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