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
  18 #include "vc_command.h"
  19 #include "vc_config_mgr.h"
  20 #include "vc_info_parser.h"
  21 #include "vc_main.h"
  22 #include "vc_widget_client.h"
  23 #include "vc_widget_dbus.h"
  24 #include "voice_control_command.h"
  25 #include "voice_control_command_expand.h"
  26 #include "voice_control_widget.h"
  27
  28
  29 #define VC_WIDGET_CONFIG_HANDLE 200000
  30
  31 static Ecore_Timer* g_w_connect_timer = NULL;
  32
  33 static Ecore_Timer* g_w_start_timer = NULL;
  34 static Ecore_Timer* g_w_tooltip_timer = NULL;
  35
  36 static vc_h g_vc_w = NULL;
  37
  38 static Eina_Bool __vc_widget_notify_state_changed(void *data);
  39 static Eina_Bool __vc_widget_notify_error(void *data);
  40
  41 const char* vc_tag()
  42 {
  43         return TAG_VCW;
  44 }
  45
  46 static const char* __vc_widget_get_error_code(vc_error_e err)
  47 {
  48         switch (err) {
  49         case VC_ERROR_NONE:             return "VC_ERROR_NONE";
  50         case VC_ERROR_OUT_OF_MEMORY:    return "VC_ERROR_OUT_OF_MEMORY";
  51         case VC_ERROR_IO_ERROR:         return "VC_ERROR_IO_ERROR";
  52         case VC_ERROR_INVALID_PARAMETER:return "VC_ERROR_INVALID_PARAMETER";
  53         case VC_ERROR_TIMED_OUT:        return "VC_ERROR_TIMED_OUT";
  54         case VC_ERROR_INVALID_STATE:    return "VC_ERROR_INVALID_STATE";
  55         case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
  56         case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
  57         default:                        return "Invalid error code";
  58         }
  59         return NULL;
  60 }
  61
  62 static int __vc_widget_convert_config_error_code(vc_config_error_e code)
  63 {
  64         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
  65         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
  66         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
  67         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
  68         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
  69         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
  70         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
  71         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
  72
  73         return VC_ERROR_NONE;
  74 }
  75
  76 static void __vc_widget_lang_changed_cb(const char* before_lang, const char* current_lang)
  77 {
  78         SLOG(LOG_DEBUG, TAG_VCW, "Lang changed : Before lang(%s) Current lang(%s)",
  79                  before_lang, current_lang);
  80
  81         vc_current_language_changed_cb callback;
  82         void* lang_user_data;
  83         vc_widget_client_get_current_lang_changed_cb(g_vc_w, &callback, &lang_user_data);
  84
  85         if (NULL != callback) {
  86                 vc_widget_client_use_callback(g_vc_w);
  87                 callback(before_lang, current_lang, lang_user_data);
  88                 vc_widget_client_not_use_callback(g_vc_w);
  89                 SLOG(LOG_DEBUG, TAG_VCW, "Language changed callback is called");
  90         } else {
  91                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Language changed callback is null");
  92         }
  93
  94         return;
  95 }
  96
  97 int vc_widget_initialize()
  98 {
  99         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Initialize");
 100
 101         /* check handle */
 102         if (true == vc_widget_client_is_valid(g_vc_w)) {
 103                 SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Already initialized");
 104                 return VC_ERROR_NONE;
 105         }
 106
 107         if (0 == vc_widget_client_get_count()) {
 108                 if (0 != vc_widget_dbus_open_connection()) {
 109                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to open connection");
 110                         return VC_ERROR_OPERATION_FAILED;
 111                 }
 112         } else {
 113                 SLOG(LOG_WARN, TAG_VCW, "[WARN] Already initialized");
 114                 return VC_ERROR_NONE;
 115         }
 116
 117         if (0 != vc_widget_client_create(&g_vc_w)) {
 118                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create client!!!!!");
 119                 return VC_ERROR_OUT_OF_MEMORY;
 120         }
 121
 122         int ret = vc_config_mgr_initialize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
 123         if (0 != ret) {
 124                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to init config manager : %s",
 125                          __vc_widget_get_error_code(__vc_widget_convert_config_error_code(ret)));
 126                 vc_widget_client_destroy(g_vc_w);
 127                 return __vc_widget_convert_config_error_code(ret);
 128         }
 129
 130         ret = vc_config_mgr_set_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE, __vc_widget_lang_changed_cb);
 131         if (0 != ret) {
 132                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set config changed : %d", ret);
 133                 vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
 134                 vc_widget_client_destroy(g_vc_w);
 135                 return __vc_widget_convert_config_error_code(ret);
 136         }
 137
 138         SLOG(LOG_DEBUG, TAG_VCW, "[Success] pid(%d)", g_vc_w->handle);
 139
 140         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 141         SLOG(LOG_DEBUG, TAG_VCW, " ");
 142
 143         return VC_ERROR_NONE;
 144 }
 145
 146 static void __vc_widget_internal_unprepare()
 147 {
 148         int ret = vc_widget_dbus_request_finalize(g_vc_w->handle);
 149         if (0 != ret) {
 150                 SLOG(LOG_WARN, TAG_VCW, "[ERROR] Fail to request finalize : %s", __vc_widget_get_error_code(ret));
 151         }
 152
 153         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
 154
 155         return;
 156 }
 157
 158 int vc_widget_deinitialize()
 159 {
 160         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Deinitialize");
 161
 162         if (false == vc_widget_client_is_valid(g_vc_w)) {
 163                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NOT initialized");
 164                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 165                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 166                 return VC_ERROR_INVALID_STATE;
 167         }
 168
 169         vc_state_e state;
 170         vc_widget_client_get_state(g_vc_w, &state);
 171
 172         /* check state */
 173         switch (state) {
 174         case VC_STATE_READY:
 175                 __vc_widget_internal_unprepare();
 176                 /* no break. need to next step*/
 177         case VC_STATE_INITIALIZED:
 178                 if (NULL != g_w_connect_timer) {
 179                         SLOG(LOG_DEBUG, TAG_VCW, "Connect Timer is deleted");
 180                         ecore_timer_del(g_w_connect_timer);
 181                 }
 182
 183                 vc_config_mgr_unset_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
 184                 vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
 185
 186                 /* Free resources */
 187                 vc_widget_client_destroy(g_vc_w);
 188                 g_vc_w = NULL;
 189                 break;
 190         case VC_STATE_NONE:
 191                 break;
 192         default:
 193                 break;
 194         }
 195
 196         SLOG(LOG_DEBUG, TAG_VCW, "Success: destroy");
 197
 198         if (0 != vc_widget_dbus_close_connection()) {
 199                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to close connection");
 200         }
 201
 202         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 203         SLOG(LOG_DEBUG, TAG_VCW, " ");
 204
 205         return VC_ERROR_NONE;
 206 }
 207
 208 static Eina_Bool __vc_widget_connect_daemon(void *data)
 209 {
 210         /* Send hello */
 211         if (0 != vc_widget_dbus_request_hello()) {
 212                 return EINA_TRUE;
 213         }
 214
 215         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Connect daemon");
 216
 217         /* request initialization */
 218         int ret = -1;
 219         int service_state = 0;
 220         ret = vc_widget_dbus_request_initialize(g_vc_w->handle, &service_state);
 221
 222         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 223                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
 224
 225                 vc_widget_client_set_error(g_vc_w, VC_ERROR_ENGINE_NOT_FOUND);
 226                 ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
 227
 228                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 229                 SLOG(LOG_DEBUG, TAG_VCW, "  ");
 230                 return EINA_FALSE;
 231
 232         } else if (VC_ERROR_NONE != ret) {
 233                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
 234
 235                 vc_widget_client_set_error(g_vc_w, VC_ERROR_TIMED_OUT);
 236                 ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
 237
 238                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 239                 SLOG(LOG_DEBUG, TAG_VCW, "  ");
 240                 return EINA_FALSE;
 241         }
 242
 243         vc_widget_client_set_service_state(g_vc_w, (vc_service_state_e)service_state);
 244
 245         vc_widget_client_set_state(g_vc_w, VC_STATE_READY);
 246         ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
 247
 248         g_w_connect_timer = NULL;
 249
 250         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 251         SLOG(LOG_DEBUG, TAG_VCW, "  ");
 252
 253         return EINA_FALSE;
 254 }
 255
 256 int vc_widget_prepare()
 257 {
 258         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Prepare");
 259
 260         vc_state_e state;
 261         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 262                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 263                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 264                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 265                 return VC_ERROR_INVALID_STATE;
 266         }
 267
 268         /* check state */
 269         if (state != VC_STATE_INITIALIZED) {
 270                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
 271                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 272                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 273                 return VC_ERROR_INVALID_STATE;
 274         }
 275
 276         g_w_connect_timer = ecore_timer_add(0, __vc_widget_connect_daemon, NULL);
 277
 278         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 279         SLOG(LOG_DEBUG, TAG_VCW, " ");
 280
 281         return VC_ERROR_NONE;
 282 }
 283
 284 int vc_widget_unprepare()
 285 {
 286         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Unprepare");
 287
 288         vc_state_e state;
 289         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 290                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 291                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 292                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 293                 return VC_ERROR_INVALID_STATE;
 294         }
 295
 296         /* check state */
 297         if (state != VC_STATE_READY) {
 298                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 299                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 300                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 301                 return VC_ERROR_INVALID_STATE;
 302         }
 303
 304         __vc_widget_internal_unprepare();
 305
 306         vc_widget_client_set_state(g_vc_w, VC_STATE_INITIALIZED);
 307         ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
 308
 309         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 310         SLOG(LOG_DEBUG, TAG_VCW, " ");
 311
 312         return VC_ERROR_NONE;
 313 }
 314
 315 int vc_widget_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 316 {
 317         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Foreach Supported Language");
 318
 319         if (NULL == callback) {
 320                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 321                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 322                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 323                 return VC_ERROR_INVALID_PARAMETER;
 324         }
 325
 326         vc_state_e state;
 327         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 328                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 329                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 330                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 331                 return VC_ERROR_INVALID_STATE;
 332         }
 333
 334         int ret = -1;
 335         ret = vc_config_mgr_get_language_list(callback, user_data);
 336         if (0 != ret) {
 337                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 338                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get languages : %s", __vc_widget_get_error_code(ret));
 339         }
 340
 341         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 342         SLOG(LOG_DEBUG, TAG_VCW, " ");
 343
 344         return VC_ERROR_NONE;
 345 }
 346
 347 int vc_widget_get_current_language(char** language)
 348 {
 349         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get Current Language");
 350
 351         if (NULL == language) {
 352                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 353                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 354                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 355                 return VC_ERROR_INVALID_PARAMETER;
 356         }
 357
 358         vc_state_e state;
 359         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 360                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 361                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 362                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 363                 return VC_ERROR_INVALID_STATE;
 364         }
 365
 366         int ret = -1;
 367         ret = vc_config_mgr_get_default_language(language);
 368         if (0 != ret) {
 369                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 370                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get current languages : %s", __vc_widget_get_error_code(ret));
 371         }
 372
 373         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 374         SLOG(LOG_DEBUG, TAG_VCW, " ");
 375
 376         return ret;
 377 }
 378
 379 int vc_widget_get_state(vc_state_e* state)
 380 {
 381         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get State");
 382
 383         if (NULL == state) {
 384                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 385                 return VC_ERROR_INVALID_PARAMETER;
 386         }
 387
 388         vc_state_e temp;
 389         if (0 != vc_widget_client_get_state(g_vc_w, &temp)) {
 390                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 391                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 392                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 393                 return VC_ERROR_INVALID_STATE;
 394         }
 395
 396         *state = temp;
 397
 398         switch (*state) {
 399         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'None'");            break;
 400         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Created'");         break;
 401         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Ready'");           break;
 402         default:                        SLOG(LOG_ERROR, TAG_VCW, "Invalid state");
 403         }
 404
 405         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 406         SLOG(LOG_DEBUG, TAG_VCW, " ");
 407
 408         return VC_ERROR_NONE;
 409 }
 410
 411 int vc_widget_get_service_state(vc_service_state_e* state)
 412 {
 413         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get Service State");
 414
 415         if (NULL == state) {
 416                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
 417                 return VC_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         vc_state_e temp;
 421         if (0 != vc_widget_client_get_state(g_vc_w, &temp)) {
 422                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 423                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 424                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 425                 return VC_ERROR_INVALID_STATE;
 426         }
 427
 428         if (temp != VC_STATE_READY) {
 429                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 430                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 431                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 432                 return VC_ERROR_INVALID_STATE;
 433         }
 434
 435         /* get service state */
 436         vc_service_state_e service_state;
 437         if (0 != vc_widget_client_get_service_state(g_vc_w, &service_state)) {
 438                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get service state");
 439                 return VC_ERROR_OPERATION_FAILED;
 440         }
 441
 442         *state = service_state;
 443
 444         switch (*state) {
 445         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'None'");            break;
 446         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Ready'");           break;
 447         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Recording'");       break;
 448         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Processing'");      break;
 449         default:                                SLOG(LOG_ERROR, TAG_VCW, "Invalid service state");
 450         }
 451
 452         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 453         SLOG(LOG_DEBUG, TAG_VCW, " ");
 454
 455         return VC_ERROR_NONE;
 456 }
 457
 458 int vc_widget_set_foreground(bool value)
 459 {
 460         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Set foreground state");
 461
 462         vc_state_e state;
 463         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 464                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
 465                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 466                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 467                 return VC_ERROR_INVALID_STATE;
 468         }
 469
 470         /* check state */
 471         if (state != VC_STATE_READY) {
 472                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 473                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 474                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 475                 return VC_ERROR_INVALID_STATE;
 476         }
 477
 478         SLOG(LOG_DEBUG, TAG_VCW, "Set foreground : pid(%d) value(%s)", getpid(), value ? "true" : "false");
 479         int ret = vc_widget_dbus_set_foreground(getpid(), value);
 480         if (0 != ret) {
 481                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 482                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground : %s", __vc_widget_get_error_code(ret));
 483         }
 484
 485         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 486         SLOG(LOG_DEBUG, TAG_VCW, " ");
 487
 488         return VC_ERROR_NONE;
 489 }
 490 #if 0
 491 int vc_widget_is_format_supported(vc_cmd_format_e format, bool* support)
 492 {
 493         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Is command type supported");
 494
 495         vc_state_e state;
 496         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 497                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
 498                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 499                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 500                 return VC_ERROR_INVALID_STATE;
 501         }
 502
 503         /* check support */
 504         bool non_fixed_support = false;
 505         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 506                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get nonfixed support info");
 507         }
 508
 509         switch (format) {
 510         case VC_CMD_FORMAT_FIXED:                       *support = true;                break;
 511         case VC_CMD_FORMAT_FIXED_AND_EXTRA:     *support = non_fixed_support;   break;
 512         case VC_CMD_FORMAT_EXTRA_AND_FIXED:     *support = non_fixed_support;   break;
 513         default:                                        *support = false;               break;
 514         }
 515
 516         SLOG(LOG_ERROR, TAG_VCW, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 517
 518         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 519         SLOG(LOG_DEBUG, TAG_VCW, " ");
 520
 521         return VC_ERROR_NONE;
 522 }
 523 #endif
 524 /**
 525 * @brief Starts recognition.
 526 *
 527 * @param[in] stop_by_silence Silence detection option
 528 *
 529 * @return 0 on success, otherwise a negative error value
 530 * @retval #VC_ERROR_NONE Successful
 531 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
 532 * @retval #VC_ERROR_INVALID_STATE Invalid state
 533 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 534 *
 535 * @pre The state should be #VC_STATE_READY.
 536 * @post It will invoke vc_state_changed_cb(), if you register a callback with vc_state_changed_cb(). \n
 537 * If this function succeeds, the state will be #VC_STATE_RECORDING.
 538 *
 539 * @see vc_widget_stop()
 540 * @see vc_widget_cancel()
 541 * @see vc_state_changed_cb()
 542 */
 543 #if 0
 544 int vc_widget_start(bool stop_by_silence, vc_cmd_group_h vc_group)
 545 {
 546         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Start");
 547
 548         vc_state_e state;
 549         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 550                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 551                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 552                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 553                 return VC_ERROR_INVALID_STATE;
 554         }
 555
 556         /* check state */
 557         if (state != VC_STATE_READY) {
 558                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 559                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 560                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 561                 return VC_ERROR_INVALID_STATE;
 562         }
 563
 564         /* Check service state */
 565         vc_service_state_e service_state = -1;
 566         vc_widget_client_get_service_state(g_vc_w, &service_state);
 567         if (service_state != VC_SERVICE_STATE_READY) {
 568                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'READY'");
 569                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 570                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 571                 return VC_ERROR_INVALID_STATE;
 572         }
 573
 574         int ret = vc_widget_client_set_command_group(g_vc_w, vc_group);
 575         if (0 != ret) {
 576                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set command to client : %d", ret);
 577                 return ret;
 578         }
 579
 580         GSList* list = NULL;
 581         if (0 > vc_cmd_group_get_cmd_list(vc_group, &list)) {
 582                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get command list : %d", ret);
 583                 return ret;
 584         }
 585
 586         ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_GROUP_TYPE_WIDGET, list);
 587         if (0 != ret) {
 588                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 589                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
 590         } else {
 591                 int count = 0;
 592                 do {
 593                         ret = vc_widget_dbus_request_start(g_vc_w->handle, stop_by_silence);
 594                         if (0 != ret) {
 595                                 if (VC_ERROR_TIMED_OUT != ret) {
 596                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start : %s", __vc_widget_get_error_code(ret));
 597                                         break;
 598                                 } else {
 599                                         SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request start : %s", __vc_widget_get_error_code(ret));
 600                                         usleep(10000);
 601                                         count++;
 602                                         if (VC_RETRY_COUNT == count) {
 603                                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 604                                                 break;
 605                                         }
 606                                 }
 607                         }
 608                 } while (0 != ret);
 609         }
 610
 611         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 612         SLOG(LOG_DEBUG, TAG_VCW, " ");
 613
 614         return VC_ERROR_NONE;
 615 }
 616 #endif
 617
 618 /**
 619 * @brief Stop interrupt.
 620 *
 621 * @return 0 on success, otherwise a negative error value
 622 * @retval #VC_ERROR_NONE Successful
 623 * @retval #VC_ERROR_INVALID_STATE Invalid state
 624 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 625 *
 626 * @pre The state should be #VC_STATE_RECORDING.
 627 * @post It will invoke vc_state_changed_cb(), if you register a callback with vc_state_changed_cb(). \n
 628 * If this function succeeds, the state will be #VC_STATE_READY and vc_widget_result_cb() is called.
 629 *
 630 * @see vc_widget_start()
 631 * @see vc_widget_cancel()
 632 * @see vc_state_changed_cb()
 633 */
 634 #if 0
 635 int vc_widget_stop()
 636 {
 637         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Stop");
 638
 639         vc_state_e state;
 640         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 641                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 642                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 643                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 644                 return VC_ERROR_INVALID_STATE;
 645         }
 646
 647         /* check state */
 648         if (state != VC_STATE_READY) {
 649                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 650                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 651                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 652                 return VC_ERROR_INVALID_STATE;
 653         }
 654
 655         /* Check service state */
 656         vc_service_state_e service_state = -1;
 657         vc_widget_client_get_service_state(g_vc_w, &service_state);
 658         if (service_state != VC_SERVICE_STATE_RECORDING) {
 659                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'RECORDING'");
 660                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 661                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 662                 return VC_ERROR_INVALID_STATE;
 663         }
 664
 665         int ret = vc_widget_client_set_command_group(g_vc_w, NULL);
 666         if (0 != ret) {
 667                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set command to client : %d", ret);
 668                 return ret;
 669         }
 670
 671         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_GROUP_TYPE_WIDGET);
 672         if (0 != ret) {
 673                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 674                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete command group : %s", __vc_widget_get_error_code(ret));
 675         }
 676
 677         int count = 0;
 678         do {
 679                 ret = vc_widget_dbus_request_stop(g_vc_w->handle);
 680                 if (0 != ret) {
 681                         if (VC_ERROR_TIMED_OUT != ret) {
 682                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request stop : %s", __vc_widget_get_error_code(ret));
 683                                 break;
 684                         } else {
 685                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request stop : %s", __vc_widget_get_error_code(ret));
 686                                 usleep(10000);
 687                                 count++;
 688                                 if (VC_RETRY_COUNT == count) {
 689                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 690                                         break;
 691                                 }
 692                         }
 693                 }
 694         } while (0 != ret);
 695
 696         return 0;
 697 }
 698 #endif
 699
 700 int vc_widget_cancel()
 701 {
 702         SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Cancel Recognition");
 703
 704         vc_state_e state;
 705         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 706                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 707                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 708                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 709                 return VC_ERROR_INVALID_STATE;
 710         }
 711
 712         /* check state */
 713         if (state != VC_STATE_READY) {
 714                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'");
 715                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 716                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 717                 return VC_ERROR_INVALID_STATE;
 718         }
 719
 720         /* Check service state */
 721         vc_service_state_e service_state = -1;
 722         vc_widget_client_get_service_state(g_vc_w, &service_state);
 723         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
 724                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
 725                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 726                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 727                 return VC_ERROR_INVALID_STATE;
 728         }
 729
 730         int count = 0;
 731         int ret = -1;
 732
 733         do {
 734                 ret = vc_widget_dbus_request_cancel(g_vc_w->handle);
 735                 if (0 != ret) {
 736                         if (VC_ERROR_TIMED_OUT != ret) {
 737                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request cancel : %s", __vc_widget_get_error_code(ret));
 738                                 break;
 739                         } else {
 740                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry request cancel : %s", __vc_widget_get_error_code(ret));
 741                                 usleep(10000);
 742                                 count++;
 743                                 if (VC_RETRY_COUNT == count) {
 744                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 745                                         break;
 746                                 }
 747                         }
 748                 }
 749         } while (0 != ret);
 750
 751         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 752
 753         return 0;
 754 }
 755
 756 static Eina_Bool __vc_widget_notify_error(void *data)
 757 {
 758         vc_error_cb callback = NULL;
 759         void* user_data;
 760         int reason;
 761
 762         vc_widget_client_get_error_cb(g_vc_w, &callback, &user_data);
 763         vc_widget_client_get_error(g_vc_w, &reason);
 764
 765         if (NULL != callback) {
 766                 vc_widget_client_use_callback(g_vc_w);
 767                 callback(reason, user_data);
 768                 vc_widget_client_not_use_callback(g_vc_w);
 769                 SLOG(LOG_DEBUG, TAG_VCW, "[Error] callback is called");
 770         } else {
 771                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Error callback is null");
 772         }
 773
 774         return EINA_FALSE;
 775 }
 776
 777 int __vc_widget_cb_error(int pid, int reason)
 778 {
 779         if (0 != vc_widget_client_get_handle(pid, &g_vc_w)) {
 780                 SLOG(LOG_ERROR, TAG_VCW, "Handle is not valid : pid(%d)", pid);
 781                 return -1;
 782         }
 783
 784         vc_widget_client_set_error(g_vc_w, reason);
 785         ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
 786
 787         return 0;
 788 }
 789
 790 static Eina_Bool __vc_widget_start_recording(void *data)
 791 {
 792         if (NULL != g_w_start_timer) {
 793                 ecore_timer_del(g_w_start_timer);
 794                 g_w_start_timer = NULL;
 795         }
 796
 797         vc_widget_send_current_command_list_cb send_command_list_cb = NULL;
 798         void* send_command_user_data = NULL;
 799         vc_cmd_list_h vc_cmd_list = NULL;
 800
 801         vc_widget_client_get_send_command_list_cb(g_vc_w, &send_command_list_cb, &send_command_user_data);
 802
 803         if (NULL != send_command_list_cb) {
 804                 vc_widget_client_use_callback(g_vc_w);
 805                 send_command_list_cb(&vc_cmd_list, send_command_user_data);
 806                 vc_widget_client_not_use_callback(g_vc_w);
 807                 SLOG(LOG_DEBUG, TAG_VCW, "client result callback called");
 808
 809         } else {
 810                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] User show tooltip callback is NULL");
 811         }
 812
 813         bool widget_command = false;
 814         int ret;
 815
 816         if (NULL != vc_cmd_list) {
 817                 vc_cmd_list_s* list = NULL;
 818                 list = (vc_cmd_list_s*)vc_cmd_list;
 819
 820                 ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_WIDGET, list->list);
 821                 if (0 == ret) {
 822                         /* widget command is valid */
 823                         widget_command = true;
 824                         SLOG(LOG_DEBUG, TAG_VCW, "Widget command is valid");
 825                 } else {
 826                         ret = VC_ERROR_OPERATION_FAILED;
 827                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
 828                 }
 829         }
 830
 831         ret = -1;
 832         int count = 0;
 833         while (0 != ret) {
 834                 ret = vc_widget_dbus_request_start_recording(g_vc_w->handle, widget_command);
 835                 if (0 != ret) {
 836                         if (VC_ERROR_TIMED_OUT != ret) {
 837                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start recording to daemon : %s", __vc_widget_get_error_code(ret));
 838                                 return EINA_FALSE;
 839                         } else {
 840                                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry start recording : %s", __vc_widget_get_error_code(ret));
 841                                 usleep(10000);
 842                                 count++;
 843                                 if (VC_RETRY_COUNT == count) {
 844                                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request");
 845                                         return EINA_FALSE;
 846                                 }
 847                         }
 848                 }
 849         }
 850
 851         return EINA_FALSE;
 852 }
 853
 854 static Eina_Bool __vc_widget_notify_tooltip(void *data)
 855 {
 856         if (NULL != g_w_tooltip_timer) {
 857                 ecore_timer_del(g_w_tooltip_timer);
 858                 g_w_tooltip_timer = NULL;
 859         }
 860
 861         vc_widget_show_tooltip_cb callback;
 862         void* user_data;
 863         bool show;
 864
 865         vc_widget_client_get_show_tooltip_cb(g_vc_w, &callback, &user_data);
 866         vc_widget_client_get_show_tooltip(g_vc_w, &show);
 867
 868         if (NULL != callback) {
 869                 vc_widget_client_use_callback(g_vc_w);
 870                 callback(show, user_data);
 871                 vc_widget_client_not_use_callback(g_vc_w);
 872                 SLOG(LOG_DEBUG, TAG_VCW, "client result callback called");
 873         } else {
 874                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Show tooltip callback is NULL");
 875         }
 876
 877         if (true == show) {
 878                 g_w_start_timer = ecore_timer_add(0, __vc_widget_start_recording, NULL);
 879         }
 880
 881         return EINA_FALSE;
 882 }
 883
 884 void __vc_widget_cb_show_tooltip(int pid, bool show)
 885 {
 886         if (0 != vc_widget_client_get_handle(pid, &g_vc_w)) {
 887                 SLOG(LOG_ERROR, TAG_VCW, "Handle is not valid : pid(%d)", pid);
 888                 return;
 889         }
 890
 891         vc_widget_client_set_show_tooltip(g_vc_w, show);
 892         g_w_tooltip_timer = ecore_timer_add(0, __vc_widget_notify_tooltip, NULL);
 893
 894         return;
 895 }
 896
 897 static Eina_Bool __vc_widget_notify_result(void *data)
 898 {
 899         char* temp_text;
 900         int event;
 901         vc_cmd_list_h vc_cmd_list = NULL;
 902
 903         vc_result_cb callback = NULL;
 904         void* user_data = NULL;
 905
 906         vc_widget_client_get_result_cb(g_vc_w, &callback, &user_data);
 907         if (NULL == callback) {
 908                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
 909                 return EINA_FALSE;
 910         }
 911
 912         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
 913                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create command list");
 914                 return EINA_FALSE;
 915         }
 916
 917         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
 918
 919         SLOG(LOG_DEBUG, TAG_VCW, "Result info : result text(%s) event(%d)", temp_text, event);
 920
 921         vc_cmd_print_list(vc_cmd_list);
 922
 923         vc_widget_client_use_callback(g_vc_w);
 924         callback(event, vc_cmd_list, temp_text, user_data);
 925         vc_widget_client_not_use_callback(g_vc_w);
 926
 927         SLOG(LOG_DEBUG, TAG_VCW, "Widget result callback called");
 928
 929         /* Release result */
 930         if (NULL != temp_text)  free(temp_text);
 931
 932         vc_cmd_list_destroy(vc_cmd_list, true);
 933
 934         return EINA_FALSE;
 935 }
 936
 937 void __vc_widget_cb_result()
 938 {
 939         ecore_timer_add(0, __vc_widget_notify_result, NULL);
 940
 941         return;
 942 }
 943
 944 static Eina_Bool __vc_widget_notify_state_changed(void *data)
 945 {
 946         vc_state_changed_cb changed_callback = NULL;
 947         void* user_data;
 948
 949         vc_widget_client_get_state_changed_cb(g_vc_w, &changed_callback, &user_data);
 950
 951         vc_state_e current_state;
 952         vc_state_e before_state;
 953
 954         vc_widget_client_get_before_state(g_vc_w, &current_state, &before_state);
 955
 956         if (NULL != changed_callback) {
 957                 vc_widget_client_use_callback(g_vc_w);
 958                 changed_callback(before_state, current_state, user_data);
 959                 vc_widget_client_not_use_callback(g_vc_w);
 960                 SLOG(LOG_DEBUG, TAG_VCW, "State changed callback is called");
 961         } else {
 962                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] State changed callback is null");
 963         }
 964
 965         return EINA_FALSE;
 966 }
 967
 968 int vc_widget_set_result_cb(vc_result_cb callback, void* user_data)
 969 {
 970         if (NULL == callback)
 971                 return VC_ERROR_INVALID_PARAMETER;
 972
 973         vc_state_e state;
 974         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 975                 return VC_ERROR_INVALID_STATE;
 976         }
 977
 978         /* check state */
 979         if (state != VC_STATE_INITIALIZED) {
 980                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
 981                 return VC_ERROR_INVALID_STATE;
 982         }
 983
 984         vc_widget_client_set_result_cb(g_vc_w, callback, user_data);
 985
 986         return 0;
 987 }
 988
 989 int vc_widget_unset_result_cb()
 990 {
 991         vc_state_e state;
 992         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
 993                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
 994                 return VC_ERROR_INVALID_STATE;
 995         }
 996
 997         /* check state */
 998         if (state != VC_STATE_INITIALIZED) {
 999                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1000                 return VC_ERROR_INVALID_STATE;
1001         }
1002
1003         vc_widget_client_set_result_cb(g_vc_w, NULL, NULL);
1004
1005         return 0;
1006 }
1007
1008 int vc_widget_set_show_tooltip_cb(vc_widget_show_tooltip_cb callback, void* user_data)
1009 {
1010         if (NULL == callback)
1011                 return VC_ERROR_INVALID_PARAMETER;
1012
1013         vc_state_e state;
1014         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1015                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1016                 return VC_ERROR_INVALID_STATE;
1017         }
1018
1019         /* check state */
1020         if (state != VC_STATE_INITIALIZED) {
1021                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1022                 return VC_ERROR_INVALID_STATE;
1023         }
1024
1025         vc_widget_client_set_show_tooltip_cb(g_vc_w, callback, user_data);
1026
1027         return 0;
1028 }
1029
1030 int vc_widget_unset_show_tooltip_cb()
1031 {
1032         vc_state_e state;
1033         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1034                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1035                 return VC_ERROR_INVALID_STATE;
1036         }
1037
1038         /* check state */
1039         if (state != VC_STATE_INITIALIZED) {
1040                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1041                 return VC_ERROR_INVALID_STATE;
1042         }
1043
1044         vc_widget_client_set_show_tooltip_cb(g_vc_w, NULL, NULL);
1045
1046         return 0;
1047 }
1048
1049 int vc_widget_set_send_current_command_list_cb(vc_widget_send_current_command_list_cb callback, void* user_data)
1050 {
1051         vc_state_e state;
1052         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1053                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1054                 return VC_ERROR_INVALID_STATE;
1055         }
1056
1057         /* check state */
1058         if (state != VC_STATE_INITIALIZED) {
1059                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1060                 return VC_ERROR_INVALID_STATE;
1061         }
1062
1063         vc_widget_client_set_send_command_list_cb(g_vc_w, callback, user_data);
1064
1065         return 0;
1066 }
1067
1068 int vc_widget_unsset_send_current_command_list_cb()
1069 {
1070         vc_state_e state;
1071         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1072                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1073                 return VC_ERROR_INVALID_STATE;
1074         }
1075
1076         /* check state */
1077         if (state != VC_STATE_INITIALIZED) {
1078                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1079                 return VC_ERROR_INVALID_STATE;
1080         }
1081
1082         vc_widget_client_set_send_command_list_cb(g_vc_w, NULL, NULL);
1083
1084         return 0;
1085 }
1086
1087 int __vc_widget_cb_service_state(int state)
1088 {
1089         vc_service_state_e current_state = (vc_service_state_e)state;
1090         vc_service_state_e before_state;
1091         vc_widget_client_get_service_state(g_vc_w, &before_state);
1092
1093         if (current_state == before_state) {
1094                 return 0;
1095         }
1096
1097         SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
1098                 before_state, current_state);
1099
1100         /* Save service state */
1101         vc_widget_client_set_service_state(g_vc_w, current_state);
1102
1103         vc_service_state_changed_cb callback = NULL;
1104         void* service_user_data = NULL;
1105         vc_widget_client_get_service_state_changed_cb(g_vc_w, &callback, &service_user_data);
1106
1107         if (NULL != callback) {
1108                 vc_widget_client_use_callback(g_vc_w);
1109                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1110                 vc_widget_client_not_use_callback(g_vc_w);
1111                 SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
1112         } else {
1113                 SLOG(LOG_WARN, TAG_VCW, "[WARNING] Service state changed callback is null");
1114         }
1115
1116         return 0;
1117 }
1118
1119 int vc_widget_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1120 {
1121         vc_state_e state;
1122         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1123                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1124                 return VC_ERROR_INVALID_STATE;
1125         }
1126
1127         /* check state */
1128         if (state != VC_STATE_INITIALIZED) {
1129                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1130                 return VC_ERROR_INVALID_STATE;
1131         }
1132
1133         vc_widget_client_set_service_state_changed_cb(g_vc_w, callback, user_data);
1134
1135         return 0;
1136 }
1137
1138 int vc_widget_unset_service_state_changed_cb()
1139 {
1140         vc_state_e state;
1141         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1142                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1143                 return VC_ERROR_INVALID_STATE;
1144         }
1145
1146         /* check state */
1147         if (state != VC_STATE_INITIALIZED) {
1148                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1149                 return VC_ERROR_INVALID_STATE;
1150         }
1151
1152         vc_widget_client_set_service_state_changed_cb(g_vc_w, NULL, NULL);
1153
1154         return 0;
1155 }
1156
1157 int vc_widget_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1158 {
1159         if (NULL == callback)
1160                 return VC_ERROR_INVALID_PARAMETER;
1161
1162         vc_state_e state;
1163         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1164                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1165                 return VC_ERROR_INVALID_STATE;
1166         }
1167
1168         /* check state */
1169         if (state != VC_STATE_INITIALIZED) {
1170                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1171                 return VC_ERROR_INVALID_STATE;
1172         }
1173
1174         vc_widget_client_set_state_changed_cb(g_vc_w, callback, user_data);
1175
1176         return 0;
1177 }
1178
1179 int vc_widget_unset_state_changed_cb()
1180 {
1181         vc_state_e state;
1182         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1183                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1184                 return VC_ERROR_INVALID_STATE;
1185         }
1186
1187         /* check state */
1188         if (state != VC_STATE_INITIALIZED) {
1189                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1190                 return VC_ERROR_INVALID_STATE;
1191         }
1192
1193         vc_widget_client_set_state_changed_cb(g_vc_w, NULL, NULL);
1194
1195         return 0;
1196 }
1197
1198 int vc_widget_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1199 {
1200         if (NULL == callback)
1201                 return VC_ERROR_INVALID_PARAMETER;
1202
1203         vc_state_e state;
1204         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1205                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1206                 return VC_ERROR_INVALID_STATE;
1207         }
1208
1209         /* check state */
1210         if (state != VC_STATE_INITIALIZED) {
1211                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1212                 return VC_ERROR_INVALID_STATE;
1213         }
1214
1215         vc_widget_client_set_current_lang_changed_cb(g_vc_w, callback, user_data);
1216
1217         return 0;
1218 }
1219
1220 int vc_widget_unset_current_language_changed_cb()
1221 {
1222         vc_state_e state;
1223         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1224                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1225                 return VC_ERROR_INVALID_STATE;
1226         }
1227
1228         /* check state */
1229         if (state != VC_STATE_INITIALIZED) {
1230                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1231                 return VC_ERROR_INVALID_STATE;
1232         }
1233
1234         vc_widget_client_set_current_lang_changed_cb(g_vc_w, NULL, NULL);
1235
1236         return 0;
1237 }
1238
1239 int vc_widget_set_error_cb(vc_error_cb callback, void* user_data)
1240 {
1241         if (NULL == callback)
1242                 return VC_ERROR_INVALID_PARAMETER;
1243
1244         vc_state_e state;
1245         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1246                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1247                 return VC_ERROR_INVALID_STATE;
1248         }
1249
1250         /* check state */
1251         if (state != VC_STATE_INITIALIZED) {
1252                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1253                 return VC_ERROR_INVALID_STATE;
1254         }
1255
1256         vc_widget_client_set_error_cb(g_vc_w, callback,  user_data);
1257
1258         return 0;
1259 }
1260
1261 int vc_widget_unset_error_cb()
1262 {
1263         vc_state_e state;
1264         if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
1265                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
1266                 return VC_ERROR_INVALID_STATE;
1267         }
1268
1269         /* check state */
1270         if (state != VC_STATE_INITIALIZED) {
1271                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'");
1272                 return VC_ERROR_INVALID_STATE;
1273         }
1274
1275         vc_widget_client_set_error_cb(g_vc_w, NULL, NULL);
1276
1277         return 0;
1278 }
1279