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