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