client/vc.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
  20 #include "vc_client.h"
  21 #include "vc_command.h"
  22 #include "vc_config_mgr.h"
  23 #include "vc_dbus.h"
  24 #include "vc_info_parser.h"
  25 #include "vc_main.h"
  26 #include "voice_control.h"
  27 #include "voice_control_authority.h"
  28 #include "voice_control_command.h"
  29 #include "voice_control_command_expand.h"
  30
  31
  32
  33 static Ecore_Timer* g_connect_timer = NULL;
  34
  35 static vc_h g_vc = NULL;
  36
  37 static int g_feature_enabled = -1;
  38
  39 #if 0
  40 static Ecore_Event_Handler* g_focus_in_hander = NULL;
  41 static Ecore_Event_Handler* g_focus_out_hander = NULL;
  42 #endif
  43
  44 Eina_Bool __vc_notify_state_changed(void *data);
  45 Eina_Bool __vc_notify_error(void *data);
  46
  47 static int __vc_get_feature_enabled()
  48 {
  49         if (0 == g_feature_enabled) {
  50                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  51                 return VC_ERROR_NOT_SUPPORTED;
  52         } else if (-1 == g_feature_enabled) {
  53                 bool vc_supported = false;
  54                 bool mic_supported = false;
  55                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  56                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  57                                 if (false == vc_supported || false == mic_supported) {
  58                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  59                                         g_feature_enabled = 0;
  60                                         return VC_ERROR_NOT_SUPPORTED;
  61                                 }
  62
  63                                 g_feature_enabled = 1;
  64                         }
  65                 }
  66         }
  67
  68         return 0;
  69 }
  70
  71 static const char* __vc_get_error_code(vc_error_e err)
  72 {
  73         switch (err) {
  74                 case VC_ERROR_NONE:                     return "VC_ERROR_NONE";                 break;
  75                 case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";        break;
  76                 case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";             break;
  77                 case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";    break;
  78                 case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";            break;
  79                 case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";        break;
  80                 case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";        break;
  81                 case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";     break;
  82                 case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";     break;
  83                 case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";     break;
  84                 default:                                return "Invalid error code";            break;
  85         }
  86         return NULL;
  87 }
  88
  89 static int __vc_convert_config_error_code(vc_config_error_e code)
  90 {
  91         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
  92         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
  93         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
  94         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
  95         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
  96         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
  97         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
  98         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
  99
 100         return VC_ERROR_NONE;
 101 }
 102
 103 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
 104 {
 105         SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
 106                  before_lang, current_lang);
 107
 108         vc_current_language_changed_cb callback;
 109         void* lang_user_data;
 110         vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
 111
 112         if (NULL != callback) {
 113                 vc_client_use_callback(g_vc);
 114                 callback(before_lang, current_lang, lang_user_data);
 115                 vc_client_not_use_callback(g_vc);
 116                 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
 117         } else {
 118                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
 119         }
 120
 121         return;
 122 }
 123
 124 static Eina_Bool __notify_auth_changed_cb(void *data)
 125 {
 126         vc_auth_state_changed_cb callback = NULL;
 127         void* user_data;
 128
 129         vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
 130
 131         vc_auth_state_e before = -1;
 132         vc_auth_state_e current = -1;
 133
 134         vc_client_get_before_auth_state(g_vc, &before, &current);
 135
 136         if (NULL != callback) {
 137                 vc_client_use_callback(g_vc);
 138                 callback(before, current, user_data);
 139                 vc_client_not_use_callback(g_vc);
 140                 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
 141         } else {
 142                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
 143         }
 144
 145         return EINA_FALSE;
 146 }
 147
 148
 149 int vc_initialize(void)
 150 {
 151         if (0 != __vc_get_feature_enabled()) {
 152                 return VC_ERROR_NOT_SUPPORTED;
 153         }
 154
 155         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
 156
 157         /* check handle */
 158         if (true == vc_client_is_valid(g_vc)) {
 159                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already initialized");
 160                 return VC_ERROR_INVALID_STATE;
 161         }
 162
 163         if (0 < vc_client_get_count()) {
 164                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
 165                 return VC_ERROR_INVALID_STATE;
 166         }
 167
 168         if (0 != vc_dbus_open_connection()) {
 169                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
 170                 return VC_ERROR_OPERATION_FAILED;
 171         }
 172
 173         if (0 != vc_client_create(&g_vc)) {
 174                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
 175                 return VC_ERROR_OUT_OF_MEMORY;
 176         }
 177
 178         int ret = vc_config_mgr_initialize(g_vc->handle);
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
 181                          __vc_get_error_code(__vc_convert_config_error_code(ret)));
 182                 vc_client_destroy(g_vc);
 183                 return __vc_convert_config_error_code(ret);
 184         }
 185
 186         ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
 187         if (0 != ret) {
 188                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
 189                 vc_config_mgr_finalize(g_vc->handle);
 190                 vc_client_destroy(g_vc);
 191                 return __vc_convert_config_error_code(ret);
 192         }
 193
 194         SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
 195
 196         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 197         SLOG(LOG_DEBUG, TAG_VCC, " ");
 198
 199         return VC_ERROR_NONE;
 200 }
 201
 202 static void __vc_internal_unprepare(void)
 203 {
 204         /* return authority */
 205         vc_auth_state_e state = VC_AUTH_STATE_NONE;
 206         if (0 != vc_client_get_auth_state(g_vc, &state)) {
 207                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 208         }
 209
 210         if (VC_AUTH_STATE_NONE != state) {
 211                 if (0 != vc_auth_disable()) {
 212                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
 213                 }
 214         }
 215
 216         int ret = vc_dbus_request_finalize(g_vc->handle);
 217         if (0 != ret) {
 218                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
 219         }
 220
 221
 222 #if 0
 223         ecore_event_handler_del(g_focus_in_hander);
 224         ecore_event_handler_del(g_focus_out_hander);
 225 #endif
 226
 227         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 228         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_BACKGROUND);
 229
 230         return;
 231 }
 232
 233 int vc_deinitialize(void)
 234 {
 235         if (0 != __vc_get_feature_enabled()) {
 236                 return VC_ERROR_NOT_SUPPORTED;
 237         }
 238
 239         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
 240
 241         if (false == vc_client_is_valid(g_vc)) {
 242                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
 243                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 244                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 245                 return VC_ERROR_INVALID_STATE;
 246         }
 247
 248         vc_state_e state;
 249         vc_client_get_client_state(g_vc, &state);
 250
 251         /* check state */
 252         switch (state) {
 253         case VC_STATE_READY:
 254                 __vc_internal_unprepare();
 255                 /* no break. need to next step*/
 256         case VC_STATE_INITIALIZED:
 257                 if (NULL != g_connect_timer) {
 258                         SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
 259                         ecore_timer_del(g_connect_timer);
 260                 }
 261
 262                 vc_config_mgr_unset_lang_cb(g_vc->handle);
 263                 vc_config_mgr_finalize(g_vc->handle);
 264
 265                 /* Free client resources */
 266                 vc_client_destroy(g_vc);
 267                 g_vc = NULL;
 268                 break;
 269         case VC_STATE_NONE:
 270                 break;
 271         default:
 272                 break;
 273         }
 274
 275         SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
 276
 277         if (0 != vc_dbus_close_connection()) {
 278                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
 279         }
 280
 281         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 282         SLOG(LOG_DEBUG, TAG_VCC, " ");
 283
 284         return VC_ERROR_NONE;
 285 }
 286
 287 #if 0
 288 static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
 289 {
 290         Ecore_X_Event_Window_Focus_In *e;
 291
 292         e = event;
 293
 294         int xid = -1;
 295         if (0 != vc_client_get_xid(g_vc, &xid)) {
 296                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
 297                 return ECORE_CALLBACK_PASS_ON;
 298         }
 299
 300         if (e->win == (Ecore_X_Window)xid) {
 301                 SLOG(LOG_DEBUG, TAG_VCC, "Focus in : pid(%d) xid(%d)", getpid(), xid);
 302                 int ret = vc_config_mgr_set_foreground(getpid(), true);
 303                 if (0 != ret) {
 304                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 305                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
 306                 }
 307                 /* set authority valid */
 308                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 309                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 310                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 311                 }
 312                 if (VC_AUTH_STATE_INVALID == state) {
 313                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
 314
 315                         /* notify auth changed cb */
 316                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 317                 }
 318         }
 319
 320         return ECORE_CALLBACK_PASS_ON;
 321 }
 322
 323 static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
 324 {
 325         Ecore_X_Event_Window_Focus_In *e;
 326
 327         e = event;
 328
 329         int xid = -1;
 330         if (0 != vc_client_get_xid(g_vc, &xid)) {
 331                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
 332                 return ECORE_CALLBACK_PASS_ON;
 333         }
 334
 335         if (e->win == (Ecore_X_Window)xid) {
 336                 SLOG(LOG_DEBUG, TAG_VCC, "Focus out : pid(%d) xid(%d)", getpid(), xid);
 337                 int ret = vc_config_mgr_set_foreground(getpid(), false);
 338                 if (0 != ret) {
 339                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 340                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus out : %s", __vc_get_error_code(ret));
 341                 }
 342                 /* set authority valid */
 343                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 344                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 345                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 346                 }
 347                 if (VC_AUTH_STATE_VALID == state) {
 348                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
 349
 350                         /* notify authority changed cb */
 351                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 352                 }
 353         }
 354
 355         return ECORE_CALLBACK_PASS_ON;
 356 }
 357 #endif
 358
 359 static Eina_Bool __vc_connect_daemon(void *data)
 360 {
 361         /* Send hello */
 362         if (0 != vc_dbus_request_hello()) {
 363                 return EINA_TRUE;
 364         }
 365
 366         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
 367
 368         /* request initialization */
 369         int ret = -1;
 370         int mgr_pid = -1;
 371         int service_state = 0;
 372         ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state);
 373         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 374                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
 375
 376                 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
 377                 ecore_timer_add(0, __vc_notify_error, g_vc);
 378
 379                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 380                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 381                 return EINA_FALSE;
 382
 383         } else if (0 != ret) {
 384                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
 385
 386                 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
 387                 ecore_timer_add(0, __vc_notify_error, g_vc);
 388
 389                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 390                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 391                 return EINA_FALSE;
 392         } else {
 393                 /* Success to connect */
 394         }
 395
 396         /* Set service state */
 397         vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
 398
 399         g_connect_timer = NULL;
 400 #if 0
 401         g_focus_in_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, __vc_x_event_window_focus_in, NULL);
 402         g_focus_out_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, __vc_x_event_window_focus_out, NULL);
 403 #endif
 404
 405         vc_client_set_client_state(g_vc, VC_STATE_READY);
 406         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 407
 408         vc_client_set_mgr_pid(g_vc, mgr_pid);
 409
 410         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 411         SLOG(LOG_DEBUG, TAG_VCC, "  ");
 412
 413         return EINA_FALSE;
 414 }
 415
 416 int vc_prepare(void)
 417 {
 418         if (0 != __vc_get_feature_enabled()) {
 419                 return VC_ERROR_NOT_SUPPORTED;
 420         }
 421
 422         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
 423
 424         vc_state_e state;
 425         if (0 != vc_client_get_client_state(g_vc, &state)) {
 426                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 427                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 428                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 429                 return VC_ERROR_INVALID_STATE;
 430         }
 431
 432         /* check state */
 433         if (state != VC_STATE_INITIALIZED) {
 434                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 435                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 436                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 437                 return VC_ERROR_INVALID_STATE;
 438         }
 439
 440         g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
 441
 442         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 443         SLOG(LOG_DEBUG, TAG_VCC, " ");
 444
 445         return VC_ERROR_NONE;
 446 }
 447
 448 int vc_unprepare(void)
 449 {
 450         if (0 != __vc_get_feature_enabled()) {
 451                 return VC_ERROR_NOT_SUPPORTED;
 452         }
 453
 454         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
 455
 456         vc_state_e state;
 457         if (0 != vc_client_get_client_state(g_vc, &state)) {
 458                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 459                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 460                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 461                 return VC_ERROR_INVALID_STATE;
 462         }
 463
 464         /* check state */
 465         if (state != VC_STATE_READY) {
 466                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 467                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 468                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 469                 return VC_ERROR_INVALID_STATE;
 470         }
 471
 472         __vc_internal_unprepare();
 473
 474         vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
 475         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 476
 477         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 478         SLOG(LOG_DEBUG, TAG_VCC, " ");
 479
 480         return VC_ERROR_NONE;
 481 }
 482
 483 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 484 {
 485         if (0 != __vc_get_feature_enabled()) {
 486                 return VC_ERROR_NOT_SUPPORTED;
 487         }
 488
 489         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
 490
 491         if (NULL == callback) {
 492                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 493                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 494                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 495                 return VC_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         vc_state_e state;
 499         if (0 != vc_client_get_client_state(g_vc, &state)) {
 500                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 501                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 502                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 503                 return VC_ERROR_INVALID_STATE;
 504         }
 505
 506         int ret = -1;
 507         ret = vc_config_mgr_get_language_list(callback, user_data);
 508         if (0 != ret) {
 509                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 510                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
 511         }
 512
 513         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 514         SLOG(LOG_DEBUG, TAG_VCC, " ");
 515
 516         return VC_ERROR_NONE;
 517 }
 518
 519
 520 int vc_get_current_language(char** language)
 521 {
 522         if (0 != __vc_get_feature_enabled()) {
 523                 return VC_ERROR_NOT_SUPPORTED;
 524         }
 525
 526         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
 527
 528         if (NULL == language) {
 529                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 530                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 531                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 532                 return VC_ERROR_INVALID_PARAMETER;
 533         }
 534
 535         vc_state_e state;
 536         if (0 != vc_client_get_client_state(g_vc, &state)) {
 537                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 538                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 539                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 540                 return VC_ERROR_INVALID_STATE;
 541         }
 542
 543         int ret = -1;
 544         ret = vc_config_mgr_get_default_language(language);
 545         if (0 != ret) {
 546                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 547                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
 548         }
 549
 550         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 551         SLOG(LOG_DEBUG, TAG_VCC, " ");
 552
 553         return ret;
 554 }
 555
 556 int vc_get_state(vc_state_e* state)
 557 {
 558         if (0 != __vc_get_feature_enabled()) {
 559                 return VC_ERROR_NOT_SUPPORTED;
 560         }
 561
 562         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
 563
 564         if (NULL == state) {
 565                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 566                 return VC_ERROR_INVALID_PARAMETER;
 567         }
 568
 569         vc_state_e temp;
 570         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 571                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 572                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 573                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 574                 return VC_ERROR_INVALID_STATE;
 575         }
 576
 577         *state = temp;
 578
 579         switch (*state) {
 580                 case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'");            break;
 581                 case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'");         break;
 582                 case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'");           break;
 583                 default:                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");              break;
 584         }
 585
 586         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 587         SLOG(LOG_DEBUG, TAG_VCC, " ");
 588
 589         return VC_ERROR_NONE;
 590 }
 591
 592 int vc_get_service_state(vc_service_state_e* state)
 593 {
 594         if (0 != __vc_get_feature_enabled()) {
 595                 return VC_ERROR_NOT_SUPPORTED;
 596         }
 597
 598         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
 599
 600         if (NULL == state) {
 601                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 602                 return VC_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         vc_state_e temp;
 606         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 607                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 608                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 609                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 610                 return VC_ERROR_INVALID_STATE;
 611         }
 612
 613         /* get service state */
 614         vc_service_state_e service_state;
 615         if (0 != vc_client_get_service_state(g_vc, &service_state)) {
 616                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
 617                 return VC_ERROR_OPERATION_FAILED;
 618         }
 619
 620         *state = service_state;
 621
 622         switch (*state) {
 623                 case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'");            break;
 624                 case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'");           break;
 625                 case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'");       break;
 626                 case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'");      break;
 627                 default:                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");                      break;
 628         }
 629
 630         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 631         SLOG(LOG_DEBUG, TAG_VCC, " ");
 632
 633         return VC_ERROR_NONE;
 634 }
 635
 636 #if 0
 637 int vc_set_window_id(int wid)
 638 {
 639         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Window id");
 640
 641         if (0 >= wid) {
 642                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is invalid");
 643                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 644                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 645                 return VC_ERROR_INVALID_PARAMETER;
 646         }
 647
 648         vc_state_e state;
 649         if (0 != vc_client_get_client_state(g_vc, &state)) {
 650                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 651                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 652                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 653                 return VC_ERROR_INVALID_STATE;
 654         }
 655
 656         /* check state */
 657         if (state != VC_STATE_READY) {
 658                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 659                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 660                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 661                 return VC_ERROR_INVALID_STATE;
 662         }
 663
 664         if (0 != vc_client_set_xid(g_vc, wid)) {
 665                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
 666                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 667                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 668                 return VC_ERROR_INVALID_STATE;
 669         }
 670
 671         /* Check if current xid is top window */
 672         int ret = -1;
 673         if ((Ecore_X_Window)wid == ecore_x_window_focus_get()) {
 674                 /* Set current pid */
 675                 ret = vc_config_mgr_set_foreground(getpid(), true);
 676                 if (0 != ret) {
 677                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 678                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
 679                 }
 680         }
 681
 682         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 683         SLOG(LOG_DEBUG, TAG_VCC, " ");
 684
 685         return ret;
 686 }
 687
 688 int vc_get_window_id(int* wid)
 689 {
 690         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Window id");
 691
 692         if (NULL == wid) {
 693                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 694                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 695                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 696                 return VC_ERROR_INVALID_PARAMETER;
 697         }
 698
 699         vc_state_e state;
 700         if (0 != vc_client_get_client_state(g_vc, &state)) {
 701                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 702                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 703                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 704                 return VC_ERROR_INVALID_STATE;
 705         }
 706
 707         /* check state */
 708         if (state != VC_STATE_READY) {
 709                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 710                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 711                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 712                 return VC_ERROR_INVALID_STATE;
 713         }
 714
 715         if (0 != vc_client_get_xid(g_vc, wid)) {
 716                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
 717                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 718                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 719                 return VC_ERROR_INVALID_STATE;
 720         }
 721
 722         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 723         SLOG(LOG_DEBUG, TAG_VCC, " ");
 724
 725         return VC_ERROR_NONE;
 726 }
 727 #endif
 728
 729 /**
 730 * @brief Checks whether the command format is supported.
 731 * @since_tizen 2.4
 732 *
 733 * @param[in] format The command format
 734 * @param[out] support The result status @c true = supported, @c false = not supported
 735 *
 736 * @return 0 on success, otherwise a negative error value
 737 * @retval #VC_ERROR_NONE Successful
 738 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 739 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 740 * @retval #VC_ERROR_INVALID_STATE Invalid state
 741 *
 742 * @pre The state should be #VC_STATE_READY.
 743 */
 744 #if 0
 745 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
 746 {
 747         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
 748
 749         vc_state_e state;
 750         if (0 != vc_client_get_client_state(g_vc, &state)) {
 751                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 752                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 753                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 754                 return VC_ERROR_INVALID_STATE;
 755         }
 756
 757         /* check support */
 758         bool non_fixed_support = false;
 759         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 760                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
 761         }
 762
 763         switch (format) {
 764         case VC_CMD_FORMAT_FIXED:                       *support = true;                break;
 765         case VC_CMD_FORMAT_FIXED_AND_EXTRA:     *support = non_fixed_support;   break;
 766         case VC_CMD_FORMAT_EXTRA_AND_FIXED:     *support = non_fixed_support;   break;
 767         default:                                        *support = false;               break;
 768         }
 769
 770         SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 771
 772         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 773         SLOG(LOG_DEBUG, TAG_VCC, " ");
 774
 775         return VC_ERROR_NONE;
 776 }
 777 #endif
 778
 779 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
 780 {
 781         if (0 != __vc_get_feature_enabled()) {
 782                 return VC_ERROR_NOT_SUPPORTED;
 783         }
 784
 785         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
 786
 787         if (NULL == vc_cmd_list) {
 788                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 789                 return VC_ERROR_INVALID_PARAMETER;
 790         }
 791
 792         vc_state_e state;
 793         if (0 != vc_client_get_client_state(g_vc, &state)) {
 794                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 795                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 796                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 797                 return VC_ERROR_INVALID_STATE;
 798         }
 799
 800         /* check state */
 801         if (state != VC_STATE_READY) {
 802                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 803                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 804                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 805                 return VC_ERROR_INVALID_STATE;
 806         }
 807
 808         /* check type */
 809         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
 810                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
 811                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 812                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 813                 return VC_ERROR_INVALID_PARAMETER;
 814         }
 815
 816         vc_cmd_list_s* list = NULL;
 817         list = (vc_cmd_list_s*)vc_cmd_list;
 818
 819         int ret = 0;
 820         if (0 != vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list)) {
 821                 ret = VC_ERROR_INVALID_PARAMETER;
 822                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
 823         } else {
 824                 int count = 0;
 825                 do {
 826                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
 827                         if (0 != ret) {
 828                                 if (VC_ERROR_TIMED_OUT != ret) {
 829                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
 830                                         break;
 831                                 } else {
 832                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
 833                                         usleep(10000);
 834                                         count++;
 835                                         if (VC_RETRY_COUNT == count) {
 836                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
 837                                                 break;
 838                                         }
 839                                 }
 840                         }
 841                 } while (0 != ret);
 842         }
 843
 844         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 845         SLOG(LOG_DEBUG, TAG_VCC, " ");
 846
 847         return ret;
 848 }
 849
 850 int vc_unset_command_list(int type)
 851 {
 852         if (0 != __vc_get_feature_enabled()) {
 853                 return VC_ERROR_NOT_SUPPORTED;
 854         }
 855
 856         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
 857
 858         vc_state_e state;
 859         if (0 != vc_client_get_client_state(g_vc, &state)) {
 860                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 861                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 862                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 863                 return VC_ERROR_INVALID_STATE;
 864         }
 865
 866         /* check state */
 867         if (state != VC_STATE_READY) {
 868                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 869                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 870                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 871                 return VC_ERROR_INVALID_STATE;
 872         }
 873
 874         int count = 0;
 875         int ret = -1;
 876         while (0 != ret) {
 877                 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
 878                 if (0 != ret) {
 879                         if (VC_ERROR_TIMED_OUT != ret) {
 880                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
 881                                 break;
 882                         } else {
 883                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
 884                                 usleep(10000);
 885                                 count++;
 886                                 if (VC_RETRY_COUNT == count) {
 887                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
 888                                         break;
 889                                 }
 890                         }
 891                 }
 892         }
 893
 894         ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
 895         if (0 != ret) {
 896                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 897                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
 898         }
 899
 900         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 901         SLOG(LOG_DEBUG, TAG_VCC, " ");
 902
 903         return ret;
 904 }
 905
 906 #if 0
 907 int vc_get_exclusive_command_option(bool* value)
 908 {
 909         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
 910
 911         vc_state_e state;
 912         if (0 != vc_client_get_client_state(g_vc, &state)) {
 913                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 914                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 915                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 916                 return VC_ERROR_INVALID_STATE;
 917         }
 918
 919         /* check state */
 920         if (state != VC_STATE_READY) {
 921                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 922                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 923                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 924                 return VC_ERROR_INVALID_STATE;
 925         }
 926
 927         int ret = vc_client_get_exclusive_cmd(g_vc, value);
 928         if (0 != ret) {
 929                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
 930                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 931                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 932                 return ret;
 933         }
 934
 935         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 936         SLOG(LOG_DEBUG, TAG_VCC, " ");
 937
 938         return ret;
 939 }
 940
 941 int vc_set_exclusive_command_option(bool value)
 942 {
 943         if (0 != __vc_get_feature_enabled()) {
 944                 return VC_ERROR_NOT_SUPPORTED;
 945         }
 946
 947         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
 948
 949         vc_state_e state;
 950         if (0 != vc_client_get_client_state(g_vc, &state)) {
 951                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 952                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 953                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 954                 return VC_ERROR_INVALID_STATE;
 955         }
 956
 957         /* check state */
 958         if (state != VC_STATE_READY) {
 959                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 960                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 961                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 962                 return VC_ERROR_INVALID_STATE;
 963         }
 964
 965         int ret = vc_client_set_exclusive_cmd(g_vc, value);
 966         if (0 != ret) {
 967                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
 968                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 969                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 970                 return ret;
 971         }
 972
 973         /* Check if current xid is top window */
 974         int count = 0;
 975         do {
 976                 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
 977                 if (0 != ret) {
 978                         if (VC_ERROR_TIMED_OUT != ret) {
 979                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
 980                                 break;
 981                         } else {
 982                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
 983                                 usleep(10000);
 984                                 count++;
 985                                 if (VC_RETRY_COUNT == count) {
 986                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
 987                                         break;
 988                                 }
 989                         }
 990                 }
 991         } while (0 != ret);
 992
 993         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 994         SLOG(LOG_DEBUG, TAG_VCC, " ");
 995
 996         return ret;
 997 }
 998 #endif
 999
1000 #if 0
1001 int vc_request_start(bool stop_by_silence)
1002 {
1003         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1004
1005         vc_state_e state;
1006         if (0 != vc_client_get_client_state(g_vc, &state)) {
1007                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1008                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1009                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1010                 return VC_ERROR_INVALID_STATE;
1011         }
1012
1013         /* check state */
1014         if (state != VC_STATE_READY) {
1015                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1016                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1017                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1018                 return VC_ERROR_INVALID_STATE;
1019         }
1020
1021         /* Check service state */
1022         vc_service_state_e service_state = -1;
1023         vc_client_get_service_state(g_vc, &service_state);
1024         if (service_state != VC_SERVICE_STATE_READY) {
1025                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1026                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1027                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1028                 return VC_ERROR_INVALID_STATE;
1029         }
1030
1031         int ret;
1032         int count = 0;
1033
1034         /* Request */
1035         ret = -1;
1036         count = 0;
1037         while (0 != ret) {
1038                 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1039                 if (0 != ret) {
1040                         if (VC_ERROR_TIMED_OUT != ret) {
1041                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1042                                 break;
1043                         } else {
1044                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1045                                 usleep(10000);
1046                                 count++;
1047                                 if (VC_RETRY_COUNT == count) {
1048                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1049                                         break;
1050                                 }
1051                         }
1052                 } else {
1053                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1054                 }
1055         }
1056
1057         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1058         SLOG(LOG_DEBUG, TAG_VCC, " ");
1059
1060         return ret;
1061 }
1062
1063 int vc_request_stop(void)
1064 {
1065         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1066
1067         vc_state_e state;
1068         if (0 != vc_client_get_client_state(g_vc, &state)) {
1069                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1070                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1071                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1072                 return VC_ERROR_INVALID_STATE;
1073         }
1074
1075         /* check state */
1076         if (state != VC_STATE_READY) {
1077                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1078                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1079                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1080                 return VC_ERROR_INVALID_STATE;
1081         }
1082
1083         /* Check service state */
1084         vc_service_state_e service_state = -1;
1085         vc_client_get_service_state(g_vc, &service_state);
1086         if (service_state != VC_SERVICE_STATE_RECORDING) {
1087                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1088                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1089                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1090                 return VC_ERROR_INVALID_STATE;
1091         }
1092
1093         int ret = -1;
1094         int count = 0;
1095         /* do request */
1096         while (0 != ret) {
1097                 ret = vc_dbus_request_stop(g_vc->handle);
1098                 if (0 != ret) {
1099                         if (VC_ERROR_TIMED_OUT != ret) {
1100                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1101                                 break;
1102                         } else {
1103                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1104                                 usleep(10000);
1105                                 count++;
1106                                 if (VC_RETRY_COUNT == count) {
1107                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1108                                         break;
1109                                 }
1110                         }
1111                 } else {
1112                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1113                 }
1114         }
1115
1116         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1117         SLOG(LOG_DEBUG, TAG_VCC, " ");
1118
1119         return ret;
1120 }
1121
1122 int vc_request_cancel(void)
1123 {
1124         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1125
1126         vc_state_e state;
1127         if (0 != vc_client_get_client_state(g_vc, &state)) {
1128                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1129                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1130                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1131                 return VC_ERROR_INVALID_STATE;
1132         }
1133
1134         /* check state */
1135         if (state != VC_STATE_READY) {
1136                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1137                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1138                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1139                 return VC_ERROR_INVALID_STATE;
1140         }
1141
1142         /* Check service state */
1143         vc_service_state_e service_state = -1;
1144         vc_client_get_service_state(g_vc, &service_state);
1145         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1146                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1147                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1148                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1149                 return VC_ERROR_INVALID_STATE;
1150         }
1151
1152         int ret = -1;
1153         int count = 0;
1154         while (0 != ret) {
1155                 ret = vc_dbus_request_cancel(g_vc->handle);
1156                 if (0 != ret) {
1157                         if (VC_ERROR_TIMED_OUT != ret) {
1158                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1159                                 break;
1160                         } else {
1161                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1162                                 usleep(10000);
1163                                 count++;
1164                                 if (VC_RETRY_COUNT == count) {
1165                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1166                                         break;
1167                                 }
1168                         }
1169                 } else {
1170                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1171                 }
1172         }
1173
1174         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1175         SLOG(LOG_DEBUG, TAG_VCC, " ");
1176
1177         return ret;
1178 }
1179 #endif
1180
1181 Eina_Bool __vc_notify_error(void *data)
1182 {
1183         vc_h vc = (vc_h)data;
1184
1185         vc_error_cb callback = NULL;
1186         void* user_data;
1187         int reason;
1188
1189         vc_client_get_error_cb(vc, &callback, &user_data);
1190         vc_client_get_error(vc, &reason);
1191
1192         if (NULL != callback) {
1193                 vc_client_use_callback(vc);
1194                 callback(reason, user_data);
1195                 vc_client_not_use_callback(vc);
1196                 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1197         } else {
1198                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1199         }
1200
1201         return EINA_FALSE;
1202 }
1203
1204 int __vc_cb_error(int pid, int reason)
1205 {
1206         if (0 != vc_client_get_handle(pid, &g_vc)) {
1207                 SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
1208                 return -1;
1209         }
1210
1211         vc_client_set_error(g_vc, reason);
1212         ecore_timer_add(0, __vc_notify_error, g_vc);
1213
1214         return 0;
1215 }
1216
1217 Eina_Bool __vc_notify_state_changed(void *data)
1218 {
1219         vc_h vc = (vc_h)data;
1220
1221         vc_state_changed_cb changed_callback = NULL;
1222         void* user_data;
1223
1224         vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1225
1226         vc_state_e current_state;
1227         vc_state_e before_state;
1228
1229         vc_client_get_before_state(vc, &current_state, &before_state);
1230
1231         if (NULL != changed_callback) {
1232                 vc_client_use_callback(vc);
1233                 changed_callback(before_state, current_state, user_data);
1234                 vc_client_not_use_callback(vc);
1235                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1236         } else {
1237                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1238         }
1239
1240         return EINA_FALSE;
1241 }
1242
1243 static Eina_Bool __vc_notify_result(void *data)
1244 {
1245         char* temp_text;
1246         int event;
1247         vc_cmd_list_h vc_cmd_list = NULL;
1248
1249         vc_result_cb callback = NULL;
1250         void* user_data = NULL;
1251
1252         vc_client_get_result_cb(g_vc, &callback, &user_data);
1253
1254         if (NULL == callback) {
1255                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1256                 return EINA_FALSE;
1257         }
1258
1259         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1260                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1261                 return EINA_FALSE;
1262         }
1263
1264         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1265
1266         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1267
1268         vc_cmd_print_list(vc_cmd_list);
1269
1270         vc_client_use_callback(g_vc);
1271         callback(event, vc_cmd_list, temp_text, user_data);
1272         vc_client_not_use_callback(g_vc);
1273
1274         SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1275
1276         vc_cmd_list_destroy(vc_cmd_list, true);
1277
1278         /* Release result */
1279         if (NULL != temp_text)  free(temp_text);
1280
1281         return EINA_FALSE;
1282 }
1283
1284 void __vc_cb_result(int pid)
1285 {
1286         if (0 != vc_client_get_handle(pid, &g_vc)) {
1287                 SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
1288                 return;
1289         }
1290
1291         ecore_timer_add(0, __vc_notify_result, NULL);
1292
1293         return;
1294 }
1295
1296 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1297 {
1298         if (0 != __vc_get_feature_enabled()) {
1299                 return VC_ERROR_NOT_SUPPORTED;
1300         }
1301
1302         if (NULL == callback)
1303                 return VC_ERROR_INVALID_PARAMETER;
1304
1305         vc_state_e state;
1306         if (0 != vc_client_get_client_state(g_vc, &state)) {
1307                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1308                 return VC_ERROR_INVALID_STATE;
1309         }
1310
1311         /* check state */
1312         if (state != VC_STATE_INITIALIZED) {
1313                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1314                 return VC_ERROR_INVALID_STATE;
1315         }
1316
1317         vc_client_set_result_cb(g_vc, callback, user_data);
1318
1319         return 0;
1320 }
1321
1322 int vc_unset_result_cb(void)
1323 {
1324         if (0 != __vc_get_feature_enabled()) {
1325                 return VC_ERROR_NOT_SUPPORTED;
1326         }
1327
1328         vc_state_e state;
1329         if (0 != vc_client_get_client_state(g_vc, &state)) {
1330                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1331                 return VC_ERROR_INVALID_STATE;
1332         }
1333
1334         /* check state */
1335         if (state != VC_STATE_INITIALIZED) {
1336                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1337                 return VC_ERROR_INVALID_STATE;
1338         }
1339
1340         vc_client_set_result_cb(g_vc, NULL, NULL);
1341
1342         return 0;
1343 }
1344
1345 int __vc_cb_service_state(int state)
1346 {
1347         vc_service_state_e current_state = (vc_service_state_e)state;
1348         vc_service_state_e before_state;
1349         vc_client_get_service_state(g_vc, &before_state);
1350
1351         if (current_state == before_state) {
1352                 return 0;
1353         }
1354
1355         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1356                 before_state, current_state);
1357
1358         /* Save service state */
1359         vc_client_set_service_state(g_vc, current_state);
1360
1361         vc_service_state_changed_cb callback = NULL;
1362         void* service_user_data;
1363         vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1364
1365         if (NULL != callback) {
1366                 vc_client_use_callback(g_vc);
1367                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1368                 vc_client_not_use_callback(g_vc);
1369                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1370         } else {
1371                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1372         }
1373
1374         return 0;
1375 }
1376
1377 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1378 {
1379         if (0 != __vc_get_feature_enabled()) {
1380                 return VC_ERROR_NOT_SUPPORTED;
1381         }
1382
1383         if (NULL == callback)
1384                 return VC_ERROR_INVALID_PARAMETER;
1385
1386         vc_state_e state;
1387         if (0 != vc_client_get_client_state(g_vc, &state)) {
1388                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1389                 return VC_ERROR_INVALID_STATE;
1390         }
1391
1392         /* check state */
1393         if (state != VC_STATE_INITIALIZED) {
1394                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1395                 return VC_ERROR_INVALID_STATE;
1396         }
1397
1398         vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1399
1400         return 0;
1401 }
1402
1403 int vc_unset_service_state_changed_cb(void)
1404 {
1405         if (0 != __vc_get_feature_enabled()) {
1406                 return VC_ERROR_NOT_SUPPORTED;
1407         }
1408
1409         vc_state_e state;
1410         if (0 != vc_client_get_client_state(g_vc, &state)) {
1411                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : 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_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1418                 return VC_ERROR_INVALID_STATE;
1419         }
1420
1421         vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1422
1423         return 0;
1424 }
1425
1426 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1427 {
1428         if (0 != __vc_get_feature_enabled()) {
1429                 return VC_ERROR_NOT_SUPPORTED;
1430         }
1431
1432         if (callback == NULL)
1433                 return VC_ERROR_INVALID_PARAMETER;
1434
1435         vc_state_e state;
1436         if (0 != vc_client_get_client_state(g_vc, &state)) {
1437                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1438                 return VC_ERROR_INVALID_STATE;
1439         }
1440
1441         /* check state */
1442         if (state != VC_STATE_INITIALIZED) {
1443                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1444                 return VC_ERROR_INVALID_STATE;
1445         }
1446
1447         vc_client_set_state_changed_cb(g_vc, callback, user_data);
1448
1449         return 0;
1450 }
1451
1452 int vc_unset_state_changed_cb(void)
1453 {
1454         if (0 != __vc_get_feature_enabled()) {
1455                 return VC_ERROR_NOT_SUPPORTED;
1456         }
1457
1458         vc_state_e state;
1459         if (0 != vc_client_get_client_state(g_vc, &state)) {
1460                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1461                 return VC_ERROR_INVALID_STATE;
1462         }
1463
1464         /* check state */
1465         if (state != VC_STATE_INITIALIZED) {
1466                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1467                 return VC_ERROR_INVALID_STATE;
1468         }
1469
1470         vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1471
1472         return 0;
1473 }
1474
1475 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1476 {
1477         if (0 != __vc_get_feature_enabled()) {
1478                 return VC_ERROR_NOT_SUPPORTED;
1479         }
1480
1481         if (NULL == callback)
1482                 return VC_ERROR_INVALID_PARAMETER;
1483
1484         vc_state_e state;
1485         if (0 != vc_client_get_client_state(g_vc, &state)) {
1486                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1487                 return VC_ERROR_INVALID_STATE;
1488         }
1489
1490         /* check state */
1491         if (state != VC_STATE_INITIALIZED) {
1492                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1493                 return VC_ERROR_INVALID_STATE;
1494         }
1495
1496         vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1497
1498         return 0;
1499 }
1500
1501 int vc_unset_current_language_changed_cb(void)
1502 {
1503         if (0 != __vc_get_feature_enabled()) {
1504                 return VC_ERROR_NOT_SUPPORTED;
1505         }
1506
1507         vc_state_e state;
1508         if (0 != vc_client_get_client_state(g_vc, &state)) {
1509                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1510                 return VC_ERROR_INVALID_STATE;
1511         }
1512
1513         /* check state */
1514         if (state != VC_STATE_INITIALIZED) {
1515                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1516                 return VC_ERROR_INVALID_STATE;
1517         }
1518
1519         vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1520
1521         return 0;
1522 }
1523
1524 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1525 {
1526         if (0 != __vc_get_feature_enabled()) {
1527                 return VC_ERROR_NOT_SUPPORTED;
1528         }
1529
1530         if (NULL == callback)
1531                 return VC_ERROR_INVALID_PARAMETER;
1532
1533         vc_state_e state;
1534         if (0 != vc_client_get_client_state(g_vc, &state)) {
1535                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : 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_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1542                 return VC_ERROR_INVALID_STATE;
1543         }
1544
1545         vc_client_set_error_cb(g_vc, callback,  user_data);
1546
1547         return 0;
1548 }
1549
1550 int vc_unset_error_cb(void)
1551 {
1552         if (0 != __vc_get_feature_enabled()) {
1553                 return VC_ERROR_NOT_SUPPORTED;
1554         }
1555
1556         vc_state_e state;
1557         if (0 != vc_client_get_client_state(g_vc, &state)) {
1558                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
1559                 return VC_ERROR_INVALID_STATE;
1560         }
1561
1562         /* check state */
1563         if (state != VC_STATE_INITIALIZED) {
1564                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
1565                 return VC_ERROR_INVALID_STATE;
1566         }
1567
1568         vc_client_set_error_cb(g_vc, NULL, NULL);
1569
1570         return 0;
1571 }
1572
1573 /* Authority */
1574 int vc_auth_enable(void)
1575 {
1576         /* check state */
1577         vc_state_e state;
1578         if (0 != vc_client_get_client_state(g_vc, &state)) {
1579                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1580                 return VC_ERROR_INVALID_STATE;
1581         }
1582
1583         if (VC_STATE_READY != state) {
1584                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1585                 return VC_ERROR_INVALID_STATE;
1586         }
1587
1588         /* check already authority */
1589         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1590         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1591                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1592                 return VC_ERROR_INVALID_STATE;
1593         }
1594
1595         if (VC_AUTH_STATE_NONE != auth_state) {
1596                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
1597                 return VC_ERROR_INVALID_STATE;
1598         }
1599
1600         /* request authority */
1601         int mgr_pid = -1;
1602         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1603                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1604                 return VC_ERROR_OPERATION_FAILED;
1605         }
1606
1607         if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
1608                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
1609                 return VC_ERROR_OPERATION_FAILED;
1610         }
1611
1612         /* set authority into handle */
1613         int fg_pid = -1;
1614         if (0 != vc_config_mgr_get_foreground(&fg_pid)) {
1615                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get foreground");
1616                 return VC_ERROR_OPERATION_FAILED;
1617         }
1618
1619         if (g_vc->handle == fg_pid) {
1620                 auth_state = VC_AUTH_STATE_VALID;
1621         } else {
1622                 auth_state = VC_AUTH_STATE_INVALID;
1623         }
1624
1625         if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
1626                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1627                 return VC_ERROR_OPERATION_FAILED;
1628         }
1629
1630         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1631
1632         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
1633
1634         return VC_ERROR_NONE;
1635 }
1636
1637 int vc_auth_disable(void)
1638 {
1639         /* check state */
1640         vc_state_e state;
1641         if (0 != vc_client_get_client_state(g_vc, &state)) {
1642                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1643                 return VC_ERROR_INVALID_STATE;
1644         }
1645
1646         if (VC_STATE_READY != state) {
1647                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1648                 return VC_ERROR_INVALID_STATE;
1649         }
1650
1651         /* check autority */
1652         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1653         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1654                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1655                 return VC_ERROR_INVALID_STATE;
1656         }
1657
1658         if (VC_AUTH_STATE_NONE == auth_state) {
1659                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
1660                 return VC_ERROR_INVALID_STATE;
1661         }
1662
1663         if (0 != vc_auth_unset_state_changed_cb()) {
1664                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
1665         }
1666
1667         /* request return authority by dbus */
1668         int mgr_pid = -1;
1669         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1670                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1671                 return VC_ERROR_OPERATION_FAILED;
1672         }
1673
1674         if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
1675                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
1676                 return VC_ERROR_OPERATION_FAILED;
1677         }
1678
1679         /* unset authority from handle */
1680         if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
1681                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1682                 return VC_ERROR_OPERATION_FAILED;
1683         }
1684
1685         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1686
1687         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
1688
1689         return VC_ERROR_NONE;
1690 }
1691
1692 int vc_auth_get_state(vc_auth_state_e* state)
1693 {
1694         /* check state */
1695         vc_state_e vc_state;
1696         if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
1697                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1698                 return VC_ERROR_INVALID_STATE;
1699         }
1700
1701         if (VC_STATE_READY != vc_state) {
1702                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1703                 return VC_ERROR_INVALID_STATE;
1704         }
1705
1706         /* get autority */
1707         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
1708         if (0 != vc_client_get_auth_state(g_vc, &temp)) {
1709                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1710                 return VC_ERROR_INVALID_STATE;
1711         }
1712
1713         *state = temp;
1714
1715         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
1716
1717         return VC_ERROR_NONE;
1718 }
1719
1720 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
1721 {
1722         /* check parameter */
1723         if (NULL == callback) {
1724                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
1725                 return VC_ERROR_INVALID_PARAMETER;
1726         }
1727
1728         /* check auth */
1729         vc_auth_state_e auth_state;
1730         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1731                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1732                 return VC_ERROR_INVALID_STATE;
1733         }
1734
1735         if (VC_AUTH_STATE_NONE == auth_state) {
1736                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
1737                 return VC_ERROR_INVALID_STATE;
1738         }
1739
1740         /* set cb into handle */
1741         if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
1742                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
1743                 return VC_ERROR_OPERATION_FAILED;
1744         }
1745
1746         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
1747
1748         return VC_ERROR_NONE;
1749 }
1750
1751 int vc_auth_unset_state_changed_cb(void)
1752 {
1753         /* check auth */
1754         vc_auth_state_e auth_state;
1755         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1756                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1757                 return VC_ERROR_INVALID_STATE;
1758         }
1759
1760         if (VC_AUTH_STATE_NONE == auth_state) {
1761                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
1762                 return VC_ERROR_INVALID_STATE;
1763         }
1764
1765         /* unset cb from handle */
1766         if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
1767                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
1768                 return VC_ERROR_OPERATION_FAILED;
1769         }
1770
1771         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
1772
1773         return VC_ERROR_NONE;
1774 }
1775
1776 int vc_auth_start(void)
1777 {
1778         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1779
1780         vc_state_e state;
1781         if (0 != vc_client_get_client_state(g_vc, &state)) {
1782                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1783                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1784                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1785                 return VC_ERROR_INVALID_STATE;
1786         }
1787
1788         /* check state */
1789         if (state != VC_STATE_READY) {
1790                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1791                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1792                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1793                 return VC_ERROR_INVALID_STATE;
1794         }
1795
1796         /* Check service state */
1797         vc_service_state_e service_state = -1;
1798         vc_client_get_service_state(g_vc, &service_state);
1799         if (service_state != VC_SERVICE_STATE_READY) {
1800                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1801                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1802                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1803                 return VC_ERROR_INVALID_STATE;
1804         }
1805
1806         /* Check authority */
1807         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1808         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1809                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1810                 return VC_ERROR_OPERATION_FAILED;
1811         }
1812
1813         if (VC_AUTH_STATE_VALID != auth_state) {
1814                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1815                 return VC_ERROR_OPERATION_FAILED;
1816         }
1817
1818         /* get mgr_pid */
1819         int mgr_pid = -1;
1820         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1821                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1822                 return VC_ERROR_OPERATION_FAILED;
1823         }
1824
1825         int ret;
1826         int count = 0;
1827         /* Request */
1828         ret = -1;
1829         count = 0;
1830         while (0 != ret) {
1831                 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
1832                 if (0 != ret) {
1833                         if (VC_ERROR_TIMED_OUT != ret) {
1834                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
1835                                 break;
1836                         } else {
1837                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
1838                                 usleep(10000);
1839                                 count++;
1840                                 if (VC_RETRY_COUNT == count) {
1841                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1842                                         break;
1843                                 }
1844                         }
1845                 } else {
1846                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
1847                 }
1848         }
1849
1850         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1851         SLOG(LOG_DEBUG, TAG_VCC, " ");
1852
1853         return ret;
1854 }
1855
1856 int vc_auth_stop(void)
1857 {
1858         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1859
1860         vc_state_e state;
1861         if (0 != vc_client_get_client_state(g_vc, &state)) {
1862                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1863                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1864                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1865                 return VC_ERROR_INVALID_STATE;
1866         }
1867
1868         /* check state */
1869         if (state != VC_STATE_READY) {
1870                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1871                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1872                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1873                 return VC_ERROR_INVALID_STATE;
1874         }
1875
1876         /* Check service state */
1877         vc_service_state_e service_state = -1;
1878         vc_client_get_service_state(g_vc, &service_state);
1879         if (service_state != VC_SERVICE_STATE_RECORDING) {
1880                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1881                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1882                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1883                 return VC_ERROR_INVALID_STATE;
1884         }
1885
1886         /* Check authority */
1887         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1888         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1889                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1890                 return VC_ERROR_OPERATION_FAILED;
1891         }
1892
1893         if (VC_AUTH_STATE_VALID != auth_state) {
1894                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1895                 return VC_ERROR_OPERATION_FAILED;
1896         }
1897
1898         /* get mgr_pid */
1899         int mgr_pid = -1;
1900         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1901                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1902                 return VC_ERROR_OPERATION_FAILED;
1903         }
1904
1905         int ret = -1;
1906         int count = 0;
1907         /* do request */
1908         while (0 != ret) {
1909                 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
1910                 if (0 != ret) {
1911                         if (VC_ERROR_TIMED_OUT != ret) {
1912                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
1913                                 break;
1914                         } else {
1915                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
1916                                 usleep(10000);
1917                                 count++;
1918                                 if (VC_RETRY_COUNT == count) {
1919                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1920                                         break;
1921                                 }
1922                         }
1923                 } else {
1924                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
1925                 }
1926         }
1927
1928         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1929         SLOG(LOG_DEBUG, TAG_VCC, " ");
1930
1931         return ret;
1932 }
1933
1934 int vc_auth_cancel(void)
1935 {
1936         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
1937
1938         vc_state_e state;
1939         if (0 != vc_client_get_client_state(g_vc, &state)) {
1940                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1941                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1942                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1943                 return VC_ERROR_INVALID_STATE;
1944         }
1945
1946         /* check state */
1947         if (state != VC_STATE_READY) {
1948                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1949                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1950                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1951                 return VC_ERROR_INVALID_STATE;
1952         }
1953
1954         /* Check service state */
1955         vc_service_state_e service_state = -1;
1956         vc_client_get_service_state(g_vc, &service_state);
1957         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1958                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1959                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1960                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1961                 return VC_ERROR_INVALID_STATE;
1962         }
1963
1964         /* Check authority */
1965         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1966         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1967                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1968                 return VC_ERROR_OPERATION_FAILED;
1969         }
1970
1971         if (VC_AUTH_STATE_VALID != auth_state) {
1972                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1973                 return VC_ERROR_OPERATION_FAILED;
1974         }
1975
1976         /* get mgr_pid */
1977         int mgr_pid = -1;
1978         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1979                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1980                 return VC_ERROR_OPERATION_FAILED;
1981         }
1982
1983         int ret = -1;
1984         int count = 0;
1985         while (0 != ret) {
1986                 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
1987                 if (0 != ret) {
1988                         if (VC_ERROR_TIMED_OUT != ret) {
1989                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
1990                                 break;
1991                         } else {
1992                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
1993                                 usleep(10000);
1994                                 count++;
1995                                 if (VC_RETRY_COUNT == count) {
1996                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1997                                         break;
1998                                 }
1999                         }
2000                 } else {
2001                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2002                 }
2003         }
2004
2005         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2006         SLOG(LOG_DEBUG, TAG_VCC, " ");
2007
2008         return ret;
2009 }