client/vc.c

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