client/vc_widget.c

   1 /*
   2 * Copyright (c) 2011-2015 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 <aul.h>
  18 #include <system_info.h>
  19 #include <Ecore_Wayland.h>
  20 #include "vc_cmd_db.h"
  21 #include "vc_command.h"
  22 #include "vc_config_mgr.h"
  23 #include "vc_info_parser.h"
  24 #include "vc_main.h"
  25 #include "vc_widget_client.h"
  26 #include "vc_widget_dbus.h"
  27 #include "voice_control_command.h"
  28 #include "voice_control_command_expand.h"
  29 #include "voice_control_internal.h"
  30 #include "voice_control_widget.h"
  31
  32
  33 #define VC_WIDGET_CONFIG_HANDLE 200000
  34
  35 static Ecore_Event_Handler* g_focus_in_handler = NULL;
  36 static Ecore_Event_Handler* g_focus_out_handler = NULL;
  37
  38 static Ecore_Timer* g_w_start_timer = NULL;
  39 static Ecore_Timer* g_w_notify_error_timer = NULL;
  40 static Ecore_Timer* g_w_notify_state_timer = NULL;
  41 static Ecore_Timer* g_w_notify_result_timer = NULL;
  42
  43 static int g_daemon_pid = 0;
  44
  45 static int g_feature_enabled = -1;
  46
  47 static Eina_Bool __vc_widget_notify_state_changed(void *data);
  48 static Eina_Bool __vc_widget_notify_error(void *data);
  49
  50 static int __vc_widget_get_feature_enabled()
  51 {
  52         if (0 == g_feature_enabled) {
  53                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Voice control feature NOT supported");
  54                 return VC_ERROR_NOT_SUPPORTED;
  55         } else if (-1 == g_feature_enabled) {
  56                 bool vc_supported = false;
  57                 bool mic_supported = false;
  58                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  59                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  60                                 if (false == vc_supported || false == mic_supported) {
  61                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Voice control feature NOT supported");
  62                                         g_feature_enabled = 0;
  63                                         return VC_ERROR_NOT_SUPPORTED;
  64                                 }
  65
  66                                 g_feature_enabled = 1;
  67                         } else {
  68                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get feature value");
  69                                 return VC_ERROR_NOT_SUPPORTED;
  70                         }
  71                 } else {
  72                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get feature value");
  73                         return VC_ERROR_NOT_SUPPORTED;
  74                 }
  75         }
  76
  77         return 0;
  78 }
  79
  80 const char* vc_tag()
  81 {
  82         return TAG_VCW;
  83 }
  84
  85 static const char* __vc_widget_get_error_code(vc_error_e err)
  86 {
  87         switch (err) {
  88         case VC_ERROR_NONE:             return "VC_ERROR_NONE";
  89         case VC_ERROR_OUT_OF_MEMORY:    return "VC_ERROR_OUT_OF_MEMORY";
  90         case VC_ERROR_IO_ERROR:         return "VC_ERROR_IO_ERROR";
  91         case VC_ERROR_INVALID_PARAMETER:return "VC_ERROR_INVALID_PARAMETER";
  92         case VC_ERROR_TIMED_OUT:        return "VC_ERROR_TIMED_OUT";
  93         case VC_ERROR_INVALID_STATE:    return "VC_ERROR_INVALID_STATE";
  94         case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
  95         case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
  96         default:                        return "Invalid error code";
  97         }
  98         return NULL;
  99 }
 100
 101 static int __vc_widget_convert_config_error_code(vc_config_error_e code)
 102 {
 103         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
 104         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
 105         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
 106         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
 107         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
 108         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
 109         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
 110         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
 111
 112         return VC_ERROR_NONE;
 113 }
 114
 115 static void __vc_widget_lang_changed_cb(const char* before_lang, const char* current_lang)
 116 {
 117         SLOG(LOG_DEBUG, TAG_VCW, "Lang changed : Before lang(%s) Current lang(%s)",
 118                  before_lang, current_lang);
 119
 120         vc_current_language_changed_cb callback;
 121         void* lang_user_data;
 122
 123         GSList* client_list = vc_widget_client_get_client_list();
 124
 125         vc_widget_s *widget_data = NULL;
 126         vc_h vc_w = NULL;
 127
 128         int count = g_slist_length(client_list);
 129         int i;
 130         for (i = 0; i < count; i++) {
 131                 widget_data = g_slist_nth_data(client_list, i);
 132                 if (NULL != widget_data) {
 133                         vc_w = widget_data->vc;
 134
 135                         vc_widget_client_get_current_lang_changed_cb(vc_w, &callback, &lang_user_data);
 136
 137                         if (NULL != callback) {
 138                                 vc_widget_client_use_callback(vc_w);
 139                                 callback(before_lang, current_lang, lang_user_data);
 140                                 vc_widget_client_not_use_callback(vc_w);
 141                                 SLOG(LOG_DEBUG, TAG_VCW, "Language changed callback is called");
 142                         } else {
 143                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Language changed callback is null");
 144                         }
 145                 }
 146         }
 147         return;
 148 }
 149
 150 int vc_widget_initialize(vc_h* vc_w)
 151 {
 152         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Initialize");
 153
 154         if (0 != __vc_widget_get_feature_enabled()) {
 155                 SLOG(LOG_ERROR, TAG_VCW, "@@@ [Widget] not supported");
 156                 return VC_ERROR_NOT_SUPPORTED;
 157         }
 158
 159         if (NULL == vc_w) {
 160                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 161                 return VC_ERROR_INVALID_PARAMETER;
 162         }
 163
 164         if (0 == vc_widget_client_get_count()) {
 165                 if (0 != vc_widget_dbus_open_connection()) {
 166                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to open connection");
 167                         return VC_ERROR_OPERATION_FAILED;
 168                 }
 169         }
 170
 171         if (0 != vc_widget_client_create(vc_w)) {
 172                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create client!!!!!");
 173                 return VC_ERROR_OUT_OF_MEMORY;
 174         }
 175
 176         /* TODO - each handle? */
 177         int ret = vc_config_mgr_initialize((*vc_w)->handle);
 178         if (0 != ret) {
 179                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to init config manager : %s",
 180                          __vc_widget_get_error_code(__vc_widget_convert_config_error_code(ret)));
 181                 vc_widget_client_destroy((*vc_w));
 182                 return __vc_widget_convert_config_error_code(ret);
 183         }
 184
 185         ret = vc_config_mgr_set_lang_cb((*vc_w)->handle, __vc_widget_lang_changed_cb);
 186         if (0 != ret) {
 187                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set config changed : %d", ret);
 188                 vc_config_mgr_finalize((*vc_w)->handle);
 189                 vc_widget_client_destroy((*vc_w));
 190                 return __vc_widget_convert_config_error_code(ret);
 191         }
 192
 193         if (1 == vc_widget_client_get_count()) {
 194                 ret = vc_db_initialize();
 195                 if (0 != ret) {
 196                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize DB : %d", ret);
 197                         vc_config_mgr_finalize((*vc_w)->handle);
 198                         vc_widget_client_destroy((*vc_w));
 199                         return ret;
 200                 }
 201         }
 202
 203         SLOG(LOG_DEBUG, TAG_VCW, "[Success] uid(%d)", (*vc_w)->handle);
 204
 205         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 206
 207         return VC_ERROR_NONE;
 208 }
 209
 210 static void __vc_widget_internal_unprepare(vc_h vc_w)
 211 {
 212         int ret = vc_widget_dbus_request_finalize(getpid());
 213         if (0 != ret) {
 214                 SLOG(LOG_WARN, TAG_VCW, "[ERROR] Fail to request finalize : %s", __vc_widget_get_error_code(ret));
 215         }
 216
 217         if (NULL != g_focus_in_handler) {
 218                 ecore_event_handler_del(g_focus_in_handler);
 219                 g_focus_in_handler = NULL;
 220         }
 221         if (NULL != g_focus_out_handler) {
 222                 ecore_event_handler_del(g_focus_out_handler);
 223                 g_focus_out_handler = NULL;
 224         }
 225
 226         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
 227         if (0 != ret)
 228                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_WIDGET, ret);
 229
 230         return;
 231 }
 232
 233 static void __vc_widget_delete_timer()
 234 {
 235         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] timers are deleted");
 236         if (NULL != g_w_start_timer) {
 237                 ecore_timer_del(g_w_start_timer);
 238                 g_w_start_timer = NULL;
 239         }
 240         if (NULL != g_w_notify_error_timer) {
 241                 ecore_timer_del(g_w_notify_error_timer);
 242                 g_w_notify_error_timer = NULL;
 243         }
 244         if (NULL != g_w_notify_state_timer) {
 245                 ecore_timer_del(g_w_notify_state_timer);
 246                 g_w_notify_state_timer = NULL;
 247         }
 248         if (NULL != g_w_notify_result_timer) {
 249                 ecore_timer_del(g_w_notify_result_timer);
 250                 g_w_notify_result_timer = NULL;
 251         }
 252         return;
 253 }
 254
 255 int vc_widget_deinitialize(vc_h vc_w)
 256 {
 257         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Deinitialize");
 258
 259         if (false == vc_widget_client_is_valid(vc_w)) {
 260                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NOT initialized");
 261                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 262                 return VC_ERROR_INVALID_STATE;
 263         }
 264
 265         vc_state_e state;
 266         vc_widget_client_get_state(vc_w, &state);
 267         vc_widget_s* widget = widget_get(vc_w);
 268
 269         /* check state */
 270         switch (state) {
 271         case VC_STATE_READY:
 272                 if (1 == vc_widget_client_get_count()) {
 273                         __vc_widget_internal_unprepare(vc_w);
 274                 }
 275                 /* no break. need to next step*/
 276         case VC_STATE_INITIALIZED:
 277                 if (NULL != widget && NULL != widget->conn_timer) {
 278                         SLOG(LOG_DEBUG, TAG_VCW, "Connect Timer is deleted");
 279                         ecore_timer_del(widget->conn_timer);
 280                         widget->conn_timer = NULL;
 281                 }
 282
 283                 vc_config_mgr_unset_lang_cb(vc_w->handle);
 284                 vc_config_mgr_finalize(vc_w->handle);
 285
 286                 /* Free resources */
 287                 vc_widget_client_destroy(vc_w);
 288                 vc_w = NULL;
 289                 break;
 290         case VC_STATE_NONE:
 291                 break;
 292         }
 293
 294         __vc_widget_delete_timer();
 295
 296         SLOG(LOG_DEBUG, TAG_VCW, "Success: destroy");
 297
 298         if (0 == vc_widget_client_get_count()) {
 299                 int ret = vc_db_finalize();
 300                 if (0 != ret) {
 301                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to finalize DB, ret(%d)", ret);
 302                 }
 303
 304                 if (0 != vc_widget_dbus_close_connection()) {
 305                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to close connection");
 306                 }
 307         }
 308
 309         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 310
 311         return VC_ERROR_NONE;
 312 }
 313
 314 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
 315 {
 316         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Focus changed");
 317
 318         int ret;
 319         if (ECORE_WL_EVENT_FOCUS_IN == type) {
 320                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set foreground");
 321                 ret = vc_widget_dbus_set_foreground(getpid(), true);
 322                 if (0 != ret) {
 323                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground (true) : %d", ret);
 324                 }
 325         } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
 326                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
 327                 ret = vc_widget_dbus_set_foreground(getpid(), false);
 328                 if (0 != ret) {
 329                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground (false) : %d", ret);
 330                 }
 331         } else {
 332                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ type(%d) is NOT valid", type);
 333         }
 334
 335         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 336         SLOG(LOG_DEBUG, TAG_VCW, "");
 337
 338         return ECORE_CALLBACK_RENEW;
 339 }
 340
 341 static Eina_Bool __vc_widget_connect_daemon(void *data)
 342 {
 343         vc_h vc_w = (vc_h)data;
 344
 345         /* Send hello */
 346         if (0 != vc_widget_dbus_request_hello()) {
 347                 return EINA_TRUE;
 348         }
 349
 350         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Connect daemon");
 351
 352         vc_widget_s* widget = widget_get(vc_w);
 353         if (NULL != widget) {
 354                 widget->conn_timer = NULL;
 355         }
 356
 357         /* request initialization */
 358         int ret = -1;
 359         int service_state = 0;
 360         ret = vc_widget_dbus_request_initialize(getpid(), &service_state, &g_daemon_pid);
 361
 362         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 363                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
 364
 365                 vc_widget_client_set_error(vc_w, VC_ERROR_ENGINE_NOT_FOUND);
 366                 g_w_notify_error_timer = ecore_timer_add(0, __vc_widget_notify_error, vc_w);
 367
 368                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 369                 return EINA_FALSE;
 370
 371         } else if (VC_ERROR_INVALID_PARAMETER == ret) {
 372                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Invalid Parameter");
 373         } else if (VC_ERROR_NONE != ret) {
 374                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
 375
 376                 vc_widget_client_set_error(vc_w, VC_ERROR_TIMED_OUT);
 377                 g_w_notify_error_timer = ecore_timer_add(0, __vc_widget_notify_error, vc_w);
 378
 379                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 380                 return EINA_FALSE;
 381         }
 382
 383         vc_widget_client_set_service_state(vc_w, (vc_service_state_e)service_state);
 384
 385         if (NULL == g_focus_in_handler)
 386                 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
 387         if (NULL == g_focus_out_handler)
 388                 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
 389
 390         char appid[1024] = {'\0',};
 391         aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
 392
 393         int status = aul_app_get_status(appid);
 394         if (status == STATUS_FOCUS) {
 395                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set foreground");
 396                 ret = vc_widget_dbus_set_foreground(getpid(), true);
 397                 if (0 != ret) {
 398                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground (true) : %d", ret);
 399                 }
 400         }
 401
 402         vc_widget_client_set_state(vc_w, VC_STATE_READY);
 403         g_w_notify_state_timer = ecore_timer_add(0, __vc_widget_notify_state_changed, vc_w);
 404
 405         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 406
 407         return EINA_FALSE;
 408 }
 409
 410 int vc_widget_prepare(vc_h vc_w)
 411 {
 412         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Prepare");
 413
 414         vc_state_e state;
 415         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 416                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 417                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 418                 return VC_ERROR_INVALID_STATE;
 419         }
 420
 421         /* check state */
 422         if (state != VC_STATE_INITIALIZED) {
 423                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
 424                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 425                 return VC_ERROR_INVALID_STATE;
 426         }
 427
 428         vc_widget_s* widget = widget_get(vc_w);
 429         if (NULL == widget) {
 430                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get widget handle");
 431                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 432                 return VC_ERROR_INVALID_STATE;
 433         }
 434
 435         widget->conn_timer = ecore_timer_add(0, __vc_widget_connect_daemon, (void*)vc_w);
 436
 437         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 438
 439         return VC_ERROR_NONE;
 440 }
 441
 442 int vc_widget_unprepare(vc_h vc_w)
 443 {
 444         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Unprepare");
 445
 446         vc_state_e state;
 447         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 448                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 449                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 450                 return VC_ERROR_INVALID_STATE;
 451         }
 452
 453         /* check state */
 454         if (state != VC_STATE_READY) {
 455                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 456                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 457                 return VC_ERROR_INVALID_STATE;
 458         }
 459
 460         __vc_widget_internal_unprepare(vc_w);
 461
 462         vc_widget_client_set_state(vc_w, VC_STATE_INITIALIZED);
 463         g_w_notify_state_timer = ecore_timer_add(0, __vc_widget_notify_state_changed, vc_w);
 464
 465         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 466
 467         return VC_ERROR_NONE;
 468 }
 469
 470 int vc_widget_enable_asr_result(vc_h vc_w, bool enable)
 471 {
 472         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Enable asr result");
 473
 474         vc_state_e state;
 475         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 476                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 477                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 478                 return VC_ERROR_INVALID_STATE;
 479         }
 480
 481         /* check state */
 482         if (state != VC_STATE_READY) {
 483                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 484                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 485                 return VC_ERROR_INVALID_STATE;
 486         }
 487
 488         int count = 0;
 489         int ret = -1;
 490
 491         do {
 492                 ret = vc_widget_dbus_request_enable_asr_result(getpid(), enable);
 493                 if (0 != ret) {
 494                         if (VC_ERROR_TIMED_OUT != ret) {
 495                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to enable asr result : %s", __vc_widget_get_error_code(ret));
 496                                 break;
 497                         } else {
 498                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry to enable asr result : %s", __vc_widget_get_error_code(ret));
 499                                 usleep(10000);
 500                                 count++;
 501                                 if (VC_RETRY_COUNT == count) {
 502                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 503                                         break;
 504                                 }
 505                         }
 506                 }
 507         } while (0 != ret);
 508
 509         vc_widget_client_set_asr_result_enabled(vc_w, enable);
 510
 511         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 512
 513         return ret;
 514 }
 515
 516 int vc_widget_foreach_supported_languages(vc_h vc_w, vc_supported_language_cb callback, void* user_data)
 517 {
 518         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Foreach Supported Language");
 519
 520         if (NULL == callback) {
 521                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 522                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 523                 return VC_ERROR_INVALID_PARAMETER;
 524         }
 525
 526         vc_state_e state;
 527         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 528                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 529                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 530                 return VC_ERROR_INVALID_STATE;
 531         }
 532
 533         int ret = -1;
 534         ret = vc_config_mgr_get_language_list(callback, user_data);
 535         if (0 != ret) {
 536                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 537                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get languages : %s", __vc_widget_get_error_code(ret));
 538         }
 539
 540         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 541
 542         return VC_ERROR_NONE;
 543 }
 544
 545 int vc_widget_get_current_language(vc_h vc_w, char** language)
 546 {
 547         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Get Current Language");
 548
 549         if (NULL == language) {
 550                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 551                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 552                 return VC_ERROR_INVALID_PARAMETER;
 553         }
 554
 555         vc_state_e state;
 556         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 557                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 558                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 559                 return VC_ERROR_INVALID_STATE;
 560         }
 561
 562         int ret = -1;
 563         ret = vc_config_mgr_get_default_language(language);
 564         if (0 != ret) {
 565                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 566                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get current languages : %s", __vc_widget_get_error_code(ret));
 567         }
 568
 569         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 570
 571         return ret;
 572 }
 573
 574 int vc_widget_get_state(vc_h vc_w, vc_state_e* state)
 575 {
 576         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Get State");
 577
 578         if (NULL == state) {
 579                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 580                 return VC_ERROR_INVALID_PARAMETER;
 581         }
 582
 583         vc_state_e temp;
 584         if (0 != vc_widget_client_get_state(vc_w, &temp)) {
 585                 SLOG(LOG_DEBUG, TAG_VCW, "[ERROR] A handle is not available");
 586                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 587                 return VC_ERROR_INVALID_STATE;
 588         }
 589
 590         *state = temp;
 591
 592         switch (*state) {
 593         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'None'");            break;
 594         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Created'");         break;
 595         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Ready'");           break;
 596         default:                        SLOG(LOG_ERROR, TAG_VCW, "Invalid state");
 597         }
 598
 599         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 600
 601         return VC_ERROR_NONE;
 602 }
 603
 604 int vc_widget_get_service_state(vc_h vc_w, vc_service_state_e* state)
 605 {
 606         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Get Service State");
 607
 608         if (NULL == state) {
 609                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 610                 return VC_ERROR_INVALID_PARAMETER;
 611         }
 612
 613         vc_state_e temp;
 614         if (0 != vc_widget_client_get_state(vc_w, &temp)) {
 615                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 616                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 617                 return VC_ERROR_INVALID_STATE;
 618         }
 619
 620         if (temp != VC_STATE_READY) {
 621                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 622                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 623                 return VC_ERROR_INVALID_STATE;
 624         }
 625
 626         /* get service state */
 627         vc_service_state_e service_state;
 628         if (0 != vc_widget_client_get_service_state(vc_w, &service_state)) {
 629                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get service state");
 630                 return VC_ERROR_OPERATION_FAILED;
 631         }
 632
 633         *state = service_state;
 634
 635         switch (*state) {
 636         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'None'");            break;
 637         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Ready'");           break;
 638         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Recording'");       break;
 639         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Processing'");      break;
 640         default:                                SLOG(LOG_ERROR, TAG_VCW, "Invalid service state");
 641         }
 642
 643         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 644
 645         return VC_ERROR_NONE;
 646 }
 647
 648 int vc_widget_set_foreground(vc_h vc_w, bool value)
 649 {
 650         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Set foreground state");
 651
 652         vc_state_e state;
 653         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 654                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
 655                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 656                 return VC_ERROR_INVALID_STATE;
 657         }
 658
 659         /* check state */
 660         if (state != VC_STATE_READY) {
 661                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 662                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 663                 return VC_ERROR_INVALID_STATE;
 664         }
 665
 666         SLOG(LOG_DEBUG, TAG_VCW, "Set foreground : pid(%d) value(%s)", getpid(), value ? "true" : "false");
 667         int ret = vc_widget_dbus_set_foreground(getpid(), value);
 668         if (0 != ret) {
 669                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 670                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground : %s", __vc_widget_get_error_code(ret));
 671         }
 672
 673         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 674
 675         return VC_ERROR_NONE;
 676 }
 677
 678 int vc_widget_is_format_supported(vc_h vc_w, vc_cmd_format_e format, bool* support)
 679 {
 680         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Is command type supported");
 681
 682         vc_state_e state;
 683         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 684                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
 685                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 686                 return VC_ERROR_INVALID_STATE;
 687         }
 688
 689         /* check support */
 690         bool non_fixed_support = false;
 691         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 692                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get nonfixed support info");
 693         }
 694
 695         switch (format) {
 696         case VC_CMD_FORMAT_FIXED:               *support = true;                break;
 697         case VC_CMD_FORMAT_FIXED_AND_VFIXED:    *support = true;                break;
 698         case VC_CMD_FORMAT_VFIXED_AND_FIXED:    *support = true;                break;
 699         case VC_CMD_FORMAT_FIXED_AND_NONFIXED:  *support = non_fixed_support;   break;
 700         case VC_CMD_FORMAT_NONFIXED_AND_FIXED:  *support = non_fixed_support;   break;
 701         default:                                *support = false;               break;
 702         }
 703
 704         SLOG(LOG_ERROR, TAG_VCW, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 705
 706         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 707
 708         return VC_ERROR_NONE;
 709 }
 710
 711 /**
 712 * @brief Starts recognition.
 713 *
 714 * @param[in] stop_by_silence Silence detection option
 715 *
 716 * @return 0 on success, otherwise a negative error value
 717 * @retval #VC_ERROR_NONE Successful
 718 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
 719 * @retval #VC_ERROR_INVALID_STATE Invalid state
 720 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 721 *
 722 * @pre The state should be #VC_STATE_READY.
 723 * @post It will invoke vc_state_changed_cb(), if you register a callback with vc_state_changed_cb(). \n
 724 * If this function succeeds, the state will be #VC_STATE_RECORDING.
 725 *
 726 * @see vc_widget_stop()
 727 * @see vc_widget_cancel()
 728 * @see vc_state_changed_cb()
 729 */
 730 #if 0
 731 int vc_widget_start(bool stop_by_silence, vc_cmd_group_h vc_group)
 732 {
 733         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Start");
 734
 735         vc_state_e state;
 736         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 737                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 738                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 739                 return VC_ERROR_INVALID_STATE;
 740         }
 741
 742         /* check state */
 743         if (state != VC_STATE_READY) {
 744                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 745                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 746                 return VC_ERROR_INVALID_STATE;
 747         }
 748
 749         /* Check service state */
 750         vc_service_state_e service_state = -1;
 751         vc_widget_client_get_service_state(g_vc_w, &service_state);
 752         if (service_state != VC_SERVICE_STATE_READY) {
 753                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'READY'");
 754                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 755                 return VC_ERROR_INVALID_STATE;
 756         }
 757
 758         int ret = vc_widget_client_set_command_group(g_vc_w, vc_group);
 759         if (0 != ret) {
 760                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set command to client : %d", ret);
 761                 return ret;
 762         }
 763
 764         GSList* list = NULL;
 765         if (0 > vc_cmd_group_get_cmd_list(vc_group, &list)) {
 766                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get command list : %d", ret);
 767                 return ret;
 768         }
 769
 770         ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_GROUP_TYPE_WIDGET, list, NULL);
 771         if (0 != ret) {
 772                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 773                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
 774         } else {
 775                 int count = 0;
 776                 do {
 777                         ret = vc_widget_dbus_request_start(getpid(), stop_by_silence);
 778                         if (0 != ret) {
 779                                 if (VC_ERROR_TIMED_OUT != ret) {
 780                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start : %s", __vc_widget_get_error_code(ret));
 781                                         break;
 782                                 } else {
 783                                         SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request start : %s", __vc_widget_get_error_code(ret));
 784                                         usleep(10000);
 785                                         count++;
 786                                         if (VC_RETRY_COUNT == count) {
 787                                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 788                                                 break;
 789                                         }
 790                                 }
 791                         }
 792                 } while (0 != ret);
 793         }
 794
 795         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 796
 797         return VC_ERROR_NONE;
 798 }
 799 #endif
 800
 801 /**
 802 * @brief Stop interrupt.
 803 *
 804 * @return 0 on success, otherwise a negative error value
 805 * @retval #VC_ERROR_NONE Successful
 806 * @retval #VC_ERROR_INVALID_STATE Invalid state
 807 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 808 *
 809 * @pre The state should be #VC_STATE_RECORDING.
 810 * @post It will invoke vc_state_changed_cb(), if you register a callback with vc_state_changed_cb(). \n
 811 * If this function succeeds, the state will be #VC_STATE_READY and vc_widget_result_cb() is called.
 812 *
 813 * @see vc_widget_start()
 814 * @see vc_widget_cancel()
 815 * @see vc_state_changed_cb()
 816 */
 817 #if 0
 818 int vc_widget_stop()
 819 {
 820         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Stop");
 821
 822         vc_state_e state;
 823         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 824                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 825                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 826                 return VC_ERROR_INVALID_STATE;
 827         }
 828
 829         /* check state */
 830         if (state != VC_STATE_READY) {
 831                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 832                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 833                 return VC_ERROR_INVALID_STATE;
 834         }
 835
 836         /* Check service state */
 837         vc_service_state_e service_state = -1;
 838         vc_widget_client_get_service_state(g_vc_w, &service_state);
 839         if (service_state != VC_SERVICE_STATE_RECORDING) {
 840                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'RECORDING'");
 841                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 842                 return VC_ERROR_INVALID_STATE;
 843         }
 844
 845         int ret = vc_widget_client_set_command_group(g_vc_w, NULL);
 846         if (0 != ret) {
 847                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set command to client : %d", ret);
 848                 return ret;
 849         }
 850
 851         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_GROUP_TYPE_WIDGET);
 852         if (0 != ret) {
 853                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 854                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete command group : %s", __vc_widget_get_error_code(ret));
 855         }
 856
 857         int count = 0;
 858         do {
 859                 ret = vc_widget_dbus_request_stop(getpid());
 860                 if (0 != ret) {
 861                         if (VC_ERROR_TIMED_OUT != ret) {
 862                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request stop : %s", __vc_widget_get_error_code(ret));
 863                                 break;
 864                         } else {
 865                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request stop : %s", __vc_widget_get_error_code(ret));
 866                                 usleep(10000);
 867                                 count++;
 868                                 if (VC_RETRY_COUNT == count) {
 869                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 870                                         break;
 871                                 }
 872                         }
 873                 }
 874         } while (0 != ret);
 875
 876         return 0;
 877 }
 878 #endif
 879
 880 int vc_widget_cancel(vc_h vc_w)
 881 {
 882         SLOG(LOG_DEBUG, TAG_VCW, "@@@ [Widget] Cancel Recognition");
 883
 884         vc_state_e state;
 885         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 886                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 887                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 888                 return VC_ERROR_INVALID_STATE;
 889         }
 890
 891         /* check state */
 892         if (state != VC_STATE_READY) {
 893                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 894                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 895                 return VC_ERROR_INVALID_STATE;
 896         }
 897
 898         /* Check service state */
 899         vc_service_state_e service_state = -1;
 900         vc_widget_client_get_service_state(vc_w, &service_state);
 901         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
 902                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
 903                 SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 904                 return VC_ERROR_INVALID_STATE;
 905         }
 906
 907         int count = 0;
 908         int ret = -1;
 909
 910         do {
 911                 ret = vc_widget_dbus_request_cancel(getpid());
 912                 if (0 != ret) {
 913                         if (VC_ERROR_TIMED_OUT != ret) {
 914                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request cancel : %s", __vc_widget_get_error_code(ret));
 915                                 break;
 916                         } else {
 917                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request cancel : %s", __vc_widget_get_error_code(ret));
 918                                 usleep(10000);
 919                                 count++;
 920                                 if (VC_RETRY_COUNT == count) {
 921                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 922                                         break;
 923                                 }
 924                         }
 925                 }
 926         } while (0 != ret);
 927
 928         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 929
 930         return 0;
 931 }
 932
 933 static Eina_Bool __vc_widget_notify_error(void *data)
 934 {
 935         vc_h vc_w = (vc_h)data;
 936         vc_error_cb callback = NULL;
 937         void* user_data;
 938         int reason;
 939         if (NULL == vc_w) {
 940                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 941                 return VC_ERROR_INVALID_PARAMETER;
 942         }
 943
 944         vc_widget_client_get_error_cb(vc_w, &callback, &user_data);
 945         vc_widget_client_get_error(vc_w, &reason);
 946
 947         if (NULL != callback) {
 948                 vc_widget_client_use_callback(vc_w);
 949                 callback(reason, user_data);
 950                 vc_widget_client_not_use_callback(vc_w);
 951                 SLOG(LOG_DEBUG, TAG_VCW, "[Error] callback is called");
 952         } else {
 953                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Error callback is null");
 954         }
 955
 956         return EINA_FALSE;
 957 }
 958
 959 int __vc_widget_cb_error(int reason, int daemon_pid, char* msg)
 960 {
 961         vc_state_e state;
 962
 963         GSList* client_list = vc_widget_client_get_client_list();
 964
 965         vc_widget_s *data = NULL;
 966         vc_h vc_w = NULL;
 967
 968         int count = g_slist_length(client_list);
 969         int i;
 970         for (i = 0; i < count; i++) {
 971                 data = g_slist_nth_data(client_list, i);
 972                 if (NULL != data) {
 973                         vc_w = data->vc;
 974
 975                         if (0 != vc_widget_client_get_state(vc_w, &state)) {
 976                                 SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Invalid client");
 977                                 return -1;
 978                         }
 979
 980                         /* check state */
 981                         if (state != VC_STATE_READY) {
 982                                 SLOG(LOG_ERROR, TAG_VCW, "[WARNING] not connected client yet");
 983                                 return -1;
 984                         }
 985
 986                         if (VC_ERROR_SERVICE_RESET == reason) {
 987                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] VC daemon reset");
 988
 989                                 vc_widget_client_set_state(vc_w, VC_STATE_INITIALIZED);
 990                                 __vc_widget_notify_state_changed(vc_w);
 991
 992                                 if (0 != vc_widget_prepare(vc_w)) {
 993                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to prepare");
 994                                 }
 995                         }
 996
 997                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
 998
 999                         vc_widget_client_set_error(vc_w, reason);
1000                         g_w_notify_error_timer = ecore_timer_add(0, __vc_widget_notify_error, vc_w);
1001                 }
1002         }
1003
1004         return 0;
1005 }
1006
1007 static Eina_Bool __vc_widget_start_recording(void *data)
1008 {
1009         if (NULL != g_w_start_timer) {
1010                 ecore_timer_del(g_w_start_timer);
1011                 g_w_start_timer = NULL;
1012         }
1013
1014         int ret;
1015         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
1016         if (0 != ret)
1017                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_WIDGET, ret);
1018
1019         vc_widget_send_current_command_list_cb send_command_list_cb = NULL;
1020         void* send_command_user_data = NULL;
1021         vc_cmd_list_h vc_cmd_list = NULL;
1022
1023         GSList* client_list = vc_widget_client_get_client_list();
1024
1025         vc_widget_s *widget_data = NULL;
1026         vc_h vc_w = NULL;
1027         bool widget_command = false;
1028
1029         int count = g_slist_length(client_list);
1030         int i;
1031         for (i = 0; i < count; i++) {
1032                 widget_data = g_slist_nth_data(client_list, i);
1033                 if (NULL != widget_data) {
1034                         vc_w = widget_data->vc;
1035
1036                         vc_widget_client_get_send_command_list_cb(vc_w, &send_command_list_cb, &send_command_user_data);
1037
1038                         if (NULL != send_command_list_cb) {
1039                                 vc_widget_client_use_callback(vc_w);
1040                                 send_command_list_cb(&vc_cmd_list, send_command_user_data);
1041                                 vc_widget_client_not_use_callback(vc_w);
1042                                 SLOG(LOG_DEBUG, TAG_VCW, "client command list callback called");
1043                                 if (NULL != vc_cmd_list) {
1044                                         vc_cmd_list_s* list = NULL;
1045                                         list = (vc_cmd_list_s*)vc_cmd_list;
1046                                         if (NULL == list || NULL == list->list) {
1047                                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] No registered commands from send_command_list_cb");
1048                                                 break;
1049                                         }
1050
1051                                         ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_WIDGET, list->list, NULL);
1052                                         if (0 == ret) {
1053                                                 /* widget command is valid */
1054                                                 widget_command = true;
1055                                                 SLOG(LOG_DEBUG, TAG_VCW, "Widget command is valid");
1056                                         } else {
1057                                                 ret = VC_ERROR_OPERATION_FAILED;
1058                                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
1059                                         }
1060                                 }
1061                         } else {
1062                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] User show tooltip callback is NULL");
1063                         }
1064                 }
1065         }
1066
1067         ret = -1;
1068         count = 0;
1069         while (0 != ret) {
1070                 ret = vc_widget_dbus_request_start_recording(getpid(), widget_command);
1071                 if (0 != ret) {
1072                         if (VC_ERROR_TIMED_OUT != ret) {
1073                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start recording to daemon : %s", __vc_widget_get_error_code(ret));
1074                                 return EINA_FALSE;
1075                         } else {
1076                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry start recording : %s", __vc_widget_get_error_code(ret));
1077                                 usleep(10000);
1078                                 count++;
1079                                 if (VC_RETRY_COUNT == count) {
1080                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
1081                                         return EINA_FALSE;
1082                                 }
1083                         }
1084                 }
1085         }
1086
1087         return EINA_FALSE;
1088 }
1089
1090
1091 static void __vc_widget_notify_tooltip(void *data)
1092 {
1093         bool show = (bool)data;
1094
1095         vc_widget_show_tooltip_cb callback;
1096         void* user_data;
1097
1098         GSList* client_list = vc_widget_client_get_client_list();
1099
1100         vc_widget_s *widget_data = NULL;
1101         vc_h vc_w = NULL;
1102
1103         int count = g_slist_length(client_list);
1104         int i;
1105         for (i = 0; i < count; i++) {
1106                 widget_data = g_slist_nth_data(client_list, i);
1107                 if (NULL != widget_data) {
1108                         vc_w = widget_data->vc;
1109
1110                         vc_widget_client_set_show_tooltip(vc_w, show);
1111                         vc_widget_client_get_show_tooltip_cb(vc_w, &callback, &user_data);
1112                         vc_widget_client_get_show_tooltip(vc_w, &show);
1113
1114                         if (NULL != callback) {
1115                                 vc_widget_client_use_callback(vc_w);
1116                                 callback(show, user_data);
1117                                 vc_widget_client_not_use_callback(vc_w);
1118                                 SLOG(LOG_DEBUG, TAG_VCW, "client show tooltip callback called");
1119                         } else {
1120                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Show tooltip callback is NULL");
1121                         }
1122                 }
1123         }
1124
1125         if (true == show) {
1126                 g_w_start_timer = ecore_timer_add(0, __vc_widget_start_recording, NULL);
1127         }
1128
1129         return;
1130 }
1131
1132 void __vc_widget_cb_show_tooltip(int pid, bool show)
1133 {
1134         ecore_main_loop_thread_safe_call_async(__vc_widget_notify_tooltip, (void*)show);
1135 }
1136
1137 static Eina_Bool __vc_widget_notify_result(void *data)
1138 {
1139         char* temp_text;
1140         int event;
1141         vc_cmd_list_h vc_cmd_list = NULL;
1142         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1143                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create command list");
1144                 return EINA_FALSE;
1145         }
1146
1147         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1148
1149         SECURE_SLOG(LOG_DEBUG, TAG_VCW, "Result info : result text(%s) event(%d)", temp_text, event);
1150
1151         vc_result_cb callback = NULL;
1152         void* user_data = NULL;
1153
1154         GSList* client_list = vc_widget_client_get_client_list();
1155
1156         vc_widget_s *widget_data = NULL;
1157         vc_h vc_w = NULL;
1158
1159         int count = g_slist_length(client_list);
1160         int i;
1161         for (i = 0; i < count; i++) {
1162                 widget_data = g_slist_nth_data(client_list, i);
1163                 if (NULL != widget_data) {
1164                         vc_w = widget_data->vc;
1165                         vc_widget_client_get_result_cb(vc_w, &callback, &user_data);
1166                         if (NULL == callback) {
1167                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
1168                                 return EINA_FALSE;
1169                         }
1170
1171                         vc_cmd_print_list(vc_cmd_list);
1172
1173                         vc_widget_client_use_callback(vc_w);
1174                         callback(event, vc_cmd_list, temp_text, user_data);
1175                         vc_widget_client_not_use_callback(vc_w);
1176
1177                         SLOG(LOG_DEBUG, TAG_VCW, "Widget result callback called");
1178                 }
1179         }
1180
1181         /* Release result */
1182         if (NULL != temp_text)  free(temp_text);
1183
1184         vc_cmd_list_destroy(vc_cmd_list, true);
1185
1186         return EINA_FALSE;
1187 }
1188
1189 void __vc_widget_cb_result()
1190 {
1191         g_w_notify_result_timer = ecore_timer_add(0, __vc_widget_notify_result, NULL);
1192
1193         return;
1194 }
1195
1196 bool __vc_widget_cb_asr_result(int event, const char* asr_result)
1197 {
1198         SECURE_SLOG(LOG_DEBUG, TAG_VCW, "Result info : result text(%s) event(%d)", asr_result, event);
1199
1200         vc_asr_result_cb callback = NULL;
1201         void* user_data = NULL;
1202
1203         GSList* client_list = vc_widget_client_get_client_list();
1204
1205         vc_widget_s *data = NULL;
1206         vc_h vc_w = NULL;
1207
1208         bool consumed = false;
1209         int count = g_slist_length(client_list);
1210         int i;
1211         for (i = 0; i < count; i++) {
1212                 data = g_slist_nth_data(client_list, i);
1213                 if (NULL != data) {
1214                         vc_w = data->vc;
1215                         bool enabled = false;
1216                         vc_widget_client_get_asr_result_enabled(vc_w, &enabled);
1217                         if (false == enabled)
1218                                 continue;
1219
1220                         vc_widget_client_get_asr_result_cb(vc_w, &callback, &user_data);
1221                         if (NULL == callback) {
1222                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
1223                                 continue;
1224                         }
1225
1226                         vc_widget_client_use_callback(vc_w);
1227                         consumed = callback(event, asr_result, user_data);
1228                         vc_widget_client_not_use_callback(vc_w);
1229                         if (true == consumed)
1230                                 break;
1231
1232                         SLOG(LOG_DEBUG, TAG_VCW, "Widget asr result callback called");
1233                 }
1234         }
1235
1236         return consumed;
1237 }
1238
1239 static Eina_Bool __vc_widget_notify_state_changed(void *data)
1240 {
1241         vc_h vc_w = (vc_h)data;
1242         if (NULL == vc_w) {
1243                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1244                 return VC_ERROR_INVALID_PARAMETER;
1245         }
1246
1247         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1248
1249         vc_state_changed_cb changed_callback = NULL;
1250         void* user_data;
1251
1252         vc_widget_client_get_state_changed_cb(vc_w, &changed_callback, &user_data);
1253
1254         vc_state_e current_state;
1255         vc_state_e before_state;
1256
1257         vc_widget_client_get_before_state(vc_w, &current_state, &before_state);
1258
1259         if (NULL != changed_callback) {
1260                 vc_widget_client_use_callback(vc_w);
1261                 changed_callback(before_state, current_state, user_data);
1262                 vc_widget_client_not_use_callback(vc_w);
1263                 SLOG(LOG_DEBUG, TAG_VCW, "State changed callback is called");
1264         } else {
1265                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] State changed callback is null");
1266         }
1267
1268         return EINA_FALSE;
1269 }
1270
1271 int vc_widget_set_result_cb(vc_h vc_w, vc_result_cb callback, void* user_data)
1272 {
1273         if (NULL == vc_w) {
1274                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1275                 return VC_ERROR_INVALID_PARAMETER;
1276         }
1277
1278         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1279         if (NULL == callback)
1280                 return VC_ERROR_INVALID_PARAMETER;
1281
1282         vc_state_e state;
1283         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1284                 return VC_ERROR_INVALID_STATE;
1285         }
1286
1287         /* check state */
1288         if (state != VC_STATE_INITIALIZED) {
1289                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1290                 return VC_ERROR_INVALID_STATE;
1291         }
1292
1293         vc_widget_client_set_result_cb(vc_w, callback, user_data);
1294
1295         return 0;
1296 }
1297
1298 int vc_widget_unset_result_cb(vc_h vc_w)
1299 {
1300         if (NULL == vc_w) {
1301                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1302                 return VC_ERROR_INVALID_PARAMETER;
1303         }
1304
1305         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1306         vc_state_e state;
1307         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1308                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1309                 return VC_ERROR_INVALID_STATE;
1310         }
1311
1312         /* check state */
1313         if (state != VC_STATE_INITIALIZED) {
1314                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1315                 return VC_ERROR_INVALID_STATE;
1316         }
1317
1318         vc_widget_client_set_result_cb(vc_w, NULL, NULL);
1319
1320         return 0;
1321 }
1322
1323 int vc_widget_set_show_tooltip_cb(vc_h vc_w, vc_widget_show_tooltip_cb callback, void* user_data)
1324 {
1325         if (NULL == vc_w) {
1326                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1327                 return VC_ERROR_INVALID_PARAMETER;
1328         }
1329
1330         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1331         if (NULL == callback)
1332                 return VC_ERROR_INVALID_PARAMETER;
1333
1334         vc_state_e state;
1335         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1336                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1337                 return VC_ERROR_INVALID_STATE;
1338         }
1339
1340         /* check state */
1341         if (state != VC_STATE_INITIALIZED) {
1342                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1343                 return VC_ERROR_INVALID_STATE;
1344         }
1345
1346         vc_widget_client_set_show_tooltip_cb(vc_w, callback, user_data);
1347
1348         return 0;
1349 }
1350
1351 int vc_widget_unset_show_tooltip_cb(vc_h vc_w)
1352 {
1353         if (NULL == vc_w) {
1354                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1355                 return VC_ERROR_INVALID_PARAMETER;
1356         }
1357
1358         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1359         vc_state_e state;
1360         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1361                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1362                 return VC_ERROR_INVALID_STATE;
1363         }
1364
1365         /* check state */
1366         if (state != VC_STATE_INITIALIZED) {
1367                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1368                 return VC_ERROR_INVALID_STATE;
1369         }
1370
1371         vc_widget_client_set_show_tooltip_cb(vc_w, NULL, NULL);
1372
1373         return 0;
1374 }
1375
1376 int vc_widget_set_send_current_command_list_cb(vc_h vc_w, vc_widget_send_current_command_list_cb callback, void* user_data)
1377 {
1378         if (NULL == vc_w) {
1379                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1380                 return VC_ERROR_INVALID_PARAMETER;
1381         }
1382
1383         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1384         vc_state_e state;
1385         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1386                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1387                 return VC_ERROR_INVALID_STATE;
1388         }
1389
1390         /* check state */
1391         if (state != VC_STATE_INITIALIZED) {
1392                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1393                 return VC_ERROR_INVALID_STATE;
1394         }
1395
1396         vc_widget_client_set_send_command_list_cb(vc_w, callback, user_data);
1397
1398         return 0;
1399 }
1400
1401 int vc_widget_unset_send_current_command_list_cb(vc_h vc_w)
1402 {
1403         if (NULL == vc_w) {
1404                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1405                 return VC_ERROR_INVALID_PARAMETER;
1406         }
1407
1408         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1409         vc_state_e state;
1410         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1411                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1412                 return VC_ERROR_INVALID_STATE;
1413         }
1414
1415         /* check state */
1416         if (state != VC_STATE_INITIALIZED) {
1417                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1418                 return VC_ERROR_INVALID_STATE;
1419         }
1420
1421         vc_widget_client_set_send_command_list_cb(vc_w, NULL, NULL);
1422
1423         return 0;
1424 }
1425
1426 int __vc_widget_cb_service_state(int state)
1427 {
1428         GSList* client_list = vc_widget_client_get_client_list();
1429
1430         vc_widget_s *data = NULL;
1431         vc_h vc_w = NULL;
1432
1433         int count = g_slist_length(client_list);
1434         int i;
1435         for (i = 0; i < count; i++) {
1436                 data = g_slist_nth_data(client_list, i);
1437                 if (NULL != data) {
1438                         vc_w = data->vc;
1439
1440                         vc_service_state_e current_state = (vc_service_state_e)state;
1441                         vc_service_state_e before_state;
1442                         vc_widget_client_get_service_state(vc_w, &before_state);
1443
1444                         if (current_state == before_state) {
1445                                 continue;
1446                         }
1447
1448                         SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
1449                                 before_state, current_state);
1450
1451                         /* Save service state */
1452                         vc_widget_client_set_service_state(vc_w, current_state);
1453
1454                         vc_service_state_changed_cb callback = NULL;
1455                         void* service_user_data = NULL;
1456                         vc_widget_client_get_service_state_changed_cb(vc_w, &callback, &service_user_data);
1457
1458                         if (NULL != callback) {
1459                                 vc_widget_client_use_callback(vc_w);
1460                                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1461                                 vc_widget_client_not_use_callback(vc_w);
1462                                 SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
1463                         } else {
1464                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Service state changed callback is null");
1465                         }
1466                 }
1467         }
1468
1469         return 0;
1470 }
1471
1472 int vc_widget_set_service_state_changed_cb(vc_h vc_w, vc_service_state_changed_cb callback, void* user_data)
1473 {
1474         if (NULL == vc_w) {
1475                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1476                 return VC_ERROR_INVALID_PARAMETER;
1477         }
1478
1479         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1480         vc_state_e state;
1481         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1482                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1483                 return VC_ERROR_INVALID_STATE;
1484         }
1485
1486         /* check state */
1487         if (state != VC_STATE_INITIALIZED) {
1488                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1489                 return VC_ERROR_INVALID_STATE;
1490         }
1491
1492         vc_widget_client_set_service_state_changed_cb(vc_w, callback, user_data);
1493
1494         return 0;
1495 }
1496
1497 int vc_widget_unset_service_state_changed_cb(vc_h vc_w)
1498 {
1499         if (NULL == vc_w) {
1500                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1501                 return VC_ERROR_INVALID_PARAMETER;
1502         }
1503
1504         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1505         vc_state_e state;
1506         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1507                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1508                 return VC_ERROR_INVALID_STATE;
1509         }
1510
1511         /* check state */
1512         if (state != VC_STATE_INITIALIZED) {
1513                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1514                 return VC_ERROR_INVALID_STATE;
1515         }
1516
1517         vc_widget_client_set_service_state_changed_cb(vc_w, NULL, NULL);
1518
1519         return 0;
1520 }
1521
1522 int vc_widget_set_state_changed_cb(vc_h vc_w, vc_state_changed_cb callback, void* user_data)
1523 {
1524         if (NULL == vc_w) {
1525                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1526                 return VC_ERROR_INVALID_PARAMETER;
1527         }
1528
1529         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1530         if (NULL == callback)
1531                 return VC_ERROR_INVALID_PARAMETER;
1532
1533         vc_state_e state;
1534         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1535                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1536                 return VC_ERROR_INVALID_STATE;
1537         }
1538
1539         /* check state */
1540         if (state != VC_STATE_INITIALIZED) {
1541                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1542                 return VC_ERROR_INVALID_STATE;
1543         }
1544
1545         vc_widget_client_set_state_changed_cb(vc_w, callback, user_data);
1546
1547         return 0;
1548 }
1549
1550 int vc_widget_unset_state_changed_cb(vc_h vc_w)
1551 {
1552         if (NULL == vc_w) {
1553                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1554                 return VC_ERROR_INVALID_PARAMETER;
1555         }
1556
1557         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1558         vc_state_e state;
1559         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1560                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1561                 return VC_ERROR_INVALID_STATE;
1562         }
1563
1564         /* check state */
1565         if (state != VC_STATE_INITIALIZED) {
1566                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1567                 return VC_ERROR_INVALID_STATE;
1568         }
1569
1570         vc_widget_client_set_state_changed_cb(vc_w, NULL, NULL);
1571
1572         return 0;
1573 }
1574
1575 int vc_widget_set_asr_result_cb(vc_h vc_w, vc_asr_result_cb callback, void* user_data)
1576 {
1577         if (NULL == vc_w) {
1578                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1579                 return VC_ERROR_INVALID_PARAMETER;
1580         }
1581
1582         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1583         if (NULL == callback)
1584                 return VC_ERROR_INVALID_PARAMETER;
1585
1586         vc_state_e state;
1587         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1588                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1589                 return VC_ERROR_INVALID_STATE;
1590         }
1591
1592         /* check state */
1593         if (state != VC_STATE_INITIALIZED) {
1594                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1595                 return VC_ERROR_INVALID_STATE;
1596         }
1597
1598         vc_widget_client_set_asr_result_cb(vc_w, callback, user_data);
1599
1600         return 0;
1601 }
1602
1603 int vc_widget_unset_asr_result_cb(vc_h vc_w)
1604 {
1605         if (NULL == vc_w) {
1606                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1607                 return VC_ERROR_INVALID_PARAMETER;
1608         }
1609
1610         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1611         vc_state_e state;
1612         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1613                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1614                 return VC_ERROR_INVALID_STATE;
1615         }
1616
1617         /* check state */
1618         if (state != VC_STATE_INITIALIZED) {
1619                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1620                 return VC_ERROR_INVALID_STATE;
1621         }
1622
1623         vc_widget_client_set_asr_result_cb(vc_w, NULL, NULL);
1624
1625         return 0;
1626 }
1627
1628 int vc_widget_set_current_language_changed_cb(vc_h vc_w, vc_current_language_changed_cb callback, void* user_data)
1629 {
1630         if (NULL == vc_w) {
1631                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1632                 return VC_ERROR_INVALID_PARAMETER;
1633         }
1634
1635         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1636         if (NULL == callback)
1637                 return VC_ERROR_INVALID_PARAMETER;
1638
1639         vc_state_e state;
1640         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1641                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1642                 return VC_ERROR_INVALID_STATE;
1643         }
1644
1645         /* check state */
1646         if (state != VC_STATE_INITIALIZED) {
1647                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1648                 return VC_ERROR_INVALID_STATE;
1649         }
1650
1651         vc_widget_client_set_current_lang_changed_cb(vc_w, callback, user_data);
1652
1653         return 0;
1654 }
1655
1656 int vc_widget_unset_current_language_changed_cb(vc_h vc_w)
1657 {
1658         if (NULL == vc_w) {
1659                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1660                 return VC_ERROR_INVALID_PARAMETER;
1661         }
1662
1663         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1664         vc_state_e state;
1665         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1666                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1667                 return VC_ERROR_INVALID_STATE;
1668         }
1669
1670         /* check state */
1671         if (state != VC_STATE_INITIALIZED) {
1672                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1673                 return VC_ERROR_INVALID_STATE;
1674         }
1675
1676         vc_widget_client_set_current_lang_changed_cb(vc_w, NULL, NULL);
1677
1678         return 0;
1679 }
1680
1681 int vc_widget_set_error_cb(vc_h vc_w, vc_error_cb callback, void* user_data)
1682 {
1683         if (NULL == vc_w) {
1684                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1685                 return VC_ERROR_INVALID_PARAMETER;
1686         }
1687
1688         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1689         if (NULL == callback)
1690                 return VC_ERROR_INVALID_PARAMETER;
1691
1692         vc_state_e state;
1693         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1694                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1695                 return VC_ERROR_INVALID_STATE;
1696         }
1697
1698         /* check state */
1699         if (state != VC_STATE_INITIALIZED) {
1700                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1701                 return VC_ERROR_INVALID_STATE;
1702         }
1703
1704         vc_widget_client_set_error_cb(vc_w, callback,  user_data);
1705
1706         return 0;
1707 }
1708
1709 int vc_widget_unset_error_cb(vc_h vc_w)
1710 {
1711         if (NULL == vc_w) {
1712                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
1713                 return VC_ERROR_INVALID_PARAMETER;
1714         }
1715
1716         SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
1717         vc_state_e state;
1718         if (0 != vc_widget_client_get_state(vc_w, &state)) {
1719                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1720                 return VC_ERROR_INVALID_STATE;
1721         }
1722
1723         /* check state */
1724         if (state != VC_STATE_INITIALIZED) {
1725                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1726                 return VC_ERROR_INVALID_STATE;
1727         }
1728
1729         vc_widget_client_set_error_cb(vc_w, NULL, NULL);
1730
1731         return 0;
1732 }
1733