client/vc.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <aul.h>
  18 #include <app_manager.h>
  19 #include <cynara-client.h>
  20 #include <cynara-error.h>
  21 #include <cynara-session.h>
  22 #include <Ecore_Wayland.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <stdbool.h>
  26 #include <system_info.h>
  27
  28 #include "vc_client.h"
  29 #include "vc_cmd_db.h"
  30 #include "vc_command.h"
  31 #include "vc_config_mgr.h"
  32 #include "vc_dbus.h"
  33 #include "vc_info_parser.h"
  34 #include "vc_json_parser.h"
  35 #include "vc_main.h"
  36 #include "voice_control.h"
  37 #include "voice_control_internal.h"
  38 #include "voice_control_authority.h"
  39 #include "voice_control_command.h"
  40 #include "voice_control_command_expand.h"
  41
  42
  43
  44 static Ecore_Timer* g_connect_timer = NULL;
  45
  46 static Ecore_Event_Handler* g_focus_in_handler = NULL;
  47 static Ecore_Event_Handler* g_focus_out_handler = NULL;
  48
  49 static vc_h g_vc = NULL;
  50
  51 static int g_daemon_pid = 0;
  52
  53 static int g_feature_enabled = -1;
  54
  55 static int g_privilege_allowed = -1;
  56 static cynara *p_cynara = NULL;
  57
  58 Eina_Bool __vc_notify_state_changed(void *data);
  59 Eina_Bool __vc_notify_error(void *data);
  60
  61 static int __vc_get_feature_enabled()
  62 {
  63         if (0 == g_feature_enabled) {
  64                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  65                 return VC_ERROR_NOT_SUPPORTED;
  66         } else if (-1 == g_feature_enabled) {
  67                 bool vc_supported = false;
  68                 bool mic_supported = false;
  69                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  70                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  71                                 if (false == vc_supported || false == mic_supported) {
  72                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  73                                         g_feature_enabled = 0;
  74                                         return VC_ERROR_NOT_SUPPORTED;
  75                                 }
  76
  77                                 g_feature_enabled = 1;
  78                         } else {
  79                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
  80                                 return VC_ERROR_NOT_SUPPORTED;
  81                         }
  82                 } else {
  83                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
  84                         return VC_ERROR_NOT_SUPPORTED;
  85                 }
  86         }
  87
  88         return 0;
  89 }
  90
  91 static int __check_privilege_initialize()
  92 {
  93         int ret = cynara_initialize(&p_cynara, NULL);
  94         if (CYNARA_API_SUCCESS != ret)
  95                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize");
  96
  97         return ret == CYNARA_API_SUCCESS;
  98 }
  99
 100 static int __check_privilege(const char* uid, const char * privilege)
 101 {
 102         FILE *fp = NULL;
 103         char label_path[1024] = "/proc/self/attr/current";
 104         char smack_label[1024] = {'\0',};
 105
 106         if (!p_cynara) {
 107             return false;
 108         }
 109
 110         fp = fopen(label_path, "r");
 111         if (fp != NULL) {
 112             if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
 113                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread");
 114
 115             fclose(fp);
 116         }
 117
 118         pid_t pid = getpid();
 119         char *session = cynara_session_from_pid(pid);
 120         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 121         SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
 122         if (session)
 123             free(session);
 124
 125         if (ret != CYNARA_API_ACCESS_ALLOWED)
 126             return false;
 127         return true;
 128 }
 129
 130 static void __check_privilege_deinitialize()
 131 {
 132         if (p_cynara)
 133                 cynara_finish(p_cynara);
 134         p_cynara = NULL;
 135 }
 136
 137 static int __vc_check_privilege()
 138 {
 139         char uid[16];
 140
 141         if (0 == g_privilege_allowed) {
 142                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
 143                 return VC_ERROR_PERMISSION_DENIED;
 144         } else if (-1 == g_privilege_allowed) {
 145                 if (false == __check_privilege_initialize()) {
 146                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
 147                         return VC_ERROR_PERMISSION_DENIED;
 148                 }
 149                 snprintf(uid, 16, "%d", getuid());
 150                 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
 151                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
 152                         g_privilege_allowed = 0;
 153                         __check_privilege_deinitialize();
 154                         return VC_ERROR_PERMISSION_DENIED;
 155                 }
 156                 __check_privilege_deinitialize();
 157         }
 158
 159         g_privilege_allowed = 1;
 160         return VC_ERROR_NONE;
 161 }
 162
 163 static const char* __vc_get_error_code(vc_error_e err)
 164 {
 165         switch (err) {
 166         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
 167         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
 168         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
 169         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
 170         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
 171         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
 172         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
 173         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
 174         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
 175         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
 176         default:                                return "Invalid error code";
 177         }
 178         return NULL;
 179 }
 180
 181 static int __vc_convert_config_error_code(vc_config_error_e code)
 182 {
 183         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
 184         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
 185         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
 186         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
 187         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
 188         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
 189         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
 190         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
 191
 192         return VC_ERROR_NONE;
 193 }
 194
 195 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
 196 {
 197         SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
 198                  before_lang, current_lang);
 199
 200         vc_current_language_changed_cb callback;
 201         void* lang_user_data;
 202         vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
 203
 204         if (NULL != callback) {
 205                 vc_client_use_callback(g_vc);
 206                 callback(before_lang, current_lang, lang_user_data);
 207                 vc_client_not_use_callback(g_vc);
 208                 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
 209         } else {
 210                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
 211         }
 212
 213         return;
 214 }
 215
 216 static Eina_Bool __notify_auth_changed_cb(void *data)
 217 {
 218         vc_auth_state_changed_cb callback = NULL;
 219         void* user_data;
 220
 221         vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
 222
 223         vc_auth_state_e before = -1;
 224         vc_auth_state_e current = -1;
 225
 226         vc_client_get_before_auth_state(g_vc, &before, &current);
 227
 228         if (NULL != callback) {
 229                 vc_client_use_callback(g_vc);
 230                 callback(before, current, user_data);
 231                 vc_client_not_use_callback(g_vc);
 232                 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
 233         } else {
 234                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
 235         }
 236
 237         return EINA_FALSE;
 238 }
 239
 240 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
 241 {
 242         SLOG(LOG_DEBUG, TAG_VCC, "===== Focus changed");
 243
 244         int ret;
 245         if (ECORE_WL_EVENT_FOCUS_IN == type) {
 246                 SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
 247                 ret = vc_dbus_set_foreground(getpid(), true);
 248                 if (0 != ret) {
 249                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
 250                 }
 251
 252                 ret = vc_client_set_is_foreground(g_vc, true);
 253                 if (0 != ret) {
 254                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
 255                 }
 256
 257                 /* set authority valid */
 258                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 259                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 260                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 261                 }
 262                 if (VC_AUTH_STATE_INVALID == state) {
 263                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
 264
 265                         /* notify auth changed cb */
 266                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 267                 }
 268         } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
 269                 SLOG(LOG_DEBUG, TAG_VCW, "===== Set background");
 270                 ret = vc_dbus_set_foreground(getpid(), false);
 271                 if (0 != ret) {
 272                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
 273                 }
 274
 275                 ret = vc_client_set_is_foreground(g_vc, false);
 276                 if (0 != ret) {
 277                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
 278                 }
 279
 280                 /* set authority valid */
 281                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 282                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 283                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 284                 }
 285                 if (VC_AUTH_STATE_VALID == state) {
 286                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
 287
 288                         /* notify authority changed cb */
 289                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 290                 }
 291         } else {
 292                 SLOG(LOG_DEBUG, TAG_VCC, "===== type(%d) is NOT valid", type);
 293         }
 294
 295         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 296         SLOG(LOG_DEBUG, TAG_VCC, "");
 297
 298         return ECORE_CALLBACK_RENEW;
 299 }
 300
 301 int vc_initialize(void)
 302 {
 303         if (0 != __vc_get_feature_enabled()) {
 304                 return VC_ERROR_NOT_SUPPORTED;
 305         }
 306         if (0 != __vc_check_privilege()) {
 307                 return VC_ERROR_PERMISSION_DENIED;
 308         }
 309
 310         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
 311
 312         /* check handle */
 313         if (true == vc_client_is_valid(g_vc)) {
 314                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already initialized");
 315                 return VC_ERROR_INVALID_STATE;
 316         }
 317
 318         if (0 < vc_client_get_count()) {
 319                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
 320                 return VC_ERROR_INVALID_STATE;
 321         }
 322
 323         if (0 != vc_dbus_open_connection()) {
 324                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
 325                 return VC_ERROR_OPERATION_FAILED;
 326         }
 327
 328         if (0 != vc_client_create(&g_vc)) {
 329                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
 330                 return VC_ERROR_OUT_OF_MEMORY;
 331         }
 332
 333         int ret = vc_config_mgr_initialize(g_vc->handle);
 334         if (0 != ret) {
 335                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
 336                          __vc_get_error_code(__vc_convert_config_error_code(ret)));
 337                 vc_client_destroy(g_vc);
 338                 return __vc_convert_config_error_code(ret);
 339         }
 340
 341         ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
 342         if (0 != ret) {
 343                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
 344                 vc_config_mgr_finalize(g_vc->handle);
 345                 vc_client_destroy(g_vc);
 346                 return __vc_convert_config_error_code(ret);
 347         }
 348
 349         ret = vc_db_initialize();
 350         if (0 != ret) {
 351                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret);
 352                 vc_config_mgr_finalize(g_vc->handle);
 353                 vc_client_destroy(g_vc);
 354                 return ret;
 355         }
 356
 357         SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
 358
 359         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 360         SLOG(LOG_DEBUG, TAG_VCC, " ");
 361
 362         return VC_ERROR_NONE;
 363 }
 364
 365 static void __vc_internal_unprepare(void)
 366 {
 367         /* return authority */
 368         vc_auth_state_e state = VC_AUTH_STATE_NONE;
 369         if (0 != vc_client_get_auth_state(g_vc, &state)) {
 370                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 371         }
 372
 373         if (VC_AUTH_STATE_NONE != state) {
 374                 if (0 != vc_auth_disable()) {
 375                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
 376                 }
 377         }
 378
 379         int ret = vc_dbus_request_finalize(g_vc->handle);
 380         if (0 != ret) {
 381                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
 382         }
 383
 384         if (NULL != g_focus_in_handler) {
 385                 ecore_event_handler_del(g_focus_in_handler);
 386                 g_focus_in_handler = NULL;
 387         }
 388         if (NULL != g_focus_out_handler) {
 389                 ecore_event_handler_del(g_focus_out_handler);
 390                 g_focus_out_handler = NULL;
 391         }
 392
 393         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 394         if (0 != ret)
 395                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
 396
 397         return;
 398 }
 399
 400 int vc_deinitialize(void)
 401 {
 402         if (0 != __vc_get_feature_enabled()) {
 403                 return VC_ERROR_NOT_SUPPORTED;
 404         }
 405         if (0 != __vc_check_privilege()) {
 406                 return VC_ERROR_PERMISSION_DENIED;
 407         }
 408
 409         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
 410
 411         if (false == vc_client_is_valid(g_vc)) {
 412                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
 413                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 414                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 415                 return VC_ERROR_INVALID_STATE;
 416         }
 417
 418         vc_state_e state;
 419         vc_client_get_client_state(g_vc, &state);
 420
 421         /* check state */
 422         switch (state) {
 423         case VC_STATE_READY:
 424                 __vc_internal_unprepare();
 425                 /* no break. need to next step*/
 426         case VC_STATE_INITIALIZED:
 427                 if (NULL != g_connect_timer) {
 428                         SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
 429                         ecore_timer_del(g_connect_timer);
 430                 }
 431
 432                 vc_config_mgr_unset_lang_cb(g_vc->handle);
 433                 vc_config_mgr_finalize(g_vc->handle);
 434
 435                 /* Free client resources */
 436                 vc_client_destroy(g_vc);
 437                 g_vc = NULL;
 438                 break;
 439         case VC_STATE_NONE:
 440                 break;
 441         }
 442
 443         SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
 444         int ret = vc_db_finalize();
 445         if (0 != ret) {
 446                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret);
 447         }
 448
 449         if (0 != vc_dbus_close_connection()) {
 450                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
 451         }
 452
 453         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 454         SLOG(LOG_DEBUG, TAG_VCC, " ");
 455
 456         return VC_ERROR_NONE;
 457 }
 458
 459 static Eina_Bool __vc_connect_daemon(void *data)
 460 {
 461         /* Send hello */
 462         if (0 != vc_dbus_request_hello()) {
 463                 return EINA_TRUE;
 464         }
 465
 466         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
 467
 468         /* request initialization */
 469         int ret = -1;
 470         int mgr_pid = -1;
 471         int service_state = 0;
 472
 473         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 474         if (0 != ret)
 475                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
 476
 477         ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
 478         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 479                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
 480
 481                 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
 482                 ecore_timer_add(0, __vc_notify_error, g_vc);
 483
 484                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 485                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 486                 return EINA_FALSE;
 487
 488         } else if (0 != ret) {
 489                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
 490
 491                 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
 492                 ecore_timer_add(0, __vc_notify_error, g_vc);
 493
 494                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 495                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 496                 return EINA_FALSE;
 497         } else {
 498                 /* Success to connect */
 499         }
 500
 501         /* Set service state */
 502         vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
 503
 504         g_connect_timer = NULL;
 505
 506         g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
 507         g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
 508
 509         char appid[255] = {'\0',};
 510         aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
 511
 512         int status = aul_app_get_status(appid);
 513         if (STATUS_FOCUS == status) {
 514                 SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
 515                 ret = vc_dbus_set_foreground(getpid(), true);
 516                 if (0 != ret) {
 517                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
 518                 }
 519
 520                 ret = vc_client_set_is_foreground(g_vc, true);
 521                 if (0 != ret) {
 522                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
 523                 }
 524
 525                 /* set authority valid */
 526                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 527                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 528                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 529                 }
 530                 if (VC_AUTH_STATE_INVALID == state) {
 531                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
 532
 533                         /* notify auth changed cb */
 534                         ecore_idler_add(__notify_auth_changed_cb, NULL);
 535                 }
 536         }
 537
 538         vc_client_set_client_state(g_vc, VC_STATE_READY);
 539         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 540
 541         vc_client_set_mgr_pid(g_vc, mgr_pid);
 542
 543         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 544         SLOG(LOG_DEBUG, TAG_VCC, "  ");
 545
 546         return EINA_FALSE;
 547 }
 548
 549 int vc_prepare(void)
 550 {
 551         if (0 != __vc_get_feature_enabled()) {
 552                 return VC_ERROR_NOT_SUPPORTED;
 553         }
 554         if (0 != __vc_check_privilege()) {
 555                 return VC_ERROR_PERMISSION_DENIED;
 556         }
 557
 558         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
 559
 560         vc_state_e state;
 561         if (0 != vc_client_get_client_state(g_vc, &state)) {
 562                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 563                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 564                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 565                 return VC_ERROR_INVALID_STATE;
 566         }
 567
 568         /* check state */
 569         if (state != VC_STATE_INITIALIZED) {
 570                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 571                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 572                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 573                 return VC_ERROR_INVALID_STATE;
 574         }
 575
 576         g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
 577
 578         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 579         SLOG(LOG_DEBUG, TAG_VCC, " ");
 580
 581         return VC_ERROR_NONE;
 582 }
 583
 584 int vc_unprepare(void)
 585 {
 586         if (0 != __vc_get_feature_enabled()) {
 587                 return VC_ERROR_NOT_SUPPORTED;
 588         }
 589         if (0 != __vc_check_privilege()) {
 590                 return VC_ERROR_PERMISSION_DENIED;
 591         }
 592
 593         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
 594
 595         vc_state_e state;
 596         if (0 != vc_client_get_client_state(g_vc, &state)) {
 597                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 598                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 599                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 600                 return VC_ERROR_INVALID_STATE;
 601         }
 602
 603         /* check state */
 604         if (state != VC_STATE_READY) {
 605                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 606                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 607                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 608                 return VC_ERROR_INVALID_STATE;
 609         }
 610
 611         __vc_internal_unprepare();
 612
 613         vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
 614         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 615
 616         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 617         SLOG(LOG_DEBUG, TAG_VCC, " ");
 618
 619         return VC_ERROR_NONE;
 620 }
 621
 622 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 623 {
 624         if (0 != __vc_get_feature_enabled()) {
 625                 return VC_ERROR_NOT_SUPPORTED;
 626         }
 627         if (0 != __vc_check_privilege()) {
 628                 return VC_ERROR_PERMISSION_DENIED;
 629         }
 630
 631         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
 632
 633         if (NULL == callback) {
 634                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 635                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 636                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 637                 return VC_ERROR_INVALID_PARAMETER;
 638         }
 639
 640         vc_state_e state;
 641         if (0 != vc_client_get_client_state(g_vc, &state)) {
 642                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 643                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 644                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 645                 return VC_ERROR_INVALID_STATE;
 646         }
 647
 648         int ret = -1;
 649         ret = vc_config_mgr_get_language_list(callback, user_data);
 650         if (0 != ret) {
 651                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 652                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
 653         }
 654
 655         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 656         SLOG(LOG_DEBUG, TAG_VCC, " ");
 657
 658         return VC_ERROR_NONE;
 659 }
 660
 661
 662 int vc_get_current_language(char** language)
 663 {
 664         if (0 != __vc_get_feature_enabled()) {
 665                 return VC_ERROR_NOT_SUPPORTED;
 666         }
 667         if (0 != __vc_check_privilege()) {
 668                 return VC_ERROR_PERMISSION_DENIED;
 669         }
 670
 671         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
 672
 673         if (NULL == language) {
 674                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 675                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 676                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 677                 return VC_ERROR_INVALID_PARAMETER;
 678         }
 679
 680         vc_state_e state;
 681         if (0 != vc_client_get_client_state(g_vc, &state)) {
 682                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 683                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 684                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 685                 return VC_ERROR_INVALID_STATE;
 686         }
 687
 688         int ret = -1;
 689         ret = vc_config_mgr_get_default_language(language);
 690         if (0 != ret) {
 691                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 692                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
 693         }
 694
 695         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 696         SLOG(LOG_DEBUG, TAG_VCC, " ");
 697
 698         return ret;
 699 }
 700
 701 int vc_get_state(vc_state_e* state)
 702 {
 703         if (0 != __vc_get_feature_enabled()) {
 704                 return VC_ERROR_NOT_SUPPORTED;
 705         }
 706         if (0 != __vc_check_privilege()) {
 707                 return VC_ERROR_PERMISSION_DENIED;
 708         }
 709
 710         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
 711
 712         if (NULL == state) {
 713                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 714                 return VC_ERROR_INVALID_PARAMETER;
 715         }
 716
 717         vc_state_e temp;
 718         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 719                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 720                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 721                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 722                 return VC_ERROR_INVALID_STATE;
 723         }
 724
 725         *state = temp;
 726
 727         switch (*state) {
 728         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'");            break;
 729         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'");         break;
 730         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'");           break;
 731         default:                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
 732         }
 733
 734         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 735         SLOG(LOG_DEBUG, TAG_VCC, " ");
 736
 737         return VC_ERROR_NONE;
 738 }
 739
 740 int vc_get_service_state(vc_service_state_e* state)
 741 {
 742         if (0 != __vc_get_feature_enabled()) {
 743                 return VC_ERROR_NOT_SUPPORTED;
 744         }
 745         if (0 != __vc_check_privilege()) {
 746                 return VC_ERROR_PERMISSION_DENIED;
 747         }
 748
 749         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
 750
 751         if (NULL == state) {
 752                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 753                 return VC_ERROR_INVALID_PARAMETER;
 754         }
 755
 756         vc_state_e temp;
 757         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 758                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 759                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 760                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 761                 return VC_ERROR_INVALID_STATE;
 762         }
 763
 764         if (VC_STATE_READY != temp) {
 765                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 766                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 767                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 768                 return VC_ERROR_INVALID_STATE;
 769         }
 770
 771         /* get service state */
 772         vc_service_state_e service_state;
 773         if (0 != vc_client_get_service_state(g_vc, &service_state)) {
 774                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
 775                 return VC_ERROR_OPERATION_FAILED;
 776         }
 777
 778         *state = service_state;
 779
 780         switch (*state) {
 781         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'");            break;
 782         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'");           break;
 783         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'");       break;
 784         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'");      break;
 785         default:                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
 786         }
 787
 788         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 789         SLOG(LOG_DEBUG, TAG_VCC, " ");
 790
 791         return VC_ERROR_NONE;
 792 }
 793
 794 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
 795 {
 796         if (0 != __vc_get_feature_enabled()) {
 797                 return VC_ERROR_NOT_SUPPORTED;
 798         }
 799         if (0 != __vc_check_privilege()) {
 800                 return VC_ERROR_PERMISSION_DENIED;
 801         }
 802
 803         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get system command list");
 804
 805         if (NULL == vc_sys_cmd_list) {
 806                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 807                 return VC_ERROR_INVALID_PARAMETER;
 808         }
 809
 810         vc_state_e state;
 811         if (0 != vc_client_get_client_state(g_vc, &state)) {
 812                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 813                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 814                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 815                 return VC_ERROR_INVALID_STATE;
 816         }
 817
 818         /* check state */
 819         if (state != VC_STATE_READY) {
 820                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 821                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 822                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 823                 return VC_ERROR_INVALID_STATE;
 824         }
 825
 826         /* Check service state */
 827         vc_service_state_e service_state = -1;
 828         vc_client_get_service_state(g_vc, &service_state);
 829         if (service_state != VC_SERVICE_STATE_READY) {
 830                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
 831                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 832                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 833                 return VC_ERROR_INVALID_STATE;
 834         }
 835
 836         bool is_sys_cmd_valid = false;
 837         int count = 0;
 838         int ret = -1;
 839
 840         do {
 841                 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
 842                 if (0 != ret) {
 843                         if (VC_ERROR_TIMED_OUT != ret) {
 844                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
 845                                 break;
 846                         } else {
 847                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
 848                                 usleep(10000);
 849                                 count++;
 850                                 if (VC_RETRY_COUNT == count) {
 851                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
 852                                         break;
 853                                 }
 854                         }
 855                 }
 856         } while (0 != ret);
 857
 858         int mgr_pid = -1;
 859         ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
 860         if (0 != ret) {
 861                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
 862                 return VC_ERROR_OPERATION_FAILED;
 863         }
 864
 865         vc_cmd_list_s* list = NULL;
 866         list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
 867         if (true == is_sys_cmd_valid) {
 868                 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
 869                 if (0 != ret) {
 870                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
 871                         return ret;
 872                 }
 873                 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
 874                 if (0 != ret) {
 875                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
 876                         return ret;
 877                 }
 878                 *vc_sys_cmd_list = (vc_cmd_list_h)list;
 879         } else {
 880                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
 881                 *vc_sys_cmd_list = NULL;
 882                 return VC_ERROR_NONE;
 883         }
 884
 885         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 886         SLOG(LOG_DEBUG, TAG_VCC, " ");
 887
 888         return ret;
 889 }
 890
 891 /**
 892 * @brief Checks whether the command format is supported.
 893 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
 894 *
 895 * @param[in] format The command format
 896 * @param[out] support The result status @c true = supported, @c false = not supported
 897 *
 898 * @return 0 on success, otherwise a negative error value
 899 * @retval #VC_ERROR_NONE Successful
 900 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 901 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 902 * @retval #VC_ERROR_INVALID_STATE Invalid state
 903 *
 904 * @pre The state should be #VC_STATE_READY.
 905 */
 906 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
 907 {
 908         if (0 != __vc_get_feature_enabled()) {
 909                 return VC_ERROR_NOT_SUPPORTED;
 910         }
 911         if (0 != __vc_check_privilege()) {
 912                 return VC_ERROR_PERMISSION_DENIED;
 913         }
 914
 915         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
 916
 917         vc_state_e state;
 918         if (0 != vc_client_get_client_state(g_vc, &state)) {
 919                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 920                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 921                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 922                 return VC_ERROR_INVALID_STATE;
 923         }
 924
 925         /* check support */
 926         bool non_fixed_support = false;
 927         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 928                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
 929         }
 930
 931         switch (format) {
 932         case VC_CMD_FORMAT_FIXED:               *support = true;                break;
 933         case VC_CMD_FORMAT_FIXED_AND_VFIXED:    *support = true;                break;
 934         case VC_CMD_FORMAT_VFIXED_AND_FIXED:    *support = true;                break;
 935         case VC_CMD_FORMAT_FIXED_AND_NONFIXED:  *support = non_fixed_support;   break;
 936         case VC_CMD_FORMAT_NONFIXED_AND_FIXED:  *support = non_fixed_support;   break;
 937         default:                                *support = false;               break;
 938         }
 939
 940         SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 941
 942         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 943         SLOG(LOG_DEBUG, TAG_VCC, " ");
 944
 945         return VC_ERROR_NONE;
 946 }
 947
 948 static int __vc_get_invocation_name(char** invocation_name)
 949 {
 950         int ret = vc_client_get_invocation_name(g_vc, invocation_name);
 951         if (0 != ret) {
 952                 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
 953                 return ret;
 954         }
 955
 956         if (NULL == *invocation_name) {
 957                 char* temp_label = NULL;
 958                 char* appid = NULL;
 959                 char* lang = NULL;
 960
 961                 ret = app_manager_get_app_id(getpid(), &appid);
 962                 if (0 != ret || NULL == appid) {
 963                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
 964                         if (NULL != appid) {
 965                                 free(appid);
 966                                 appid = NULL;
 967                         }
 968                         return VC_ERROR_OPERATION_FAILED;
 969                 }
 970
 971                 ret = vc_get_current_language(&lang);
 972                 if (0 != ret || NULL == lang) {
 973                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
 974                         free(appid);
 975                         appid = NULL;
 976                         if (NULL != lang) {
 977                                 free(lang);
 978                                 lang = NULL;
 979                         }
 980                         return VC_ERROR_OPERATION_FAILED;
 981                 }
 982
 983                 ret = app_info_get_localed_label(appid, lang, &temp_label);
 984                 if (0 != ret || NULL == temp_label) {
 985                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
 986                         free(appid);
 987                         appid = NULL;
 988                         free(lang);
 989                         lang = NULL;
 990                         if (NULL != temp_label) {
 991                                 free(temp_label);
 992                                 temp_label = NULL;
 993                         }
 994                         return VC_ERROR_OPERATION_FAILED;
 995                 }
 996
 997                 *invocation_name = strdup(temp_label);
 998                 if (NULL == *invocation_name) {
 999                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1000                         return VC_ERROR_OUT_OF_MEMORY;
1001                 }
1002
1003                 free(appid);
1004                 appid = NULL;
1005                 free(lang);
1006                 lang = NULL;
1007                 free(temp_label);
1008                 temp_label = NULL;
1009         }
1010
1011         SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1012         return VC_ERROR_NONE;
1013 }
1014
1015 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1016 {
1017         if (0 != __vc_get_feature_enabled()) {
1018                 return VC_ERROR_NOT_SUPPORTED;
1019         }
1020         if (0 != __vc_check_privilege()) {
1021                 return VC_ERROR_PERMISSION_DENIED;
1022         }
1023
1024         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
1025
1026         if (NULL == vc_cmd_list) {
1027                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1028                 return VC_ERROR_INVALID_PARAMETER;
1029         }
1030
1031         vc_state_e state;
1032         if (0 != vc_client_get_client_state(g_vc, &state)) {
1033                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1034                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1035                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1036                 return VC_ERROR_INVALID_STATE;
1037         }
1038
1039         /* check state */
1040         if (state != VC_STATE_READY) {
1041                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1042                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1043                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1044                 return VC_ERROR_INVALID_STATE;
1045         }
1046
1047         /* check type */
1048         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1049                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1050                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1051                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1052                 return VC_ERROR_INVALID_PARAMETER;
1053         }
1054
1055         vc_cmd_list_s* list = NULL;
1056         list = (vc_cmd_list_s*)vc_cmd_list;
1057
1058         int ret = 0;
1059         char* invocation_name = NULL;
1060         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1061                 ret = __vc_get_invocation_name(&invocation_name);
1062                 if (0 != ret || NULL == invocation_name) {
1063                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1064                         return ret;
1065                 }
1066         }
1067
1068         ret = vc_cmd_parser_delete_file(getpid(), type);
1069         if (0 != ret)
1070                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1071
1072         ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1073         if (0 != ret) {
1074                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1075         } else {
1076                 int count = 0;
1077                 do {
1078                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1079                         if (0 != ret) {
1080                                 if (VC_ERROR_TIMED_OUT != ret) {
1081                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1082                                         break;
1083                                 } else {
1084                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1085                                         usleep(10000);
1086                                         count++;
1087                                         if (VC_RETRY_COUNT == count) {
1088                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1089                                                 break;
1090                                         }
1091                                 }
1092                         }
1093                 } while (0 != ret);
1094         }
1095
1096         if (NULL != invocation_name) {
1097                 free(invocation_name);
1098                 invocation_name = NULL;
1099         }
1100
1101         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1102         SLOG(LOG_DEBUG, TAG_VCC, " ");
1103
1104         return ret;
1105 }
1106
1107 int vc_unset_command_list(int type)
1108 {
1109         if (0 != __vc_get_feature_enabled()) {
1110                 return VC_ERROR_NOT_SUPPORTED;
1111         }
1112         if (0 != __vc_check_privilege()) {
1113                 return VC_ERROR_PERMISSION_DENIED;
1114         }
1115
1116         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1117
1118         vc_state_e state;
1119         if (0 != vc_client_get_client_state(g_vc, &state)) {
1120                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1121                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1122                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1123                 return VC_ERROR_INVALID_STATE;
1124         }
1125
1126         /* check state */
1127         if (state != VC_STATE_READY) {
1128                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1129                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1130                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1131                 return VC_ERROR_INVALID_STATE;
1132         }
1133
1134         int count = 0;
1135         int ret = -1;
1136         while (0 != ret) {
1137                 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1138                 if (0 != ret) {
1139                         if (VC_ERROR_TIMED_OUT != ret) {
1140                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1141                                 break;
1142                         } else {
1143                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1144                                 usleep(10000);
1145                                 count++;
1146                                 if (VC_RETRY_COUNT == count) {
1147                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1148                                         break;
1149                                 }
1150                         }
1151                 }
1152         }
1153
1154         ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1155         if (0 != ret) {
1156                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1157                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1158         }
1159
1160         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1161         SLOG(LOG_DEBUG, TAG_VCC, " ");
1162
1163         return ret;
1164 }
1165
1166 int vc_set_command_list_from_file(const char* file_path, int type)
1167 {
1168         if (0 != __vc_get_feature_enabled()) {
1169                 return VC_ERROR_NOT_SUPPORTED;
1170         }
1171         if (0 != __vc_check_privilege()) {
1172                 return VC_ERROR_PERMISSION_DENIED;
1173         }
1174
1175         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list from file");
1176
1177         vc_state_e state;
1178         if (0 != vc_client_get_client_state(g_vc, &state)) {
1179                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1180                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1181                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1182                 return VC_ERROR_INVALID_STATE;
1183         }
1184
1185         /* check state */
1186         if (state != VC_STATE_READY) {
1187                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1188                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1189                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1190                 return VC_ERROR_INVALID_STATE;
1191         }
1192
1193         /* check type */
1194         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1195                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1196                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1197                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1198                 return VC_ERROR_INVALID_PARAMETER;
1199         }
1200
1201         int ret = 0;
1202         char* invocation_name = NULL;
1203         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1204                 ret = __vc_get_invocation_name(&invocation_name);
1205                 if (0 != ret || NULL == invocation_name) {
1206                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1207                         return ret;
1208                 }
1209         }
1210
1211         ret = vc_cmd_parser_delete_file(getpid(), type);
1212         if (0 != ret)
1213                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1214
1215         ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1216         if (0 != ret) {
1217                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1218         } else {
1219                 int count = 0;
1220                 do {
1221                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1222                         if (0 != ret) {
1223                                 if (VC_ERROR_TIMED_OUT != ret) {
1224                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1225                                         break;
1226                                 } else {
1227                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1228                                         usleep(10000);
1229                                         count++;
1230                                         if (VC_RETRY_COUNT == count) {
1231                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1232                                                 break;
1233                                         }
1234                                 }
1235                         }
1236                 } while (0 != ret);
1237         }
1238
1239         if (NULL != invocation_name) {
1240                 free(invocation_name);
1241                 invocation_name = NULL;
1242         }
1243
1244         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1245         SLOG(LOG_DEBUG, TAG_VCC, " ");
1246         return ret;
1247 }
1248
1249 #if 0
1250 int vc_get_exclusive_command_option(bool* value)
1251 {
1252         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1253
1254         vc_state_e state;
1255         if (0 != vc_client_get_client_state(g_vc, &state)) {
1256                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1257                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1258                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1259                 return VC_ERROR_INVALID_STATE;
1260         }
1261
1262         /* check state */
1263         if (state != VC_STATE_READY) {
1264                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1265                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1266                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1267                 return VC_ERROR_INVALID_STATE;
1268         }
1269
1270         int ret = vc_client_get_exclusive_cmd(g_vc, value);
1271         if (0 != ret) {
1272                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1273                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1274                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1275                 return ret;
1276         }
1277
1278         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1279         SLOG(LOG_DEBUG, TAG_VCC, " ");
1280
1281         return ret;
1282 }
1283
1284 int vc_set_exclusive_command_option(bool value)
1285 {
1286         if (0 != __vc_get_feature_enabled()) {
1287                 return VC_ERROR_NOT_SUPPORTED;
1288         }
1289         if (0 != __vc_check_privilege()) {
1290                 return VC_ERROR_PERMISSION_DENIED;
1291         }
1292
1293         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
1294
1295         vc_state_e state;
1296         if (0 != vc_client_get_client_state(g_vc, &state)) {
1297                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1298                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1299                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1300                 return VC_ERROR_INVALID_STATE;
1301         }
1302
1303         /* check state */
1304         if (state != VC_STATE_READY) {
1305                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1306                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1307                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1308                 return VC_ERROR_INVALID_STATE;
1309         }
1310
1311         int ret = vc_client_set_exclusive_cmd(g_vc, value);
1312         if (0 != ret) {
1313                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1314                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1315                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1316                 return ret;
1317         }
1318
1319         int count = 0;
1320         do {
1321                 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1322                 if (0 != ret) {
1323                         if (VC_ERROR_TIMED_OUT != ret) {
1324                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1325                                 break;
1326                         } else {
1327                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1328                                 usleep(10000);
1329                                 count++;
1330                                 if (VC_RETRY_COUNT == count) {
1331                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1332                                         break;
1333                                 }
1334                         }
1335                 }
1336         } while (0 != ret);
1337
1338         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1339         SLOG(LOG_DEBUG, TAG_VCC, " ");
1340
1341         return ret;
1342 }
1343 #endif
1344
1345 #if 0
1346 int vc_request_start(bool stop_by_silence)
1347 {
1348         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1349
1350         vc_state_e state;
1351         if (0 != vc_client_get_client_state(g_vc, &state)) {
1352                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1353                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1354                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1355                 return VC_ERROR_INVALID_STATE;
1356         }
1357
1358         /* check state */
1359         if (state != VC_STATE_READY) {
1360                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1361                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1362                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1363                 return VC_ERROR_INVALID_STATE;
1364         }
1365
1366         /* Check service state */
1367         vc_service_state_e service_state = -1;
1368         vc_client_get_service_state(g_vc, &service_state);
1369         if (service_state != VC_SERVICE_STATE_READY) {
1370                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1371                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1372                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1373                 return VC_ERROR_INVALID_STATE;
1374         }
1375
1376         int ret;
1377         int count = 0;
1378
1379         /* Request */
1380         ret = -1;
1381         count = 0;
1382         while (0 != ret) {
1383                 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1384                 if (0 != ret) {
1385                         if (VC_ERROR_TIMED_OUT != ret) {
1386                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1387                                 break;
1388                         } else {
1389                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1390                                 usleep(10000);
1391                                 count++;
1392                                 if (VC_RETRY_COUNT == count) {
1393                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1394                                         break;
1395                                 }
1396                         }
1397                 } else {
1398                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1399                 }
1400         }
1401
1402         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1403         SLOG(LOG_DEBUG, TAG_VCC, " ");
1404
1405         return ret;
1406 }
1407
1408 int vc_request_stop(void)
1409 {
1410         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1411
1412         vc_state_e state;
1413         if (0 != vc_client_get_client_state(g_vc, &state)) {
1414                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1415                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1416                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1417                 return VC_ERROR_INVALID_STATE;
1418         }
1419
1420         /* check state */
1421         if (state != VC_STATE_READY) {
1422                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1423                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1424                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1425                 return VC_ERROR_INVALID_STATE;
1426         }
1427
1428         /* Check service state */
1429         vc_service_state_e service_state = -1;
1430         vc_client_get_service_state(g_vc, &service_state);
1431         if (service_state != VC_SERVICE_STATE_RECORDING) {
1432                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1433                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1434                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1435                 return VC_ERROR_INVALID_STATE;
1436         }
1437
1438         int ret = -1;
1439         int count = 0;
1440         /* do request */
1441         while (0 != ret) {
1442                 ret = vc_dbus_request_stop(g_vc->handle);
1443                 if (0 != ret) {
1444                         if (VC_ERROR_TIMED_OUT != ret) {
1445                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1446                                 break;
1447                         } else {
1448                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1449                                 usleep(10000);
1450                                 count++;
1451                                 if (VC_RETRY_COUNT == count) {
1452                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1453                                         break;
1454                                 }
1455                         }
1456                 } else {
1457                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1458                 }
1459         }
1460
1461         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1462         SLOG(LOG_DEBUG, TAG_VCC, " ");
1463
1464         return ret;
1465 }
1466
1467 int vc_request_cancel(void)
1468 {
1469         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1470
1471         vc_state_e state;
1472         if (0 != vc_client_get_client_state(g_vc, &state)) {
1473                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1474                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1475                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1476                 return VC_ERROR_INVALID_STATE;
1477         }
1478
1479         /* check state */
1480         if (state != VC_STATE_READY) {
1481                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1482                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1483                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1484                 return VC_ERROR_INVALID_STATE;
1485         }
1486
1487         /* Check service state */
1488         vc_service_state_e service_state = -1;
1489         vc_client_get_service_state(g_vc, &service_state);
1490         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1491                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1492                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1493                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1494                 return VC_ERROR_INVALID_STATE;
1495         }
1496
1497         int ret = -1;
1498         int count = 0;
1499         while (0 != ret) {
1500                 ret = vc_dbus_request_cancel(g_vc->handle);
1501                 if (0 != ret) {
1502                         if (VC_ERROR_TIMED_OUT != ret) {
1503                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1504                                 break;
1505                         } else {
1506                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1507                                 usleep(10000);
1508                                 count++;
1509                                 if (VC_RETRY_COUNT == count) {
1510                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1511                                         break;
1512                                 }
1513                         }
1514                 } else {
1515                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1516                 }
1517         }
1518
1519         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1520         SLOG(LOG_DEBUG, TAG_VCC, " ");
1521
1522         return ret;
1523 }
1524 #endif
1525
1526 Eina_Bool __vc_notify_error(void *data)
1527 {
1528         vc_h vc = (vc_h)data;
1529
1530         vc_error_cb callback = NULL;
1531         void* user_data;
1532         int reason;
1533
1534         vc_client_get_error_cb(vc, &callback, &user_data);
1535         vc_client_get_error(vc, &reason);
1536
1537         if (NULL != callback) {
1538                 vc_client_use_callback(vc);
1539                 callback(reason, user_data);
1540                 vc_client_not_use_callback(vc);
1541                 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1542         } else {
1543                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1544         }
1545
1546         return EINA_FALSE;
1547 }
1548
1549 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1550 {
1551         vc_state_e state;
1552         if (0 != vc_client_get_client_state(g_vc, &state)) {
1553                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1554                 return -1;
1555         }
1556
1557         /* check state */
1558         if (state != VC_STATE_READY) {
1559                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1560                 return -1;
1561         }
1562
1563         if (VC_ERROR_SERVICE_RESET == reason) {
1564                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1565
1566                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1567                 __vc_notify_state_changed(g_vc);
1568
1569                 if (0 != vc_prepare()) {
1570                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1571                 }
1572         }
1573
1574         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1575
1576         vc_client_set_error(g_vc, reason);
1577         ecore_timer_add(0, __vc_notify_error, g_vc);
1578
1579         return 0;
1580 }
1581
1582 Eina_Bool __vc_notify_state_changed(void *data)
1583 {
1584         vc_h vc = (vc_h)data;
1585
1586         vc_state_changed_cb changed_callback = NULL;
1587         void* user_data;
1588
1589         vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1590
1591         vc_state_e current_state;
1592         vc_state_e before_state;
1593
1594         vc_client_get_before_state(vc, &current_state, &before_state);
1595
1596         if (NULL != changed_callback) {
1597                 vc_client_use_callback(vc);
1598                 changed_callback(before_state, current_state, user_data);
1599                 vc_client_not_use_callback(vc);
1600                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1601         } else {
1602                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1603         }
1604
1605         return EINA_FALSE;
1606 }
1607
1608 static Eina_Bool __vc_notify_result(void *data)
1609 {
1610         char* temp_text;
1611         int event;
1612         vc_cmd_list_h vc_cmd_list = NULL;
1613
1614         vc_result_cb callback = NULL;
1615         void* user_data = NULL;
1616
1617         vc_client_get_result_cb(g_vc, &callback, &user_data);
1618
1619         if (NULL == callback) {
1620                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1621                 return EINA_FALSE;
1622         }
1623
1624         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1625                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1626                 return EINA_FALSE;
1627         }
1628
1629         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1630
1631         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1632
1633         vc_cmd_print_list(vc_cmd_list);
1634
1635         vc_client_use_callback(g_vc);
1636         callback(event, vc_cmd_list, temp_text, user_data);
1637         vc_client_not_use_callback(g_vc);
1638
1639         SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1640
1641         vc_cmd_list_destroy(vc_cmd_list, true);
1642
1643         /* Release result */
1644         if (NULL != temp_text)  free(temp_text);
1645
1646         return EINA_FALSE;
1647 }
1648
1649 void __vc_cb_result(void)
1650 {
1651         ecore_timer_add(0, __vc_notify_result, NULL);
1652
1653         return;
1654 }
1655
1656 int vc_get_result(vc_result_cb callback, void* user_data)
1657 {
1658         if (0 != __vc_get_feature_enabled()) {
1659                 return VC_ERROR_NOT_SUPPORTED;
1660         }
1661         if (0 != __vc_check_privilege()) {
1662                 return VC_ERROR_PERMISSION_DENIED;
1663         }
1664
1665         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get result");
1666
1667         if (NULL == callback) {
1668                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1669                 return VC_ERROR_INVALID_PARAMETER;
1670         }
1671
1672         char* temp_text = NULL;
1673         int event = 0;
1674         vc_cmd_list_h vc_cmd_list = NULL;
1675
1676         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1677                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1678                 return VC_ERROR_INVALID_PARAMETER;
1679         }
1680
1681         int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1682         if (0 != ret || NULL == temp_text) {
1683                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1684                 return ret;
1685         }
1686
1687         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1688
1689         vc_cmd_print_list(vc_cmd_list);
1690
1691         vc_client_use_callback(g_vc);
1692         callback(event, vc_cmd_list, temp_text, user_data);
1693         vc_client_not_use_callback(g_vc);
1694
1695         vc_cmd_list_destroy(vc_cmd_list, true);
1696
1697         /* Release result */
1698         if (NULL != temp_text) {
1699                 free(temp_text);
1700                 temp_text = NULL;
1701         }
1702
1703         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1704         SLOG(LOG_DEBUG, TAG_VCC, " ");
1705
1706         return VC_ERROR_NONE;
1707 }
1708
1709 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1710 {
1711         if (0 != __vc_get_feature_enabled()) {
1712                 return VC_ERROR_NOT_SUPPORTED;
1713         }
1714         if (0 != __vc_check_privilege()) {
1715                 return VC_ERROR_PERMISSION_DENIED;
1716         }
1717
1718         if (NULL == callback)
1719                 return VC_ERROR_INVALID_PARAMETER;
1720
1721         vc_state_e state;
1722         if (0 != vc_client_get_client_state(g_vc, &state)) {
1723                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1724                 return VC_ERROR_INVALID_STATE;
1725         }
1726
1727         /* check state */
1728         if (state != VC_STATE_INITIALIZED) {
1729                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1730                 return VC_ERROR_INVALID_STATE;
1731         }
1732
1733         vc_client_set_result_cb(g_vc, callback, user_data);
1734
1735         return 0;
1736 }
1737
1738 int vc_unset_result_cb(void)
1739 {
1740         if (0 != __vc_get_feature_enabled()) {
1741                 return VC_ERROR_NOT_SUPPORTED;
1742         }
1743         if (0 != __vc_check_privilege()) {
1744                 return VC_ERROR_PERMISSION_DENIED;
1745         }
1746
1747         vc_state_e state;
1748         if (0 != vc_client_get_client_state(g_vc, &state)) {
1749                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1750                 return VC_ERROR_INVALID_STATE;
1751         }
1752
1753         /* check state */
1754         if (state != VC_STATE_INITIALIZED) {
1755                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1756                 return VC_ERROR_INVALID_STATE;
1757         }
1758
1759         vc_client_set_result_cb(g_vc, NULL, NULL);
1760
1761         return 0;
1762 }
1763
1764 int __vc_cb_service_state(int state)
1765 {
1766         vc_service_state_e current_state = (vc_service_state_e)state;
1767         vc_service_state_e before_state;
1768         vc_client_get_service_state(g_vc, &before_state);
1769
1770         if (current_state == before_state) {
1771                 return 0;
1772         }
1773
1774         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1775                 before_state, current_state);
1776
1777         /* Save service state */
1778         vc_client_set_service_state(g_vc, current_state);
1779
1780         vc_service_state_changed_cb callback = NULL;
1781         void* service_user_data;
1782         vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1783
1784         if (NULL != callback) {
1785                 vc_client_use_callback(g_vc);
1786                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1787                 vc_client_not_use_callback(g_vc);
1788                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1789         } else {
1790                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1791         }
1792
1793         return 0;
1794 }
1795
1796 int __vc_cb_manager_pid(int manager_pid)
1797 {
1798         SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1799
1800         /* Save service state */
1801         vc_client_set_mgr_pid(g_vc, manager_pid);
1802
1803         return 0;
1804 }
1805
1806 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1807 {
1808         if (0 != __vc_get_feature_enabled()) {
1809                 return VC_ERROR_NOT_SUPPORTED;
1810         }
1811         if (0 != __vc_check_privilege()) {
1812                 return VC_ERROR_PERMISSION_DENIED;
1813         }
1814
1815         if (NULL == callback)
1816                 return VC_ERROR_INVALID_PARAMETER;
1817
1818         vc_state_e state;
1819         if (0 != vc_client_get_client_state(g_vc, &state)) {
1820                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1821                 return VC_ERROR_INVALID_STATE;
1822         }
1823
1824         /* check state */
1825         if (state != VC_STATE_INITIALIZED) {
1826                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1827                 return VC_ERROR_INVALID_STATE;
1828         }
1829
1830         vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1831
1832         return 0;
1833 }
1834
1835 int vc_unset_service_state_changed_cb(void)
1836 {
1837         if (0 != __vc_get_feature_enabled()) {
1838                 return VC_ERROR_NOT_SUPPORTED;
1839         }
1840         if (0 != __vc_check_privilege()) {
1841                 return VC_ERROR_PERMISSION_DENIED;
1842         }
1843
1844         vc_state_e state;
1845         if (0 != vc_client_get_client_state(g_vc, &state)) {
1846                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1847                 return VC_ERROR_INVALID_STATE;
1848         }
1849
1850         /* check state */
1851         if (state != VC_STATE_INITIALIZED) {
1852                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1853                 return VC_ERROR_INVALID_STATE;
1854         }
1855
1856         vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1857
1858         return 0;
1859 }
1860
1861 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1862 {
1863         if (0 != __vc_get_feature_enabled()) {
1864                 return VC_ERROR_NOT_SUPPORTED;
1865         }
1866         if (0 != __vc_check_privilege()) {
1867                 return VC_ERROR_PERMISSION_DENIED;
1868         }
1869
1870         if (callback == NULL)
1871                 return VC_ERROR_INVALID_PARAMETER;
1872
1873         vc_state_e state;
1874         if (0 != vc_client_get_client_state(g_vc, &state)) {
1875                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1876                 return VC_ERROR_INVALID_STATE;
1877         }
1878
1879         /* check state */
1880         if (state != VC_STATE_INITIALIZED) {
1881                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1882                 return VC_ERROR_INVALID_STATE;
1883         }
1884
1885         vc_client_set_state_changed_cb(g_vc, callback, user_data);
1886
1887         return 0;
1888 }
1889
1890 int vc_unset_state_changed_cb(void)
1891 {
1892         if (0 != __vc_get_feature_enabled()) {
1893                 return VC_ERROR_NOT_SUPPORTED;
1894         }
1895         if (0 != __vc_check_privilege()) {
1896                 return VC_ERROR_PERMISSION_DENIED;
1897         }
1898
1899         vc_state_e state;
1900         if (0 != vc_client_get_client_state(g_vc, &state)) {
1901                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1902                 return VC_ERROR_INVALID_STATE;
1903         }
1904
1905         /* check state */
1906         if (state != VC_STATE_INITIALIZED) {
1907                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1908                 return VC_ERROR_INVALID_STATE;
1909         }
1910
1911         vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1912
1913         return 0;
1914 }
1915
1916 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1917 {
1918         if (0 != __vc_get_feature_enabled()) {
1919                 return VC_ERROR_NOT_SUPPORTED;
1920         }
1921         if (0 != __vc_check_privilege()) {
1922                 return VC_ERROR_PERMISSION_DENIED;
1923         }
1924
1925         if (NULL == callback)
1926                 return VC_ERROR_INVALID_PARAMETER;
1927
1928         vc_state_e state;
1929         if (0 != vc_client_get_client_state(g_vc, &state)) {
1930                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1931                 return VC_ERROR_INVALID_STATE;
1932         }
1933
1934         /* check state */
1935         if (state != VC_STATE_INITIALIZED) {
1936                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1937                 return VC_ERROR_INVALID_STATE;
1938         }
1939
1940         vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1941
1942         return 0;
1943 }
1944
1945 int vc_unset_current_language_changed_cb(void)
1946 {
1947         if (0 != __vc_get_feature_enabled()) {
1948                 return VC_ERROR_NOT_SUPPORTED;
1949         }
1950         if (0 != __vc_check_privilege()) {
1951                 return VC_ERROR_PERMISSION_DENIED;
1952         }
1953
1954         vc_state_e state;
1955         if (0 != vc_client_get_client_state(g_vc, &state)) {
1956                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1957                 return VC_ERROR_INVALID_STATE;
1958         }
1959
1960         /* check state */
1961         if (state != VC_STATE_INITIALIZED) {
1962                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1963                 return VC_ERROR_INVALID_STATE;
1964         }
1965
1966         vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1967
1968         return 0;
1969 }
1970
1971 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1972 {
1973         if (0 != __vc_get_feature_enabled()) {
1974                 return VC_ERROR_NOT_SUPPORTED;
1975         }
1976         if (0 != __vc_check_privilege()) {
1977                 return VC_ERROR_PERMISSION_DENIED;
1978         }
1979
1980         if (NULL == callback)
1981                 return VC_ERROR_INVALID_PARAMETER;
1982
1983         vc_state_e state;
1984         if (0 != vc_client_get_client_state(g_vc, &state)) {
1985                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1986                 return VC_ERROR_INVALID_STATE;
1987         }
1988
1989         /* check state */
1990         if (state != VC_STATE_INITIALIZED) {
1991                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1992                 return VC_ERROR_INVALID_STATE;
1993         }
1994
1995         vc_client_set_error_cb(g_vc, callback,  user_data);
1996
1997         return 0;
1998 }
1999
2000 int vc_unset_error_cb(void)
2001 {
2002         if (0 != __vc_get_feature_enabled()) {
2003                 return VC_ERROR_NOT_SUPPORTED;
2004         }
2005         if (0 != __vc_check_privilege()) {
2006                 return VC_ERROR_PERMISSION_DENIED;
2007         }
2008
2009         vc_state_e state;
2010         if (0 != vc_client_get_client_state(g_vc, &state)) {
2011                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2012                 return VC_ERROR_INVALID_STATE;
2013         }
2014
2015         /* check state */
2016         if (state != VC_STATE_INITIALIZED) {
2017                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2018                 return VC_ERROR_INVALID_STATE;
2019         }
2020
2021         vc_client_set_error_cb(g_vc, NULL, NULL);
2022
2023         return 0;
2024 }
2025
2026 int vc_set_invocation_name(const char* name)
2027 {
2028         if (0 != __vc_get_feature_enabled()) {
2029                 return VC_ERROR_NOT_SUPPORTED;
2030         }
2031         if (0 != __vc_check_privilege()) {
2032                 return VC_ERROR_PERMISSION_DENIED;
2033         }
2034
2035         vc_state_e state;
2036         SLOG(LOG_DEBUG, TAG_VCC, "===== Set invocation name");
2037
2038         int ret = vc_client_get_client_state(g_vc, &state);
2039         if (0 != ret) {
2040                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2041                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2042                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2043                 return ret;
2044         }
2045
2046         /* check state */
2047         if (state != VC_STATE_READY) {
2048                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2049                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2050                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2051                 return VC_ERROR_INVALID_STATE;
2052         }
2053
2054         ret = vc_client_set_invocation_name(g_vc, name);
2055         if (0 != ret) {
2056                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2057         }
2058         return ret;
2059 }
2060
2061 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2062 {
2063         vc_state_e state;
2064
2065         SLOG(LOG_DEBUG, TAG_VCC, "===== Request dialog");
2066         if (0 != __vc_get_feature_enabled()) {
2067                 return VC_ERROR_NOT_SUPPORTED;
2068         }
2069         if (0 != __vc_check_privilege()) {
2070                 return VC_ERROR_PERMISSION_DENIED;
2071         }
2072
2073         if (0 != vc_client_get_client_state(g_vc, &state)) {
2074                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2075                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2076                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2077                 return VC_ERROR_INVALID_STATE;
2078         }
2079
2080         /* check state */
2081         if (state != VC_STATE_READY) {
2082                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2083                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2084                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2085                 return VC_ERROR_INVALID_STATE;
2086         }
2087
2088         /* Check service state */
2089         vc_service_state_e service_state = -1;
2090         vc_client_get_service_state(g_vc, &service_state);
2091         if (service_state != VC_SERVICE_STATE_READY) {
2092                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2093                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2094                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2095                 return VC_ERROR_INVALID_STATE;
2096         }
2097
2098         SLOG(LOG_DEBUG, TAG_VCC, "Request dialog : pid(%d) disp_text(%s), utt_text(%s), auto_start(%d)", getpid(), disp_text, utt_text, auto_start);
2099         int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2100         if (0 != ret) {
2101                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2102                 return VC_ERROR_OPERATION_FAILED;
2103         }
2104
2105         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2106         SLOG(LOG_DEBUG, TAG_VCC, " ");
2107
2108         return VC_ERROR_NONE;
2109 }
2110
2111 /* Authority */
2112 int vc_auth_enable(void)
2113 {
2114         /* check state */
2115         vc_state_e state;
2116         if (0 != vc_client_get_client_state(g_vc, &state)) {
2117                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2118                 return VC_ERROR_INVALID_STATE;
2119         }
2120
2121         if (VC_STATE_READY != state) {
2122                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2123                 return VC_ERROR_INVALID_STATE;
2124         }
2125
2126         /* check already authority */
2127         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2128         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2129                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2130                 return VC_ERROR_INVALID_STATE;
2131         }
2132
2133         if (VC_AUTH_STATE_NONE != auth_state) {
2134                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2135                 return VC_ERROR_INVALID_STATE;
2136         }
2137
2138         /* request authority */
2139         int mgr_pid = -1;
2140         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2141                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2142                 return VC_ERROR_OPERATION_FAILED;
2143         }
2144
2145         if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2146                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2147                 return VC_ERROR_OPERATION_FAILED;
2148         }
2149
2150         /* set authority into handle */
2151         bool is_foreground = false;
2152         if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2153                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2154                 return VC_ERROR_OPERATION_FAILED;
2155         }
2156
2157         if (is_foreground) {
2158                 auth_state = VC_AUTH_STATE_VALID;
2159         } else {
2160                 auth_state = VC_AUTH_STATE_INVALID;
2161         }
2162
2163         if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2164                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2165                 return VC_ERROR_OPERATION_FAILED;
2166         }
2167
2168         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2169
2170         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2171
2172         return VC_ERROR_NONE;
2173 }
2174
2175 int vc_auth_disable(void)
2176 {
2177         /* check state */
2178         vc_state_e state;
2179         if (0 != vc_client_get_client_state(g_vc, &state)) {
2180                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2181                 return VC_ERROR_INVALID_STATE;
2182         }
2183
2184         if (VC_STATE_READY != state) {
2185                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2186                 return VC_ERROR_INVALID_STATE;
2187         }
2188
2189         /* check autority */
2190         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2191         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2192                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2193                 return VC_ERROR_INVALID_STATE;
2194         }
2195
2196         if (VC_AUTH_STATE_NONE == auth_state) {
2197                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2198                 return VC_ERROR_INVALID_STATE;
2199         }
2200
2201         if (0 != vc_auth_unset_state_changed_cb()) {
2202                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2203         }
2204
2205         /* request return authority by dbus */
2206         int mgr_pid = -1;
2207         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2208                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2209                 return VC_ERROR_OPERATION_FAILED;
2210         }
2211
2212         if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2213                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2214                 return VC_ERROR_OPERATION_FAILED;
2215         }
2216
2217         /* unset authority from handle */
2218         if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2219                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2220                 return VC_ERROR_OPERATION_FAILED;
2221         }
2222
2223         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2224
2225         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2226
2227         return VC_ERROR_NONE;
2228 }
2229
2230 int vc_auth_get_state(vc_auth_state_e* state)
2231 {
2232         /* check state */
2233         vc_state_e vc_state;
2234         if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2235                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2236                 return VC_ERROR_INVALID_STATE;
2237         }
2238
2239         if (VC_STATE_READY != vc_state) {
2240                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2241                 return VC_ERROR_INVALID_STATE;
2242         }
2243
2244         /* get autority */
2245         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2246         if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2247                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2248                 return VC_ERROR_INVALID_STATE;
2249         }
2250
2251         *state = temp;
2252
2253         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2254
2255         return VC_ERROR_NONE;
2256 }
2257
2258 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2259 {
2260         /* check parameter */
2261         if (NULL == callback) {
2262                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2263                 return VC_ERROR_INVALID_PARAMETER;
2264         }
2265
2266         /* check auth */
2267         vc_auth_state_e auth_state;
2268         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2269                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2270                 return VC_ERROR_INVALID_STATE;
2271         }
2272
2273         if (VC_AUTH_STATE_NONE == auth_state) {
2274                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2275                 return VC_ERROR_INVALID_STATE;
2276         }
2277
2278         /* set cb into handle */
2279         if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2280                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2281                 return VC_ERROR_OPERATION_FAILED;
2282         }
2283
2284         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
2285
2286         return VC_ERROR_NONE;
2287 }
2288
2289 int vc_auth_unset_state_changed_cb(void)
2290 {
2291         /* check auth */
2292         vc_auth_state_e auth_state;
2293         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2294                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2295                 return VC_ERROR_INVALID_STATE;
2296         }
2297
2298         if (VC_AUTH_STATE_NONE == auth_state) {
2299                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2300                 return VC_ERROR_INVALID_STATE;
2301         }
2302
2303         /* unset cb from handle */
2304         if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2305                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2306                 return VC_ERROR_OPERATION_FAILED;
2307         }
2308
2309         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2310
2311         return VC_ERROR_NONE;
2312 }
2313
2314 int vc_auth_start(void)
2315 {
2316         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
2317
2318         vc_state_e state;
2319         if (0 != vc_client_get_client_state(g_vc, &state)) {
2320                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2321                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2322                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2323                 return VC_ERROR_INVALID_STATE;
2324         }
2325
2326         /* check state */
2327         if (state != VC_STATE_READY) {
2328                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2329                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2330                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2331                 return VC_ERROR_INVALID_STATE;
2332         }
2333
2334         /* Check service state */
2335         vc_service_state_e service_state = -1;
2336         vc_client_get_service_state(g_vc, &service_state);
2337         if (service_state != VC_SERVICE_STATE_READY) {
2338                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2339                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2340                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2341                 return VC_ERROR_INVALID_STATE;
2342         }
2343
2344         /* Check authority */
2345         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2346         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2347                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2348                 return VC_ERROR_OPERATION_FAILED;
2349         }
2350
2351         if (VC_AUTH_STATE_VALID != auth_state) {
2352                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2353                 return VC_ERROR_OPERATION_FAILED;
2354         }
2355
2356         /* get mgr_pid */
2357         int mgr_pid = -1;
2358         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2359                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2360                 return VC_ERROR_OPERATION_FAILED;
2361         }
2362
2363         int ret;
2364         int count = 0;
2365         /* Request */
2366         ret = -1;
2367         count = 0;
2368         while (0 != ret) {
2369                 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2370                 if (0 != ret) {
2371                         if (VC_ERROR_TIMED_OUT != ret) {
2372                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2373                                 break;
2374                         } else {
2375                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2376                                 usleep(10000);
2377                                 count++;
2378                                 if (VC_RETRY_COUNT == count) {
2379                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2380                                         break;
2381                                 }
2382                         }
2383                 } else {
2384                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2385                 }
2386         }
2387
2388         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2389         SLOG(LOG_DEBUG, TAG_VCC, " ");
2390
2391         return ret;
2392 }
2393
2394 int vc_auth_stop(void)
2395 {
2396         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
2397
2398         vc_state_e state;
2399         if (0 != vc_client_get_client_state(g_vc, &state)) {
2400                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2401                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2402                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2403                 return VC_ERROR_INVALID_STATE;
2404         }
2405
2406         /* check state */
2407         if (state != VC_STATE_READY) {
2408                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2409                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2410                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2411                 return VC_ERROR_INVALID_STATE;
2412         }
2413
2414         /* Check service state */
2415         vc_service_state_e service_state = -1;
2416         vc_client_get_service_state(g_vc, &service_state);
2417         if (service_state != VC_SERVICE_STATE_RECORDING) {
2418                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2419                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2420                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2421                 return VC_ERROR_INVALID_STATE;
2422         }
2423
2424         /* Check authority */
2425         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2426         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2427                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2428                 return VC_ERROR_OPERATION_FAILED;
2429         }
2430
2431         if (VC_AUTH_STATE_VALID != auth_state) {
2432                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2433                 return VC_ERROR_OPERATION_FAILED;
2434         }
2435
2436         /* get mgr_pid */
2437         int mgr_pid = -1;
2438         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2439                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2440                 return VC_ERROR_OPERATION_FAILED;
2441         }
2442
2443         int ret = -1;
2444         int count = 0;
2445         /* do request */
2446         while (0 != ret) {
2447                 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2448                 if (0 != ret) {
2449                         if (VC_ERROR_TIMED_OUT != ret) {
2450                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2451                                 break;
2452                         } else {
2453                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2454                                 usleep(10000);
2455                                 count++;
2456                                 if (VC_RETRY_COUNT == count) {
2457                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2458                                         break;
2459                                 }
2460                         }
2461                 } else {
2462                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2463                 }
2464         }
2465
2466         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2467         SLOG(LOG_DEBUG, TAG_VCC, " ");
2468
2469         return ret;
2470 }
2471
2472 int vc_auth_cancel(void)
2473 {
2474         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2475
2476         vc_state_e state;
2477         if (0 != vc_client_get_client_state(g_vc, &state)) {
2478                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2479                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2480                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2481                 return VC_ERROR_INVALID_STATE;
2482         }
2483
2484         /* check state */
2485         if (state != VC_STATE_READY) {
2486                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2487                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2488                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2489                 return VC_ERROR_INVALID_STATE;
2490         }
2491
2492         /* Check service state */
2493         vc_service_state_e service_state = -1;
2494         vc_client_get_service_state(g_vc, &service_state);
2495         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2496                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2497                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2498                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2499                 return VC_ERROR_INVALID_STATE;
2500         }
2501
2502         /* Check authority */
2503         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2504         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2505                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2506                 return VC_ERROR_OPERATION_FAILED;
2507         }
2508
2509         if (VC_AUTH_STATE_VALID != auth_state) {
2510                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2511                 return VC_ERROR_OPERATION_FAILED;
2512         }
2513
2514         /* get mgr_pid */
2515         int mgr_pid = -1;
2516         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2517                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2518                 return VC_ERROR_OPERATION_FAILED;
2519         }
2520
2521         int ret = -1;
2522         int count = 0;
2523         while (0 != ret) {
2524                 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2525                 if (0 != ret) {
2526                         if (VC_ERROR_TIMED_OUT != ret) {
2527                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2528                                 break;
2529                         } else {
2530                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2531                                 usleep(10000);
2532                                 count++;
2533                                 if (VC_RETRY_COUNT == count) {
2534                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2535                                         break;
2536                                 }
2537                         }
2538                 } else {
2539                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2540                 }
2541         }
2542
2543         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2544         SLOG(LOG_DEBUG, TAG_VCC, " ");
2545
2546         return ret;
2547 }