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