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_Wl2.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_data.h"
  33 #include "vc_tidl.h"
  34 #include "vc_info_parser.h"
  35 #include "vc_json_parser.h"
  36 #include "vc_main.h"
  37 #include "voice_control.h"
  38 #include "voice_control_internal.h"
  39 #include "voice_control_authority.h"
  40 #include "voice_control_command.h"
  41 #include "voice_control_command_expand.h"
  42
  43
  44 static Ecore_Event_Handler* g_focus_in_handler = NULL;
  45 static Ecore_Event_Handler* g_focus_out_handler = NULL;
  46
  47 static Ecore_Thread* g_tts_thread = NULL;
  48 static Ecore_Thread* g_prepare_thread = NULL;
  49 static pthread_mutex_t g_prepare_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
  50
  51 static int g_pid;
  52
  53 static int g_daemon_pid = 0;
  54
  55 static int g_feature_enabled = -1;
  56 static bool g_privilege_allowed = false;
  57 static bool g_vc_tts_privilege_allowed = false;
  58 static bool g_backup = false;
  59
  60 static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER;
  61 static cynara *p_cynara = NULL;
  62
  63 static void __vc_notify_state_changed(void *data);
  64 static void __vc_notify_error(void *data);
  65
  66 static int __vc_get_feature_enabled()
  67 {
  68         if (0 == g_feature_enabled) {
  69                 //LCOV_EXCL_START
  70                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  71                 return VC_ERROR_NOT_SUPPORTED;
  72                 //LCOV_EXCL_STOP
  73         } else if (-1 == g_feature_enabled) {
  74                 bool vc_supported = false;
  75                 bool mic_supported = false;
  76                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  77                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  78                                 if (false == vc_supported || false == mic_supported) {
  79                                         //LCOV_EXCL_START
  80                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  81                                         g_feature_enabled = 0;
  82                                         return VC_ERROR_NOT_SUPPORTED;
  83                                         //LCOV_EXCL_STOP
  84                                 }
  85
  86                                 g_feature_enabled = 1;
  87                         } else {
  88                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
  89                                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
  90                         }
  91                 } else {
  92                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
  93                         return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
  94                 }
  95         }
  96
  97         return VC_ERROR_NONE;
  98 }
  99
 100 static int __check_privilege_initialize()
 101 {
 102         int ret = cynara_initialize(&p_cynara, NULL);
 103         if (CYNARA_API_SUCCESS != ret)
 104                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize"); //LCOV_EXCL_LINE
 105
 106         return ret == CYNARA_API_SUCCESS;
 107 }
 108
 109 static int __check_privilege(const char* uid, const char * privilege)
 110 {
 111         FILE *fp = NULL;
 112         char label_path[1024] = "/proc/self/attr/current";
 113         char smack_label[1024] = {'\0',};
 114
 115         if (!p_cynara) {
 116                 return false;   //LCOV_EXCL_LINE
 117         }
 118
 119         fp = fopen(label_path, "r");
 120         if (fp != NULL) {
 121                 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
 122                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread"); //LCOV_EXCL_LINE
 123
 124                 fclose(fp);
 125         }
 126
 127         pid_t pid = getpid();
 128         char *session = cynara_session_from_pid(pid);
 129         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 130         SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
 131         FREE(session);
 132
 133         if (ret != CYNARA_API_ACCESS_ALLOWED)
 134                 return false;   //LCOV_EXCL_LINE
 135         return true;
 136 }
 137
 138 static void __check_privilege_deinitialize()
 139 {
 140         if (p_cynara)
 141         {
 142                 int ret = cynara_finish(p_cynara);
 143                 if (ret != CYNARA_API_SUCCESS)
 144                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cynara finish %d", ret);      //LCOV_EXCL_LINE
 145         }
 146         p_cynara = NULL;
 147 }
 148
 149 static int __vc_check_privilege()
 150 {
 151         if (true == g_privilege_allowed)
 152                 return VC_ERROR_NONE;
 153
 154         pthread_mutex_lock(&g_cynara_mutex);
 155
 156         if (false == g_privilege_allowed) {
 157                 bool ret = true;
 158                 ret = __check_privilege_initialize();
 159                 if (false == ret) {
 160                         //LCOV_EXCL_START
 161                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
 162                         pthread_mutex_unlock(&g_cynara_mutex);
 163                         return VC_ERROR_PERMISSION_DENIED;
 164                         //LCOV_EXCL_STOP
 165                 }
 166
 167                 char uid[32];
 168                 snprintf(uid, 32, "%d", getuid());
 169                 ret = true;
 170                 ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
 171                 if (false == ret) {
 172                         //LCOV_EXCL_START
 173                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
 174                         __check_privilege_deinitialize();
 175                         g_privilege_allowed = false;
 176                         pthread_mutex_unlock(&g_cynara_mutex);
 177                         return VC_ERROR_PERMISSION_DENIED;
 178                         //LCOV_EXCL_STOP
 179                 }
 180
 181                 __check_privilege_deinitialize();
 182         }
 183
 184         g_privilege_allowed = true;
 185         pthread_mutex_unlock(&g_cynara_mutex);
 186         return VC_ERROR_NONE;
 187 }
 188
 189 int __check_feature_privilege()
 190 {
 191         if (0 != __vc_get_feature_enabled()) {
 192                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
 193         }
 194         if (0 != __vc_check_privilege()) {
 195                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
 196         }
 197
 198         return VC_ERROR_NONE;
 199 }
 200
 201 int __vc_tts_check_privilege()
 202 {
 203         if (true == g_vc_tts_privilege_allowed)
 204                 return VC_ERROR_NONE;
 205
 206         pthread_mutex_lock(&g_cynara_mutex);
 207
 208         if (false == g_vc_tts_privilege_allowed) {
 209                 bool ret = true;
 210                 ret = __check_privilege_initialize();
 211                 if (false == ret) {
 212                         //LCOV_EXCL_START
 213                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
 214                         pthread_mutex_unlock(&g_cynara_mutex);
 215                         return VC_ERROR_PERMISSION_DENIED;
 216                         //LCOV_EXCL_STOP
 217                 }
 218
 219                 char uid[32];
 220                 snprintf(uid, 32, "%d", getuid());
 221                 ret = true;
 222                 ret = __check_privilege(uid, VC_TTS_PRIVILEGE);
 223                 if (false == ret) {
 224                         //LCOV_EXCL_START
 225                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied(%s)(%s)", VC_TTS_PRIVILEGE, uid);
 226                         __check_privilege_deinitialize();
 227                         g_vc_tts_privilege_allowed = false;
 228                         pthread_mutex_unlock(&g_cynara_mutex);
 229                         return VC_ERROR_PERMISSION_DENIED;
 230                         //LCOV_EXCL_STOP
 231                 }
 232
 233                 __check_privilege_deinitialize();
 234         }
 235
 236         g_vc_tts_privilege_allowed = true;
 237         pthread_mutex_unlock(&g_cynara_mutex);
 238         return VC_ERROR_NONE;
 239 }
 240
 241 //LCOV_EXCL_START
 242 static const char* __vc_get_error_code(vc_error_e err)
 243 {
 244         switch (err) {
 245         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
 246         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
 247         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
 248         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
 249         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
 250         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
 251         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
 252         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
 253         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
 254         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
 255         default:                                return "Invalid error code";
 256         }
 257         return NULL;
 258 }
 259
 260 static int __vc_convert_config_error_code(vc_config_error_e code)
 261 {
 262         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
 263         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
 264         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
 265         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
 266         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
 267         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
 268         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
 269         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
 270
 271         return VC_ERROR_NONE;
 272 }
 273
 274 static void __vc_lang_changed_cb(const char* previous_lang, const char* current_lang)
 275 {
 276         SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : previous lang(%s) Current lang(%s)",
 277                  previous_lang, current_lang);
 278
 279         vc_current_language_changed_cb callback;
 280         void* lang_user_data;
 281         vc_client_get_current_lang_changed_cb(&callback, &lang_user_data);
 282
 283         if (NULL != callback) {
 284                 vc_client_use_callback();
 285                 callback(previous_lang, current_lang, lang_user_data);
 286                 vc_client_not_use_callback();
 287                 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
 288         } else {
 289                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
 290         }
 291
 292         return;
 293 }
 294
 295 static Eina_Bool __notify_auth_changed_cb(void *data)
 296 {
 297         vc_auth_state_changed_cb callback = NULL;
 298         void* user_data;
 299
 300         vc_client_get_auth_state_changed_cb(&callback, &user_data);
 301
 302         vc_auth_state_e previous = -1;
 303         vc_auth_state_e current = -1;
 304
 305         vc_client_get_previous_auth_state(&previous, &current);
 306
 307         if (NULL != callback) {
 308                 vc_client_use_callback();
 309                 callback(previous, current, user_data);
 310                 vc_client_not_use_callback();
 311                 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
 312         } else {
 313                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
 314         }
 315
 316         return EINA_FALSE;
 317 }
 318
 319 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
 320 {
 321         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
 322
 323         int ret;
 324         if (ECORE_WL2_EVENT_FOCUS_IN == type) {
 325                 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
 326                 ret = vc_tidl_request_set_foreground(getpid(), true);
 327                 if (0 != ret) {
 328                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
 329                 }
 330
 331                 ret = vc_client_set_is_foreground(true);
 332                 if (0 != ret) {
 333                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
 334                 }
 335
 336                 /* set authority valid */
 337                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 338                 if (0 != vc_client_get_auth_state(&state)) {
 339                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 340                 }
 341                 if (VC_AUTH_STATE_INVALID == state) {
 342                         vc_client_set_auth_state(VC_AUTH_STATE_VALID);
 343
 344                         /* notify auth changed cb */
 345                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 346                 }
 347         } else if (ECORE_WL2_EVENT_FOCUS_OUT == type) {
 348                 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
 349                 ret = vc_tidl_request_set_foreground(getpid(), false);
 350                 if (0 != ret) {
 351                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
 352                 }
 353
 354                 ret = vc_client_set_is_foreground(false);
 355                 if (0 != ret) {
 356                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
 357                 }
 358
 359                 /* set authority valid */
 360                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 361                 if (0 != vc_client_get_auth_state(&state)) {
 362                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 363                 }
 364                 if (VC_AUTH_STATE_VALID == state) {
 365                         vc_client_set_auth_state(VC_AUTH_STATE_INVALID);
 366
 367                         /* notify authority changed cb */
 368                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 369                 }
 370         } else {
 371                 SLOG(LOG_DEBUG, TAG_VCC, "@@@ type(%d) is NOT valid", type);
 372         }
 373
 374         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed DONE");
 375
 376         return ECORE_CALLBACK_RENEW;
 377 }
 378 //LCOV_EXCL_STOP
 379
 380 int vc_initialize(void)
 381 {
 382         int ret;
 383         ret = __check_feature_privilege();
 384         if (VC_ERROR_NONE != ret)
 385                 return ret;
 386
 387         SLOG(LOG_INFO, TAG_VCC, "@@@ [Client] Initialize");
 388
 389         /* check handle */
 390         if (true == vc_client_is_valid()) {
 391                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
 392                 return VC_ERROR_NONE; //LCOV_EXCL_LINE
 393         }
 394
 395         if (0 != vc_tidl_open_connection()) {
 396                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection"); //LCOV_EXCL_LINE
 397                 return VC_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 398         }
 399
 400         if (0 != vc_client_create()) {
 401                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!"); //LCOV_EXCL_LINE
 402                 return VC_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 403         }
 404
 405         g_pid = getpid();
 406         ret = vc_config_mgr_initialize(g_pid);
 407         if (0 != ret) {
 408                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
 409                 __vc_get_error_code(__vc_convert_config_error_code(ret))); //LCOV_EXCL_LINE
 410                 vc_client_destroy(); //LCOV_EXCL_LINE
 411                 return __vc_convert_config_error_code(ret); //LCOV_EXCL_LINE
 412         }
 413
 414         ret = vc_config_mgr_set_lang_cb(g_pid, __vc_lang_changed_cb);
 415         if (0 != ret) {
 416                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret); //LCOV_EXCL_LINE
 417                 vc_config_mgr_finalize(g_pid); //LCOV_EXCL_LINE
 418                 vc_client_destroy(); //LCOV_EXCL_LINE
 419                 return __vc_convert_config_error_code(ret);
 420         }
 421
 422         SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_pid);
 423
 424
 425         return VC_ERROR_NONE;
 426 }
 427
 428 static void __vc_internal_unprepare(void)
 429 {
 430         /* return authority */
 431         vc_auth_state_e state = VC_AUTH_STATE_NONE;
 432         if (0 != vc_client_get_auth_state(&state)) {
 433                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
 434         }
 435
 436         if (VC_AUTH_STATE_NONE != state) {
 437                 if (0 != vc_auth_disable()) {
 438                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable"); //LCOV_EXCL_LINE
 439                 }
 440         }
 441
 442         int ret = vc_tidl_request_finalize(g_pid);
 443         if (0 != ret) {
 444                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
 445         }
 446
 447         /* TODO set_start_listening should be move to proper place */
 448         vc_client_set_start_listening(false);
 449
 450         if (NULL != g_focus_in_handler) {
 451                 ecore_event_handler_del(g_focus_in_handler);
 452                 g_focus_in_handler = NULL;
 453         }
 454         if (NULL != g_focus_out_handler) {
 455                 ecore_event_handler_del(g_focus_out_handler);
 456                 g_focus_out_handler = NULL;
 457         }
 458
 459         ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 460         if (0 != ret)
 461                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
 462
 463         return;
 464 }
 465
 466 int vc_deinitialize(void)
 467 {
 468         int ret = VC_ERROR_NONE;
 469         ret = __check_feature_privilege();
 470         if (VC_ERROR_NONE != ret)
 471                 return ret;
 472
 473         SLOG(LOG_INFO, TAG_VCC, "@@@ [Client] Deinitialize");
 474
 475         if (false == vc_client_is_valid()) {
 476                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
 477                 return VC_ERROR_INVALID_STATE;
 478         }
 479
 480         vc_state_e state;
 481         vc_client_get_client_state(&state);
 482
 483         /* check state */
 484         switch (state) {
 485         case VC_STATE_READY:
 486                 __vc_internal_unprepare();
 487                 /* no break. need to next step*/
 488         case VC_STATE_INITIALIZED:
 489                 pthread_mutex_lock(&g_prepare_thread_mutex);
 490                 if (NULL != g_prepare_thread) {
 491                         ecore_thread_cancel(g_prepare_thread);
 492                 }
 493                 pthread_mutex_unlock(&g_prepare_thread_mutex);
 494
 495                 vc_config_mgr_unset_lang_cb(g_pid);
 496                 vc_config_mgr_finalize(g_pid);
 497
 498                 /* Free client resources */
 499                 vc_client_destroy();
 500                 g_pid = 0;
 501                 break;
 502         case VC_STATE_NONE:
 503                 break;
 504         }
 505
 506         SLOG(LOG_INFO, TAG_VCC, "Success: destroy");
 507
 508         if (true == g_backup) {
 509                 ret = vc_db_backup_command();
 510                 if (0 != ret) {
 511                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to backup command, ret(%d)", ret); //LCOV_EXCL_LINE
 512                 }
 513         }
 514
 515         ret = vc_db_finalize();
 516         if (0 != ret) {
 517                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret); //LCOV_EXCL_LINE
 518         }
 519
 520         if (0 != vc_tidl_close_connection()) {
 521                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE
 522         }
 523
 524         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize DONE");
 525
 526         return VC_ERROR_NONE;
 527 }
 528
 529 static Eina_Bool __vc_connect_daemon(void *data)
 530 {
 531         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
 532
 533         /* request initialization */
 534         int ret = -1;
 535         int mgr_pid = -1;
 536         int service_state = 0;
 537
 538         /* check handle */
 539         if (true == vc_client_is_valid()) {
 540                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The current client is valid");
 541
 542                 /* Initialize DB */
 543                 ret = vc_db_initialize();
 544                 if (0 != ret) {
 545                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret); //LCOV_EXCL_LINE
 546                         return EINA_TRUE;
 547                 }
 548
 549                 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 550                 if (0 != ret)
 551                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
 552
 553                 ret = vc_tidl_request_initialize(g_pid, &mgr_pid, &service_state, &g_daemon_pid);
 554                 //LCOV_EXCL_START
 555                 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 556                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
 557
 558                         vc_client_set_error(VC_ERROR_ENGINE_NOT_FOUND);
 559                         ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 560
 561                         return EINA_FALSE;
 562                 //LCOV_EXCL_STOP
 563                 } else if (0 != ret) {
 564                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
 565
 566                         vc_client_set_error(VC_ERROR_TIMED_OUT);
 567                         ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 568
 569                         ret = vc_db_finalize();
 570                         if (0 != ret) {
 571                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB : %d", ret); //LCOV_EXCL_LINE
 572                         }
 573
 574                         return EINA_TRUE;
 575                 } else {
 576                         /* Success to connect */
 577                 }
 578
 579                 /* Set service state */
 580                 vc_service_state_e previous_service_state;
 581                 vc_client_get_service_state(&previous_service_state);
 582
 583                 vc_client_set_service_state((vc_service_state_e)service_state);
 584
 585                 vc_service_state_changed_cb service_changed_callback = NULL;
 586                 void* user_data = NULL;
 587                 vc_client_get_service_state_changed_cb(&service_changed_callback, &user_data);
 588
 589                 if (NULL != service_changed_callback) {
 590                         vc_client_use_callback();
 591                         service_changed_callback(previous_service_state, service_state, user_data);
 592                         vc_client_not_use_callback();
 593                         SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called"); //LCOV_EXCL_LINE
 594                 } else {
 595                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null"); //LCOV_EXCL_LINE
 596                 }
 597
 598                 /* Register focus handler */
 599                 ecore_thread_main_loop_begin();
 600                 g_focus_in_handler = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
 601                 g_focus_out_handler = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
 602                 ecore_thread_main_loop_end();
 603
 604                 char appid[1024] = {'\0',};
 605                 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
 606                 if (ret != AUL_R_OK)
 607                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get aul_app_get_appid_bypid : %d", ret);
 608
 609                 int status = aul_app_get_status(appid);
 610                 if (STATUS_FOCUS == status) {
 611                         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); //LCOV_EXCL_LINE
 612                         ret = vc_tidl_request_set_foreground(getpid(), true);
 613                         if (0 != ret) {
 614                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE
 615                         }
 616
 617                         ret = vc_client_set_is_foreground(true);
 618                         if (0 != ret) {
 619                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret); //LCOV_EXCL_LINE
 620                         }
 621
 622                         /* set authority valid */
 623                         vc_auth_state_e state = VC_AUTH_STATE_NONE;
 624                         if (0 != vc_client_get_auth_state(&state)) {
 625                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
 626                         }
 627                         if (VC_AUTH_STATE_INVALID == state) {
 628                                 vc_client_set_auth_state(VC_AUTH_STATE_VALID);
 629
 630                                 /* notify auth changed cb */
 631                                 ecore_idler_add(__notify_auth_changed_cb, NULL);
 632                         }
 633                 }
 634
 635                 vc_client_set_client_state(VC_STATE_READY);
 636                 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
 637
 638                 vc_client_set_mgr_pid(mgr_pid);
 639         } else {
 640                 SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] The current client is not valid. It is destroyed."); //LCOV_EXCL_LINE
 641                 return EINA_FALSE;
 642         }
 643         /* TODO set_start_listening should be move to proper place */
 644         vc_client_set_start_listening(true);
 645
 646         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon DONE");
 647
 648         return EINA_FALSE;
 649 }
 650
 651 static void __start_prepare_thread(void *data, Ecore_Thread *thread)
 652 {
 653         SLOG(LOG_ERROR, TAG_VCC, "@@@ Start prepare thread");
 654         int ret = -1, retry_count = 0;
 655
 656         /* Send hello */
 657         while (0 != ret) {
 658                 pthread_mutex_lock(&g_prepare_thread_mutex);
 659                 if (EINA_TRUE == ecore_thread_check(thread)) {
 660                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 661                         pthread_mutex_unlock(&g_prepare_thread_mutex);
 662                         return;
 663                 }
 664
 665                 if (retry_count == VC_TIDL_RETRY_COUNT) { // 200 ms * 20 = 4 sec
 666                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 667                         pthread_mutex_unlock(&g_prepare_thread_mutex);
 668                         return;
 669                 }
 670
 671                 ret = vc_tidl_request_hello();
 672                 pthread_mutex_unlock(&g_prepare_thread_mutex);
 673                 if (ret == 0) {
 674                         SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
 675                         break;
 676                 } else {
 677                         retry_count++;
 678                         usleep(200000);
 679                 }
 680         }
 681
 682         ret = -1;
 683         retry_count = 0;
 684         while (0 != ret) {
 685                 pthread_mutex_lock(&g_prepare_thread_mutex);
 686                 if (EINA_TRUE == ecore_thread_check(thread)) {
 687                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 688                         pthread_mutex_unlock(&g_prepare_thread_mutex);
 689                         return;
 690                 }
 691
 692                 if (retry_count == 10) {
 693                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!"); //LCOV_EXCL_LINE
 694                         pthread_mutex_unlock(&g_prepare_thread_mutex);
 695                         return;
 696                 }
 697
 698                 ret = __vc_connect_daemon(NULL);
 699                 pthread_mutex_unlock(&g_prepare_thread_mutex);
 700                 if (ret == 0)
 701                         break;
 702                 else
 703                         retry_count++;
 704         }
 705 }
 706
 707 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
 708 {
 709         SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
 710         g_prepare_thread = NULL;
 711 }
 712
 713 static void __cancel_prepare_thread(void *data, Ecore_Thread *thread)
 714 {
 715         SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
 716         g_prepare_thread = NULL;
 717 }
 718
 719 int vc_prepare(void)
 720 {
 721         int ret;
 722         ret = __check_feature_privilege();
 723         if (VC_ERROR_NONE != ret)
 724                 return ret;
 725
 726         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
 727
 728         vc_state_e state;
 729         if (0 != vc_client_get_client_state(&state)) {
 730                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 731                 return VC_ERROR_INVALID_STATE;
 732         }
 733
 734         /* check state */
 735         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 736
 737         g_prepare_thread = ecore_thread_run(__start_prepare_thread, __end_prepare_thread, __cancel_prepare_thread, NULL);
 738
 739         return VC_ERROR_NONE;
 740 }
 741
 742 int vc_prepare_sync(void)
 743 {
 744         int ret;
 745         ret = __check_feature_privilege();
 746         if (VC_ERROR_NONE != ret)
 747                 return ret;
 748
 749         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
 750
 751         vc_state_e state;
 752         if (0 != vc_client_get_client_state(&state)) {
 753                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 754                 return VC_ERROR_INVALID_STATE;
 755         }
 756
 757         /* check state */
 758         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 759
 760         ret = -1;
 761         int cnt = 0;
 762         while (VC_CONNECTION_RETRY_COUNT > cnt) {
 763                 ret= vc_tidl_request_hello_sync();
 764                 if (VC_ERROR_NONE == ret)
 765                         break;
 766                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello_sync and retry, ret(%d)", ret);
 767                 usleep(100000);
 768                 cnt++;
 769         }
 770         if (VC_ERROR_NONE != ret) {
 771                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello_sync, ret(%d)", ret);
 772                 return ret;
 773         }
 774
 775         cnt = 0;
 776         while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
 777                 cnt++;
 778         }
 779
 780         RETVM_IF(VC_CONNECTION_RETRY_COUNT == cnt, VC_ERROR_OPERATION_FAILED, TAG_VCC, "[ERROR] Fail to connect daemon");
 781
 782         return VC_ERROR_NONE;
 783 }
 784
 785 int vc_unprepare(void)
 786 {
 787         int ret;
 788         ret = __check_feature_privilege();
 789         if (VC_ERROR_NONE != ret)
 790                 return ret;
 791
 792         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
 793
 794         vc_state_e state;
 795         if (0 != vc_client_get_client_state(&state)) {
 796                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 797                 return VC_ERROR_INVALID_STATE;
 798         }
 799
 800         /* check state */
 801         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 802
 803         __vc_internal_unprepare();
 804
 805         vc_client_set_client_state(VC_STATE_INITIALIZED);
 806         ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
 807
 808         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare DONE");
 809
 810         return VC_ERROR_NONE;
 811 }
 812
 813 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 814 {
 815         int ret;
 816         ret = __check_feature_privilege();
 817         if (VC_ERROR_NONE != ret)
 818                 return ret;
 819
 820         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 821
 822         vc_state_e state;
 823         if (0 != vc_client_get_client_state(&state)) {
 824                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 825                 return VC_ERROR_INVALID_STATE;
 826         }
 827
 828         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
 829
 830         ret = vc_config_mgr_get_language_list(callback, user_data);
 831         if (0 != ret) {
 832                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 833                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
 834         }
 835
 836         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language DONE");
 837
 838         return VC_ERROR_NONE;
 839 }
 840
 841
 842 int vc_get_current_language(char** language)
 843 {
 844         int ret;
 845         ret = __check_feature_privilege();
 846         if (VC_ERROR_NONE != ret)
 847                 return ret;
 848
 849         RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 850
 851         vc_state_e state;
 852         if (0 != vc_client_get_client_state(&state)) {
 853                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 854                 return VC_ERROR_INVALID_STATE;
 855         }
 856
 857
 858         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
 859
 860         ret = vc_config_mgr_get_default_language(language);
 861         if (0 != ret) {
 862                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 863                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
 864         }
 865
 866         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language DONE");
 867
 868         return ret;
 869 }
 870
 871 int vc_get_state(vc_state_e* state)
 872 {
 873         int ret;
 874         ret = __check_feature_privilege();
 875         if (VC_ERROR_NONE != ret)
 876                 return ret;
 877
 878         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 879
 880         vc_state_e temp;
 881         if (0 != vc_client_get_client_state(&temp)) {
 882                 SLOG(LOG_WARN, TAG_VCC, "[ERROR] handle is not valid");
 883                 temp = VC_STATE_NONE;
 884         }
 885
 886         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
 887         switch (temp) {
 888         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'");            break;
 889         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'");         break;
 890         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'");           break;
 891         default:
 892                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state. Return state as 'None'.");
 893                 temp = VC_STATE_NONE;
 894         }
 895
 896         *state = temp;
 897         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State DONE");
 898
 899         return VC_ERROR_NONE;
 900 }
 901
 902 int vc_get_service_state(vc_service_state_e* state)
 903 {
 904         int ret;
 905         ret = __check_feature_privilege();
 906         if (VC_ERROR_NONE != ret)
 907                 return ret;
 908
 909         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 910
 911         vc_state_e temp;
 912         if (0 != vc_client_get_client_state(&temp)) {
 913                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 914                 return VC_ERROR_INVALID_STATE;
 915         }
 916
 917         RETVM_IF(VC_STATE_READY != temp, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", temp);
 918
 919         /* get service state */
 920         vc_service_state_e service_state;
 921         if (0 != vc_client_get_service_state(&service_state)) {
 922                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state"); //LCOV_EXCL_LINE
 923                 return VC_ERROR_OPERATION_FAILED;
 924         }
 925
 926         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
 927
 928         *state = service_state;
 929
 930         switch (*state) {
 931         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'");            break;
 932         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'");           break;
 933         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'");       break;
 934         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'");      break;
 935         default:                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
 936         }
 937
 938         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State DONE");
 939
 940         return VC_ERROR_NONE;
 941 }
 942
 943 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
 944 {
 945         int ret;
 946         ret = __check_feature_privilege();
 947         if (VC_ERROR_NONE != ret)
 948                 return ret;
 949
 950         RETVM_IF(NULL == vc_sys_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 951         *vc_sys_cmd_list = NULL;
 952
 953         vc_state_e state;
 954         if (0 != vc_client_get_client_state(&state)) {
 955                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 956                 return VC_ERROR_INVALID_STATE;
 957         }
 958
 959         /* check state */
 960         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 961
 962         /* Check service state */
 963         vc_service_state_e service_state = -1;
 964         vc_client_get_service_state(&service_state);
 965         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 966
 967
 968         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
 969
 970         bool is_sys_cmd_valid = false;
 971         int count = 0;
 972         ret = -1;
 973         bool is_prepared = false;
 974         do {
 975                 ret = vc_tidl_request_is_system_command_valid(g_pid, &is_sys_cmd_valid);
 976                 if (0 != ret) {
 977                         //LCOV_EXCL_START
 978                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
 979                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
 980                                 if (0 == vc_prepare_sync()) {
 981                                         is_prepared = true;
 982                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
 983                                 }
 984                         } else if (VC_ERROR_TIMED_OUT != ret) {
 985                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
 986                                 break;
 987                         } else {
 988                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
 989                                 usleep(10000);
 990                                 count++;
 991                                 if (VC_RETRY_COUNT == count) {
 992                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
 993                                         break;
 994                                 }
 995                         }
 996                         //LCOV_EXCL_STOP
 997                 }
 998         } while (0 != ret);
 999
1000         int mgr_pid = -1;
1001         ret = vc_client_get_mgr_pid(&mgr_pid);
1002         if (0 != ret) {
1003                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid"); //LCOV_EXCL_LINE
1004                 return VC_ERROR_OPERATION_FAILED;
1005         }
1006
1007         if (true == is_sys_cmd_valid) {
1008                 vc_cmd_list_s* list = NULL;
1009                 ret = vc_cmd_list_create((vc_cmd_list_h*)&list);
1010                 if (0 != ret) {
1011                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1012                         return ret;
1013                 }
1014
1015                 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
1016                 if (0 != ret) {
1017                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
1018                         vc_cmd_list_destroy((vc_cmd_list_h)list, true);
1019                         return ret;
1020                 }
1021
1022                 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
1023                 if (0 != ret) {
1024                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
1025                         vc_cmd_list_destroy((vc_cmd_list_h)list, true);
1026                         return ret;
1027                 }
1028
1029                 *vc_sys_cmd_list = (vc_cmd_list_h)list;
1030         } else {
1031                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands"); //LCOV_EXCL_LINE
1032                 return VC_ERROR_NONE;
1033         }
1034
1035         SLOG(LOG_DEBUG, TAG_VCC, "@@@  [Client] Get system command list DONE");
1036
1037         return ret;
1038 }
1039
1040 //LCOV_EXCL_START
1041 /**
1042 * @brief Checks whether the command format is supported.
1043 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
1044 *
1045 * @param[in] format The command format
1046 * @param[out] support The result status @c true = supported, @c false = not supported
1047 *
1048 * @return 0 on success, otherwise a negative error value
1049 * @retval #VC_ERROR_NONE Successful
1050 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1051 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
1052 * @retval #VC_ERROR_INVALID_STATE Invalid state
1053 *
1054 * @pre The state should be #VC_STATE_READY.
1055 */
1056 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
1057 {
1058         int ret;
1059         ret = __check_feature_privilege();
1060         if (VC_ERROR_NONE != ret)
1061                 return ret;
1062
1063         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
1064
1065         vc_state_e state;
1066         if (0 != vc_client_get_client_state(&state)) {
1067                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1068                 return VC_ERROR_INVALID_STATE;
1069         }
1070
1071         /* check support */
1072         bool non_fixed_support = false;
1073         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1074                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1075         }
1076
1077         switch (format) {
1078         case VC_CMD_FORMAT_FIXED:               *support = true;                break;
1079         case VC_CMD_FORMAT_FIXED_AND_VFIXED:    *support = true;                break;
1080         case VC_CMD_FORMAT_VFIXED_AND_FIXED:    *support = true;                break;
1081         case VC_CMD_FORMAT_FIXED_AND_NONFIXED:  *support = non_fixed_support;   break;
1082         case VC_CMD_FORMAT_NONFIXED_AND_FIXED:  *support = non_fixed_support;   break;
1083         default:                                *support = false;               break;
1084         }
1085
1086         SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1087
1088         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported DONE");
1089
1090         return VC_ERROR_NONE;
1091 }
1092 //LCOV_EXCL_STOP
1093
1094 static int __vc_get_invocation_name(char** invocation_name)
1095 {
1096         int ret = vc_client_get_invocation_name(invocation_name);
1097         if (0 != ret) {
1098                 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name"); //LCOV_EXCL_LINE
1099                 return ret; //LCOV_EXCL_LINE
1100         }
1101
1102         if (NULL == *invocation_name) {
1103                 char* temp_label = NULL;
1104                 char* appid = NULL;
1105                 char* lang = NULL;
1106
1107                 ret = app_manager_get_app_id(getpid(), &appid);
1108                 if (0 != ret || NULL == appid) {
1109                         //LCOV_EXCL_START
1110                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret); //LCOV_EXCL_LINE
1111                         FREE(appid);
1112                         return VC_ERROR_OPERATION_FAILED;
1113                         //LCOV_EXCL_STOP
1114                 }
1115
1116                 ret = vc_get_current_language(&lang);
1117                 if (0 != ret || NULL == lang) {
1118                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current language, ret(%d)", ret); //LCOV_EXCL_LINE
1119                         FREE(appid);
1120                         FREE(lang);
1121                         return VC_ERROR_OPERATION_FAILED;
1122                 }
1123
1124                 ret = app_info_get_localed_label(appid, lang, &temp_label);
1125                 if (0 != ret || NULL == temp_label) {
1126                         //LCOV_EXCL_START
1127                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang); //LCOV_EXCL_LINE
1128                         FREE(appid);
1129                         FREE(lang);
1130                         FREE(temp_label);
1131                         return VC_ERROR_OPERATION_FAILED;
1132                         //LCOV_EXCL_STOP
1133                 }
1134
1135                 *invocation_name = strdup(temp_label);
1136                 if (NULL == *invocation_name) {
1137                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
1138                         FREE(appid);
1139                         FREE(lang);
1140                         FREE(temp_label);
1141                         return VC_ERROR_OUT_OF_MEMORY;
1142                 }
1143
1144                 FREE(appid);
1145                 FREE(lang);
1146                 FREE(temp_label);
1147         }
1148
1149         SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1150         return VC_ERROR_NONE;
1151 }
1152
1153 void __set_command(vc_cmd_type_e type)
1154 {
1155         int ret = -1;
1156         int count = 0;
1157         bool is_prepared = false;
1158         do {
1159                 ret = vc_tidl_request_set_command(g_pid, type);
1160                 if (0 != ret) {
1161                         //LCOV_EXCL_START
1162                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1163                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
1164                                 if (0 == vc_prepare_sync()) {
1165                                         is_prepared = true;
1166                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1167                                 }
1168                         } else if (VC_ERROR_TIMED_OUT != ret) {
1169                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1170                                 break;
1171                         } else {
1172                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1173                                 usleep(10000);
1174                                 count++;
1175                                 if (VC_RETRY_COUNT == count) {
1176                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1177                                         break;
1178                                 }
1179                         }
1180                         //LCOV_EXCL_STOP
1181                 }
1182         } while (0 != ret);
1183
1184         return;
1185 }
1186
1187 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1188 {
1189         int ret;
1190         ret = __check_feature_privilege();
1191         if (VC_ERROR_NONE != ret)
1192                 return ret;
1193
1194         RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
1195
1196         vc_state_e state;
1197         if (0 != vc_client_get_client_state(&state)) {
1198                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1199                 return VC_ERROR_INVALID_STATE;
1200         }
1201
1202         /* check state */
1203         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1204
1205
1206         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1207
1208         /* check type */
1209         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1210                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type); //LCOV_EXCL_LINE
1211                 return VC_ERROR_INVALID_PARAMETER;
1212         }
1213
1214         vc_cmd_list_s* list = NULL;
1215         list = (vc_cmd_list_s*)vc_cmd_list;
1216         RETVM_IF(NULL == list->list, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Invalid command list");
1217
1218         ret = 0;
1219         char* invocation_name = NULL;
1220         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1221                 ret = __vc_get_invocation_name(&invocation_name);
1222                 if (0 != ret || NULL == invocation_name) {
1223                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret); //LCOV_EXCL_LINE
1224                         return ret;
1225                 }
1226         }
1227
1228         ret = vc_cmd_parser_delete_file(getpid(), type);
1229         if (0 != ret)
1230                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1231
1232         ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1233         if (0 != ret) {
1234                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1235         } else {
1236                 __set_command((vc_cmd_type_e)type);
1237         }
1238
1239         FREE(invocation_name);
1240
1241         if (VC_COMMAND_TYPE_BACKGROUND == type)
1242                 g_backup = true;
1243
1244         SLOG(LOG_DEBUG, TAG_VCC, "@@@  [Client] Set Command list DONE");
1245
1246         return ret;
1247 }
1248
1249 int vc_unset_command_list(int type)
1250 {
1251         int ret;
1252         ret = __check_feature_privilege();
1253         if (VC_ERROR_NONE != ret)
1254                 return ret;
1255
1256         /* check type */
1257         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1258                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1259                 return VC_ERROR_INVALID_PARAMETER;
1260         }
1261
1262         vc_state_e state;
1263         if (0 != vc_client_get_client_state(&state)) {
1264                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1265                 return VC_ERROR_INVALID_STATE;
1266         }
1267
1268         /* check state */
1269         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1270
1271
1272         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1273
1274         int count = 0;
1275         ret = -1;
1276         bool is_prepared = false;
1277         while (0 != ret) {
1278                 ret = vc_tidl_request_unset_command(g_pid, (vc_cmd_type_e)type);
1279                 if (0 != ret) {
1280                         //LCOV_EXCL_START
1281                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1282                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
1283                                 if (0 == vc_prepare_sync()) {
1284                                         is_prepared = true;
1285                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1286                                 }
1287                         } else if (VC_ERROR_TIMED_OUT != ret) {
1288                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1289                                 break;
1290                         } else {
1291                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1292                                 usleep(10000);
1293                                 count++;
1294                                 if (VC_RETRY_COUNT == count) {
1295                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1296                                         break;
1297                                 }
1298                         }
1299                         //LCOV_EXCL_STOP
1300                 }
1301         }
1302
1303         ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1304         if (0 != ret) {
1305                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1306                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret)); //LCOV_EXCL_LINE
1307         }
1308
1309         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list DONE");
1310
1311         return ret;
1312 }
1313
1314 int vc_set_command_list_from_file(const char* file_path, int type)
1315 {
1316         int ret;
1317         ret = __check_feature_privilege();
1318         if (VC_ERROR_NONE != ret)
1319                 return ret;
1320
1321         RETVM_IF(NULL == file_path, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1322         SLOG(LOG_INFO, TAG_VCC, "@@@ File path: %s", file_path);
1323
1324         vc_state_e state;
1325         if (0 != vc_client_get_client_state(&state)) {
1326                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1327                 return VC_ERROR_INVALID_STATE;
1328         }
1329
1330         /* check state */
1331         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1332
1333         /* check type */
1334         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1335                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1336                 return VC_ERROR_INVALID_PARAMETER;
1337         }
1338
1339
1340         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1341
1342         ret = 0;
1343         char* invocation_name = NULL;
1344         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1345                 ret = __vc_get_invocation_name(&invocation_name);
1346                 if (0 != ret || NULL == invocation_name) {
1347                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1348                         return ret;
1349                 }
1350         }
1351
1352         ret = vc_cmd_parser_delete_file(getpid(), type);
1353         if (0 != ret)
1354                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1355
1356         ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1357         if (0 != ret) {
1358                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1359         } else {
1360                 __set_command((vc_cmd_type_e)type);
1361         }
1362
1363         FREE(invocation_name);
1364
1365         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file DONE");
1366         return ret;
1367 }
1368
1369 #if 0
1370 int vc_get_exclusive_command_option(bool* value)
1371 {
1372         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1373
1374         vc_state_e state;
1375         if (0 != vc_client_get_client_state(g_vc, &state)) {
1376                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1377                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1378                 return VC_ERROR_INVALID_STATE;
1379         }
1380
1381         /* check state */
1382         if (state != VC_STATE_READY) {
1383                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1384                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1385                 return VC_ERROR_INVALID_STATE;
1386         }
1387
1388         int ret = vc_client_get_exclusive_cmd(g_vc, value);
1389         if (0 != ret) {
1390                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1391                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1392                 return ret;
1393         }
1394
1395         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1396
1397         return ret;
1398 }
1399
1400 int vc_set_exclusive_command_option(bool value)
1401 {
1402         if (0 != __vc_get_feature_enabled()) {
1403                 return VC_ERROR_NOT_SUPPORTED;
1404         }
1405         if (0 != __vc_check_privilege()) {
1406                 return VC_ERROR_PERMISSION_DENIED;
1407         }
1408
1409         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1410
1411         vc_state_e state;
1412         if (0 != vc_client_get_client_state(g_vc, &state)) {
1413                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1414                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1415                 return VC_ERROR_INVALID_STATE;
1416         }
1417
1418         /* check state */
1419         if (state != VC_STATE_READY) {
1420                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1421                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1422                 return VC_ERROR_INVALID_STATE;
1423         }
1424
1425         int ret = vc_client_set_exclusive_cmd(g_vc, value);
1426         if (0 != ret) {
1427                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1428                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1429                 return ret;
1430         }
1431
1432         int count = 0;
1433         do {
1434                 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1435                 if (0 != ret) {
1436                         if (VC_ERROR_TIMED_OUT != ret) {
1437                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1438                                 break;
1439                         } else {
1440                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1441                                 usleep(10000);
1442                                 count++;
1443                                 if (VC_RETRY_COUNT == count) {
1444                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1445                                         break;
1446                                 }
1447                         }
1448                 }
1449         } while (0 != ret);
1450
1451         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1452
1453         return ret;
1454 }
1455 #endif
1456
1457 #if 0
1458 int vc_request_start(bool stop_by_silence)
1459 {
1460         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1461
1462         vc_state_e state;
1463         if (0 != vc_client_get_client_state(g_vc, &state)) {
1464                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1465                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1466                 return VC_ERROR_INVALID_STATE;
1467         }
1468
1469         /* check state */
1470         if (state != VC_STATE_READY) {
1471                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1472                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1473                 return VC_ERROR_INVALID_STATE;
1474         }
1475
1476         /* Check service state */
1477         vc_service_state_e service_state = -1;
1478         vc_client_get_service_state(g_vc, &service_state);
1479         if (service_state != VC_SERVICE_STATE_READY) {
1480                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1481                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1482                 return VC_ERROR_INVALID_STATE;
1483         }
1484
1485         int ret;
1486         int count = 0;
1487
1488         /* Request */
1489         ret = -1;
1490         count = 0;
1491         while (0 != ret) {
1492                 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1493                 if (0 != ret) {
1494                         if (VC_ERROR_TIMED_OUT != ret) {
1495                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1496                                 break;
1497                         } else {
1498                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1499                                 usleep(10000);
1500                                 count++;
1501                                 if (VC_RETRY_COUNT == count) {
1502                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1503                                         break;
1504                                 }
1505                         }
1506                 } else {
1507                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1508                 }
1509         }
1510
1511         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1512
1513         return ret;
1514 }
1515
1516 int vc_request_stop(void)
1517 {
1518         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1519
1520         vc_state_e state;
1521         if (0 != vc_client_get_client_state(g_vc, &state)) {
1522                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1523                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1524                 return VC_ERROR_INVALID_STATE;
1525         }
1526
1527         /* check state */
1528         if (state != VC_STATE_READY) {
1529                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1530                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1531                 return VC_ERROR_INVALID_STATE;
1532         }
1533
1534         /* Check service state */
1535         vc_service_state_e service_state = -1;
1536         vc_client_get_service_state(g_vc, &service_state);
1537         if (service_state != VC_SERVICE_STATE_RECORDING) {
1538                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1539                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1540                 return VC_ERROR_INVALID_STATE;
1541         }
1542
1543         int ret = -1;
1544         int count = 0;
1545         /* do request */
1546         while (0 != ret) {
1547                 ret = vc_dbus_request_stop(g_vc->handle);
1548                 if (0 != ret) {
1549                         if (VC_ERROR_TIMED_OUT != ret) {
1550                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1551                                 break;
1552                         } else {
1553                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1554                                 usleep(10000);
1555                                 count++;
1556                                 if (VC_RETRY_COUNT == count) {
1557                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1558                                         break;
1559                                 }
1560                         }
1561                 } else {
1562                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1563                 }
1564         }
1565
1566         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1567
1568         return ret;
1569 }
1570
1571 int vc_request_cancel(void)
1572 {
1573         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1574
1575         vc_state_e state;
1576         if (0 != vc_client_get_client_state(g_vc, &state)) {
1577                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1578                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1579                 return VC_ERROR_INVALID_STATE;
1580         }
1581
1582         /* check state */
1583         if (state != VC_STATE_READY) {
1584                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1585                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1586                 return VC_ERROR_INVALID_STATE;
1587         }
1588
1589         /* Check service state */
1590         vc_service_state_e service_state = -1;
1591         vc_client_get_service_state(g_vc, &service_state);
1592         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1593                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1594                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1595                 return VC_ERROR_INVALID_STATE;
1596         }
1597
1598         int ret = -1;
1599         int count = 0;
1600         while (0 != ret) {
1601                 ret = vc_dbus_request_cancel(g_vc->handle);
1602                 if (0 != ret) {
1603                         if (VC_ERROR_TIMED_OUT != ret) {
1604                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1605                                 break;
1606                         } else {
1607                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1608                                 usleep(10000);
1609                                 count++;
1610                                 if (VC_RETRY_COUNT == count) {
1611                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1612                                         break;
1613                                 }
1614                         }
1615                 } else {
1616                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1617                 }
1618         }
1619
1620         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1621
1622         return ret;
1623 }
1624 #endif
1625
1626 static void __vc_notify_error(void *data)
1627 {
1628         vc_error_cb callback = NULL;
1629         void* user_data;
1630         int reason;
1631
1632         vc_client_get_error_cb(&callback, &user_data);
1633         vc_client_get_error(&reason);
1634
1635         if (NULL != callback) {
1636                 vc_client_use_callback();
1637                 callback(reason, user_data);
1638                 vc_client_not_use_callback();
1639                 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1640         } else {
1641                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1642         }
1643 }
1644
1645 int __vc_cb_error(int reason, const char* msg)
1646 {
1647         if (VC_ERROR_SERVICE_RESET == reason) {
1648                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1649
1650                 vc_client_set_client_state(VC_STATE_INITIALIZED);
1651                 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
1652
1653                 if (0 != vc_prepare()) {
1654                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1655                 }
1656         }
1657
1658         SLOG(LOG_ERROR, TAG_VCC, "[INFO] send error reason(%d), msg(%s)", reason, msg);
1659
1660         vc_client_set_error(reason);
1661         ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
1662
1663         return VC_ERROR_NONE;
1664 }
1665
1666 static void __vc_notify_state_changed(void *data)
1667 {
1668         vc_state_changed_cb changed_callback = NULL;
1669         void* user_data;
1670
1671         vc_client_get_state_changed_cb(&changed_callback, &user_data);
1672
1673         vc_state_e current_state;
1674         vc_state_e previous_state;
1675
1676         vc_client_get_previous_state(&current_state, &previous_state);
1677
1678         if (NULL != changed_callback) {
1679                 vc_client_use_callback();
1680                 changed_callback(previous_state, current_state, user_data);
1681                 vc_client_not_use_callback();
1682                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1683         } else {
1684                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1685         }
1686 }
1687
1688 //LCOV_EXCL_START
1689 static Eina_Bool __vc_notify_result(void *data)
1690 {
1691         char* temp_text;
1692         int event;
1693         vc_cmd_list_h vc_cmd_list = NULL;
1694
1695         vc_result_cb callback = NULL;
1696         void* user_data = NULL;
1697
1698         vc_client_get_result_cb(&callback, &user_data);
1699
1700         RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCC, "[ERROR] Client result callback is NULL");
1701
1702         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1703                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1704                 return EINA_FALSE;
1705         }
1706
1707         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1708
1709         SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1710
1711         vc_cmd_print_list(vc_cmd_list);
1712
1713         vc_client_use_callback();
1714         callback(event, vc_cmd_list, temp_text, user_data);
1715         vc_client_not_use_callback();
1716
1717         SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1718
1719         vc_cmd_list_destroy(vc_cmd_list, true);
1720         vc_cmd_list = NULL;
1721
1722         /* Release result */
1723         FREE(temp_text);
1724
1725         return EINA_FALSE;
1726 }
1727
1728 void __vc_cb_result(void)
1729 {
1730         ecore_timer_add(0, __vc_notify_result, NULL);
1731
1732         return;
1733 }
1734 //LCOV_EXCL_STOP
1735
1736 int vc_get_result(vc_result_cb callback, void* user_data)
1737 {
1738         int ret;
1739         ret = __check_feature_privilege();
1740         if (VC_ERROR_NONE != ret)
1741                 return ret;
1742
1743         vc_state_e state;
1744         if (0 != vc_client_get_client_state(&state)) {
1745                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1746                 return VC_ERROR_INVALID_STATE;
1747         }
1748
1749         /* check state */
1750         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1751
1752         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client result callback is NULL");
1753
1754
1755         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1756
1757         char* temp_text = NULL;
1758         int event = 0;
1759         vc_cmd_list_h vc_cmd_list = NULL;
1760
1761         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1762                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1763                 return VC_ERROR_INVALID_PARAMETER;
1764         }
1765
1766         ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1767         if (0 != ret || NULL == temp_text) {
1768                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text); //LCOV_EXCL_LINE
1769                 return ret;
1770         }
1771
1772         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event); //LCOV_EXCL_LINE
1773
1774         vc_cmd_print_list(vc_cmd_list);
1775
1776         vc_client_use_callback();
1777         callback(event, vc_cmd_list, temp_text, user_data);
1778         vc_client_not_use_callback();
1779
1780         vc_cmd_list_destroy(vc_cmd_list, true);
1781         vc_cmd_list = NULL;
1782
1783         /* Release result */
1784         FREE(temp_text);
1785
1786         SLOG(LOG_DEBUG, TAG_VCC, "@@@  [Client] Get result DONE");
1787
1788         return VC_ERROR_NONE;
1789 }
1790
1791 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1792 {
1793         int ret;
1794         ret = __check_feature_privilege();
1795         if (VC_ERROR_NONE != ret)
1796                 return ret;
1797
1798         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client result callback is NULL");
1799
1800         vc_state_e state;
1801         if (0 != vc_client_get_client_state(&state)) {
1802                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1803                 return VC_ERROR_INVALID_STATE;
1804         }
1805
1806         /* check state */
1807         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1808
1809         vc_client_set_result_cb(callback, user_data);
1810
1811         return VC_ERROR_NONE;
1812 }
1813
1814 int vc_unset_result_cb(void)
1815 {
1816         int ret;
1817         ret = __check_feature_privilege();
1818         if (VC_ERROR_NONE != ret)
1819                 return ret;
1820
1821         vc_state_e state;
1822         if (0 != vc_client_get_client_state(&state)) {
1823                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1824                 return VC_ERROR_INVALID_STATE;
1825         }
1826
1827         /* check state */
1828         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1829
1830         vc_client_set_result_cb(NULL, NULL);
1831
1832         return VC_ERROR_NONE;
1833 }
1834
1835 int __vc_cb_service_state(int state)
1836 {
1837         vc_service_state_e current_state = (vc_service_state_e)state;
1838         vc_service_state_e previous_state;
1839         vc_client_get_service_state(&previous_state);
1840
1841         if (current_state == previous_state) {
1842                 return VC_ERROR_NONE;
1843         }
1844
1845         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : previous(%d) current(%d)",
1846                 previous_state, current_state);
1847
1848         /* Save service state */
1849         vc_client_set_service_state(current_state);
1850
1851         vc_service_state_changed_cb callback = NULL;
1852         void* service_user_data;
1853         vc_client_get_service_state_changed_cb(&callback, &service_user_data);
1854
1855         if (NULL != callback) {
1856                 vc_client_use_callback();
1857                 callback((vc_service_state_e)previous_state, (vc_service_state_e)current_state, service_user_data);
1858                 vc_client_not_use_callback();
1859                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1860         } else {
1861                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1862         }
1863
1864         return VC_ERROR_NONE;
1865 }
1866
1867 int __vc_cb_manager_pid(int manager_pid)
1868 {
1869         SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
1870
1871         /* Save service state */
1872         vc_client_set_mgr_pid(manager_pid);
1873
1874         return VC_ERROR_NONE;
1875 }
1876
1877 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1878 {
1879         int ret;
1880         ret = __check_feature_privilege();
1881         if (VC_ERROR_NONE != ret)
1882                 return ret;
1883
1884         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client service state changed callback is NULL");
1885
1886         vc_state_e state;
1887         if (0 != vc_client_get_client_state(&state)) {
1888                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1889                 return VC_ERROR_INVALID_STATE;
1890         }
1891
1892         /* check state */
1893         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1894
1895         vc_client_set_service_state_changed_cb(callback, user_data);
1896
1897         return VC_ERROR_NONE;
1898 }
1899
1900 int vc_unset_service_state_changed_cb(void)
1901 {
1902         int ret;
1903         ret = __check_feature_privilege();
1904         if (VC_ERROR_NONE != ret)
1905                 return ret;
1906
1907         vc_state_e state;
1908         if (0 != vc_client_get_client_state(&state)) {
1909                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1910                 return VC_ERROR_INVALID_STATE;
1911         }
1912
1913         /* check state */
1914         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1915
1916         vc_client_set_service_state_changed_cb(NULL, NULL);
1917
1918         return VC_ERROR_NONE;
1919 }
1920
1921 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1922 {
1923         int ret;
1924         ret = __check_feature_privilege();
1925         if (VC_ERROR_NONE != ret)
1926                 return ret;
1927
1928         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client state changed callback is NULL");
1929
1930         vc_state_e state;
1931         if (0 != vc_client_get_client_state(&state)) {
1932                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1933                 return VC_ERROR_INVALID_STATE;
1934         }
1935
1936         /* check state */
1937         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1938
1939         vc_client_set_state_changed_cb(callback, user_data);
1940
1941         return VC_ERROR_NONE;
1942 }
1943
1944 int vc_unset_state_changed_cb(void)
1945 {
1946         int ret;
1947         ret = __check_feature_privilege();
1948         if (VC_ERROR_NONE != ret)
1949                 return ret;
1950
1951         vc_state_e state;
1952         if (0 != vc_client_get_client_state(&state)) {
1953                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1954                 return VC_ERROR_INVALID_STATE;
1955         }
1956
1957         /* check state */
1958         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1959
1960         vc_client_set_state_changed_cb(NULL, NULL);
1961
1962         return VC_ERROR_NONE;
1963 }
1964
1965 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1966 {
1967         int ret;
1968         ret = __check_feature_privilege();
1969         if (VC_ERROR_NONE != ret)
1970                 return ret;
1971
1972         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client current language changed callback is NULL");
1973
1974         vc_state_e state;
1975         if (0 != vc_client_get_client_state(&state)) {
1976                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1977                 return VC_ERROR_INVALID_STATE;
1978         }
1979
1980         /* check state */
1981         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1982
1983         vc_client_set_current_lang_changed_cb(callback, user_data);
1984
1985         return VC_ERROR_NONE;
1986 }
1987
1988 int vc_unset_current_language_changed_cb(void)
1989 {
1990         int ret;
1991         ret = __check_feature_privilege();
1992         if (VC_ERROR_NONE != ret)
1993                 return ret;
1994
1995         vc_state_e state;
1996         if (0 != vc_client_get_client_state(&state)) {
1997                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1998                 return VC_ERROR_INVALID_STATE;
1999         }
2000
2001         /* check state */
2002         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2003
2004         vc_client_set_current_lang_changed_cb(NULL, NULL);
2005
2006         return VC_ERROR_NONE;
2007 }
2008
2009 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2010 {
2011         int ret;
2012         ret = __check_feature_privilege();
2013         if (VC_ERROR_NONE != ret)
2014                 return ret;
2015
2016         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client error callback is NULL");
2017
2018         vc_state_e state;
2019         if (0 != vc_client_get_client_state(&state)) {
2020                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2021                 return VC_ERROR_INVALID_STATE;
2022         }
2023
2024         /* check state */
2025         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2026
2027         vc_client_set_error_cb(callback,  user_data);
2028
2029         return VC_ERROR_NONE;
2030 }
2031
2032 int vc_unset_error_cb(void)
2033 {
2034         int ret;
2035         ret = __check_feature_privilege();
2036         if (VC_ERROR_NONE != ret)
2037                 return ret;
2038
2039         vc_state_e state;
2040         if (0 != vc_client_get_client_state(&state)) {
2041                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2042                 return VC_ERROR_INVALID_STATE;
2043         }
2044
2045         /* check state */
2046         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2047
2048         vc_client_set_error_cb(NULL, NULL);
2049
2050         return VC_ERROR_NONE;
2051 }
2052
2053 int vc_set_invocation_name(const char* name)
2054 {
2055         int ret;
2056         ret = __check_feature_privilege();
2057         if (VC_ERROR_NONE != ret)
2058                 return ret;
2059
2060         vc_state_e state;
2061         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2062
2063         ret = vc_client_get_client_state(&state);
2064         if (0 != ret) {
2065                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2066                 return ret;
2067         }
2068
2069         /* check state */
2070         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2071
2072         ret = vc_client_set_invocation_name(name);
2073         if (0 != ret) {
2074                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2075         }
2076         return ret;
2077 }
2078
2079 int vc_set_server_dialog(const char* app_id, const char* credential)
2080 {
2081         vc_state_e state;
2082         int ret = -1;
2083         ret = __check_feature_privilege();
2084         if (VC_ERROR_NONE != ret)
2085                 return ret;
2086
2087         RETVM_IF(NULL == credential, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Credential is NULL");
2088
2089         if (0 != vc_client_get_client_state(&state)) {
2090                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2091                 return VC_ERROR_INVALID_STATE;
2092         }
2093
2094         /* check state */
2095         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2096
2097         /* Check service state */
2098         vc_service_state_e service_state = -1;
2099         vc_client_get_service_state(&service_state);
2100         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2101
2102
2103         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2104
2105         char* tmp_appid = NULL;
2106         if (NULL == app_id) {
2107                 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2108                 if (0 != ret || NULL == tmp_appid) {
2109                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2110                         FREE(tmp_appid);
2111                         return VC_ERROR_INVALID_PARAMETER;
2112                 }
2113         } else {
2114                 tmp_appid = strdup(app_id);
2115         }
2116         int pid = getpid();
2117
2118         SLOG(LOG_DEBUG, TAG_VCC, "Set server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2119
2120         int count = 0;
2121         bool is_prepared = false;
2122         do {
2123                 ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential);
2124                 if (0 != ret) {
2125                         //LCOV_EXCL_START
2126                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2127                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2128                                 if (0 == vc_prepare_sync()) {
2129                                         is_prepared = true;
2130                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2131                                 }
2132                         } else if (VC_ERROR_TIMED_OUT != ret) {
2133                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set server dialog to vc service : %s", __vc_get_error_code(ret));
2134                                 break;
2135                         } else {
2136                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set server dialog : %s", __vc_get_error_code(ret));
2137                                 usleep(10000);
2138                                 count++;
2139                                 if (VC_RETRY_COUNT == count) {
2140                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2141                                         break;
2142                                 }
2143                         }
2144                         //LCOV_EXCL_STOP
2145                 }
2146         } while (0 != ret);
2147
2148         FREE(tmp_appid);
2149
2150         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog DONE");
2151
2152         return ret;
2153 }
2154
2155 int vc_unset_server_dialog(const char* app_id)
2156 {
2157         vc_state_e state;
2158         int ret = -1;
2159         char* tmp_appid = NULL;
2160
2161         ret = __check_feature_privilege();
2162         if (VC_ERROR_NONE != ret)
2163                 return ret;
2164
2165         if (0 != vc_client_get_client_state(&state)) {
2166                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2167                 return VC_ERROR_INVALID_STATE;
2168         }
2169
2170         /* check state */
2171         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2172
2173         /* Check service state */
2174         vc_service_state_e service_state = -1;
2175         vc_client_get_service_state(&service_state);
2176         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2177
2178
2179         if (NULL == app_id) {
2180                 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2181                 if (0 != ret || NULL == tmp_appid) {
2182                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2183                         FREE(tmp_appid);
2184                         return VC_ERROR_INVALID_PARAMETER;
2185                 }
2186         } else {
2187                 tmp_appid = strdup(app_id);
2188         }
2189         int pid = getpid();
2190
2191         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2192
2193         int count = 0;
2194         bool is_prepared = false;
2195         char* credential = strdup("#NULL");
2196         do {
2197                 ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential);
2198                 if (0 != ret) {
2199                         //LCOV_EXCL_START
2200                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2201                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2202                                 if (0 == vc_prepare_sync()) {
2203                                         is_prepared = true;
2204                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2205                                 }
2206                         } else if (VC_ERROR_TIMED_OUT != ret) {
2207                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset server dialog to vc service : %s", __vc_get_error_code(ret));
2208                                 break;
2209                         } else {
2210                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset server dialog : %s", __vc_get_error_code(ret));
2211                                 usleep(10000);
2212                                 count++;
2213                                 if (VC_RETRY_COUNT == count) {
2214                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2215                                         break;
2216                                 }
2217                         }
2218                         //LCOV_EXCL_STOP
2219                 }
2220         } while (0 != ret);
2221
2222         FREE(tmp_appid);
2223         FREE(credential);
2224
2225         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog DONE");
2226
2227         return ret;
2228 }
2229
2230 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2231 {
2232         vc_state_e state;
2233         int ret;
2234         ret = __check_feature_privilege();
2235         if (VC_ERROR_NONE != ret)
2236                 return ret;
2237
2238         if (0 != vc_client_get_client_state(&state)) {
2239                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2240                 return VC_ERROR_INVALID_STATE;
2241         }
2242
2243         /* check state */
2244         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2245
2246         /* Check service state */
2247         vc_service_state_e service_state = -1;
2248         vc_client_get_service_state(&service_state);
2249         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2250
2251         RETVM_IF(NULL == disp_text && NULL == utt_text, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Both two parameters are NULL");
2252
2253         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);
2254         ret = vc_tidl_request_request_dialog(getpid(), disp_text, utt_text, auto_start);
2255         if (0 != ret) {
2256                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret);
2257                 return VC_ERROR_OPERATION_FAILED;
2258         }
2259
2260         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog DONE");
2261
2262         return VC_ERROR_NONE;
2263 }
2264
2265 //LCOV_EXCL_START
2266 /* Authority */
2267 int vc_auth_enable(void)
2268 {
2269         /* check state */
2270         vc_state_e state;
2271         if (0 != vc_client_get_client_state(&state)) {
2272                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2273                 return VC_ERROR_INVALID_STATE;
2274         }
2275         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Current state(%d) is not 'READY'", state);
2276
2277         /* check already authority */
2278         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2279         if (0 != vc_client_get_auth_state(&auth_state)) {
2280                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2281                 return VC_ERROR_INVALID_STATE;
2282         }
2283         RETVM_IF(VC_AUTH_STATE_NONE != auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Already authority enabled");
2284
2285         /* request authority */
2286         int mgr_pid = -1;
2287         if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
2288                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2289                 return VC_ERROR_OPERATION_FAILED;
2290         }
2291
2292         if (0 != vc_tidl_request_auth_enable(g_pid, mgr_pid)) {
2293                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2294                 return VC_ERROR_OPERATION_FAILED;
2295         }
2296
2297         /* set authority into handle */
2298         bool is_foreground = false;
2299         if (0 != vc_client_get_is_foreground(&is_foreground)) {
2300                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2301                 return VC_ERROR_OPERATION_FAILED;
2302         }
2303
2304         if (is_foreground) {
2305                 auth_state = VC_AUTH_STATE_VALID;
2306         } else {
2307                 auth_state = VC_AUTH_STATE_INVALID;
2308         }
2309
2310         if (0 != vc_client_set_auth_state(auth_state)) {
2311                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2312                 return VC_ERROR_OPERATION_FAILED;
2313         }
2314
2315         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2316
2317         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2318
2319         return VC_ERROR_NONE;
2320 }
2321
2322 int vc_auth_disable(void)
2323 {
2324         /* check state */
2325         vc_state_e state;
2326         if (0 != vc_client_get_client_state(&state)) {
2327                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2328                 return VC_ERROR_INVALID_STATE;
2329         }
2330         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Current state(%d) is not 'READY'", state);
2331
2332         /* check authority */
2333         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2334         if (0 != vc_client_get_auth_state(&auth_state)) {
2335                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2336                 return VC_ERROR_INVALID_STATE;
2337         }
2338         RETVM_IF(VC_AUTH_STATE_NONE == auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] No authority");
2339
2340         if (0 != vc_auth_unset_state_changed_cb()) {
2341                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2342         }
2343
2344         /* request return authority by tidl */
2345         int mgr_pid = -1;
2346         if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
2347                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2348                 return VC_ERROR_OPERATION_FAILED;
2349         }
2350
2351         if (0 != vc_tidl_request_auth_disable(g_pid, mgr_pid)) {
2352                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
2353                 return VC_ERROR_OPERATION_FAILED;
2354         }
2355
2356         /* unset authority from handle */
2357         if (0 != vc_client_set_auth_state(VC_AUTH_STATE_NONE)) {
2358                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2359                 return VC_ERROR_OPERATION_FAILED;
2360         }
2361
2362         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2363
2364         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2365
2366         return VC_ERROR_NONE;
2367 }
2368
2369 int vc_auth_get_state(vc_auth_state_e* state)
2370 {
2371         /* check state */
2372         vc_state_e vc_state;
2373         if (0 != vc_client_get_client_state(&vc_state)) {
2374                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2375                 return VC_ERROR_INVALID_STATE;
2376         }
2377         RETVM_IF(VC_STATE_READY != vc_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Current state(%d) is not 'READY'", vc_state);
2378
2379         /* get authority */
2380         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2381         if (0 != vc_client_get_auth_state(&temp)) {
2382                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2383                 return VC_ERROR_INVALID_STATE;
2384         }
2385
2386         *state = temp;
2387
2388         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2389
2390         return VC_ERROR_NONE;
2391 }
2392
2393 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2394 {
2395         /* check parameter */
2396         if (NULL == callback) {
2397                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2398                 return VC_ERROR_INVALID_PARAMETER;
2399         }
2400
2401         /* check auth */
2402         vc_auth_state_e auth_state;
2403         if (0 != vc_client_get_auth_state(&auth_state)) {
2404                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2405                 return VC_ERROR_INVALID_STATE;
2406         }
2407         RETVM_IF(VC_AUTH_STATE_NONE == auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Auth is not enabled");
2408
2409         /* set cb into handle */
2410         if (0 != vc_client_set_auth_state_changed_cb(callback, user_data)) {
2411                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2412                 return VC_ERROR_OPERATION_FAILED;
2413         }
2414
2415         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
2416
2417         return VC_ERROR_NONE;
2418 }
2419
2420 int vc_auth_unset_state_changed_cb(void)
2421 {
2422         /* check auth */
2423         vc_auth_state_e auth_state;
2424         if (0 != vc_client_get_auth_state(&auth_state)) {
2425                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2426                 return VC_ERROR_INVALID_STATE;
2427         }
2428         RETVM_IF(VC_AUTH_STATE_NONE == auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Auth is not enabled");
2429
2430         /* unset cb from handle */
2431         if (0 != vc_client_unset_auth_state_changed_cb()) {
2432                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2433                 return VC_ERROR_OPERATION_FAILED;
2434         }
2435
2436         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2437
2438         return VC_ERROR_NONE;
2439 }
2440
2441 int vc_auth_start(void)
2442 {
2443         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2444
2445         vc_state_e state;
2446         if (0 != vc_client_get_client_state(&state)) {
2447                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2448                 return VC_ERROR_INVALID_STATE;
2449         }
2450
2451         /* check state */
2452         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2453
2454         /* Check service state */
2455         vc_service_state_e service_state = -1;
2456         vc_client_get_service_state(&service_state);
2457         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2458
2459         /* Check authority */
2460         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2461         if (0 != vc_client_get_auth_state(&auth_state)) {
2462                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2463                 return VC_ERROR_OPERATION_FAILED;
2464         }
2465         RETVM_IF(VC_AUTH_STATE_VALID != auth_state, VC_ERROR_OPERATION_FAILED, TAG_VCC, "[ERROR] Not auth valid");
2466
2467         /* get mgr_pid */
2468         int mgr_pid = -1;
2469         if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
2470                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2471                 return VC_ERROR_OPERATION_FAILED;
2472         }
2473
2474         int ret = -1;
2475         int count = 0;
2476         bool is_prepared = false;
2477         /* Request */
2478         while (0 != ret) {
2479                 ret = vc_tidl_request_auth_start(g_pid, mgr_pid);
2480                 if (0 != ret) {
2481                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2482                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2483                                 if (0 == vc_prepare_sync()) {
2484                                         is_prepared = true;
2485                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2486                                 }
2487                         } else if (VC_ERROR_TIMED_OUT != ret) {
2488                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2489                                 break;
2490                         } else {
2491                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2492                                 usleep(10000);
2493                                 count++;
2494                                 if (VC_RETRY_COUNT == count) {
2495                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2496                                         break;
2497                                 }
2498                         }
2499                 } else {
2500                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2501                 }
2502         }
2503
2504         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start DONE");
2505
2506         return ret;
2507 }
2508
2509 int vc_auth_stop(void)
2510 {
2511         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2512
2513         vc_state_e state;
2514         if (0 != vc_client_get_client_state(&state)) {
2515                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2516                 return VC_ERROR_INVALID_STATE;
2517         }
2518
2519         /* check state */
2520         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2521
2522         /* Check service state */
2523         vc_service_state_e service_state = -1;
2524         vc_client_get_service_state(&service_state);
2525         RETVM_IF(service_state != VC_SERVICE_STATE_RECORDING, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'RECORDING'", service_state);
2526
2527         /* Check authority */
2528         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2529         if (0 != vc_client_get_auth_state(&auth_state)) {
2530                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2531                 return VC_ERROR_OPERATION_FAILED;
2532         }
2533         RETVM_IF(VC_AUTH_STATE_VALID != auth_state, VC_ERROR_OPERATION_FAILED, TAG_VCC, "[ERROR] Not auth valid");
2534
2535         /* get mgr_pid */
2536         int mgr_pid = -1;
2537         if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
2538                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2539                 return VC_ERROR_OPERATION_FAILED;
2540         }
2541
2542         int ret = -1;
2543         int count = 0;
2544         bool is_prepared = false;
2545         /* do request */
2546         while (0 != ret) {
2547                 ret = vc_tidl_request_auth_stop(g_pid, mgr_pid);
2548                 if (0 != ret) {
2549                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2550                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2551                                 if (0 == vc_prepare_sync()) {
2552                                         is_prepared = true;
2553                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2554                                 }
2555                         } else if (VC_ERROR_TIMED_OUT != ret) {
2556                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2557                                 break;
2558                         } else {
2559                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2560                                 usleep(10000);
2561                                 count++;
2562                                 if (VC_RETRY_COUNT == count) {
2563                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2564                                         break;
2565                                 }
2566                         }
2567                 } else {
2568                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2569                 }
2570         }
2571
2572         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop DONE");
2573
2574         return ret;
2575 }
2576
2577 int vc_auth_cancel(void)
2578 {
2579         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2580
2581         vc_state_e state;
2582         if (0 != vc_client_get_client_state(&state)) {
2583                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2584                 return VC_ERROR_INVALID_STATE;
2585         }
2586
2587         /* check state */
2588         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2589
2590         /* Check service state */
2591         vc_service_state_e service_state = -1;
2592         vc_client_get_service_state(&service_state);
2593         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2594                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2595                 return VC_ERROR_INVALID_STATE;
2596         }
2597
2598         /* Check authority */
2599         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2600         if (0 != vc_client_get_auth_state(&auth_state)) {
2601                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2602                 return VC_ERROR_OPERATION_FAILED;
2603         }
2604         RETVM_IF(VC_AUTH_STATE_VALID != auth_state, VC_ERROR_OPERATION_FAILED, TAG_VCC, "[ERROR] Not auth valid");
2605
2606         /* get mgr_pid */
2607         int mgr_pid = -1;
2608         if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
2609                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2610                 return VC_ERROR_OPERATION_FAILED;
2611         }
2612
2613         int ret = -1;
2614         int count = 0;
2615         bool is_prepared = false;
2616         while (0 != ret) {
2617                 ret = vc_tidl_request_auth_cancel(g_pid, mgr_pid);
2618                 if (0 != ret) {
2619                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2620                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2621                                 if (0 == vc_prepare_sync()) {
2622                                         is_prepared = true;
2623                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2624                                 }
2625                         } else if (VC_ERROR_TIMED_OUT != ret) {
2626                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2627                                 break;
2628                         } else {
2629                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2630                                 usleep(10000);
2631                                 count++;
2632                                 if (VC_RETRY_COUNT == count) {
2633                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2634                                         break;
2635                                 }
2636                         }
2637                 } else {
2638                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2639                 }
2640         }
2641
2642         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel DONE");
2643
2644         return ret;
2645 }
2646
2647 static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
2648 {
2649         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Start tts streaming thread");
2650
2651         vc_tts_streaming_cb callback = NULL;
2652         void* user_data = NULL;
2653
2654         vc_client_get_tts_streaming_cb(&callback, &user_data);
2655         RETM_IF(NULL == callback, TAG_VCC, "[WARNING] tts streaming callback is null");
2656
2657         while (1) {
2658                 int ret = -1;
2659                 int cnt = 0;
2660
2661                 /* get tts data */
2662                 vc_tts_data_s *tts_data = NULL;
2663                 ret = vc_data_get_first_tts_data(&tts_data);
2664                 if (0 != ret || NULL == tts_data) {
2665                         /* empty queue */
2666                         SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] No tts data. Waiting mode");
2667
2668                         /* waiting */
2669                         while (1) {
2670                                 usleep(10000);
2671                                 if (0 < vc_data_get_tts_data_size()) {
2672                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Resume thread");
2673                                         break;
2674                                 }
2675                                 if (200 < cnt) {
2676                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Wrong request, there's no pcm data");
2677                                         vc_data_clear_tts_data(&tts_data);
2678                                         return;
2679                                 }
2680                                 cnt++;
2681                         }
2682                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish to wait for new tts data come");
2683
2684                         /* resume tts thread */
2685                         vc_data_clear_tts_data(&tts_data);
2686                         continue;
2687                 }
2688
2689                 if (NULL != tts_data) {
2690                         SLOG(LOG_DEBUG, TAG_VCC, "tts streaming callback is called");
2691                         vc_client_use_callback();
2692                         callback(tts_data->event, tts_data->data, tts_data->data_size, tts_data->utt_id, user_data);
2693                         vc_client_not_use_callback();
2694
2695                         /* If no tts data and EVENT_FINISH */
2696                         if (0 >= vc_data_get_tts_data_size() && VC_TTS_EVENT_FINISH == tts_data->event) {
2697                                 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish tts");
2698                                 FREE(tts_data)
2699                                 break;
2700                         }
2701                         FREE(tts_data);
2702                 }
2703         }
2704 }
2705
2706 static void __end_tts_streaming_thread(void* data, Ecore_Thread* thread)
2707 {
2708         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] End tts streaming thread");
2709         g_tts_thread = NULL;
2710 }
2711
2712 int __vc_cb_tts_streaming(int utt_id, vc_tts_event_e event, char* buffer, int len)
2713 {
2714         /* add tts data */
2715         vc_tts_data_s* temp_tts_data = NULL;
2716         temp_tts_data = (vc_tts_data_s*)calloc(1, sizeof(vc_tts_data_s));
2717         RETVM_IF(NULL == temp_tts_data, VC_ERROR_OUT_OF_MEMORY, TAG_VCC, "[ERROR] Out of memory");
2718
2719         temp_tts_data->data = NULL;
2720         temp_tts_data->data_size = 0;
2721
2722         if (0 < len) {
2723                 temp_tts_data->data = (char*)calloc(len + 5, sizeof(char));
2724                 if (NULL != temp_tts_data->data) {
2725                         memcpy(temp_tts_data->data, buffer, len);
2726                         temp_tts_data->data_size = len;
2727                         SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG][memcpy] data(%p) size(%d)",
2728                                         temp_tts_data->data, temp_tts_data->data_size);
2729                 } else {
2730                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to allocate memory");
2731                 }
2732         } else {
2733                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] tts data is NULL");
2734         }
2735
2736         temp_tts_data->utt_id = utt_id;
2737         temp_tts_data->event = event;
2738
2739         int ret = vc_data_add_tts_data(temp_tts_data);
2740         if (0 != ret) {
2741                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to add tts data");
2742                 FREE(temp_tts_data->data);
2743                 FREE(temp_tts_data);
2744         }
2745
2746         bool is_canceled = ecore_thread_check(g_tts_thread);
2747         if (NULL == g_tts_thread || TRUE == is_canceled) {
2748                 SLOG(LOG_INFO, TAG_VCC, "ecore thread run : __start_tts_streaming_thread ");
2749                 g_tts_thread = ecore_thread_run(__start_tts_streaming_thread, __end_tts_streaming_thread, NULL, NULL);
2750         }
2751
2752         return ret;
2753 }
2754
2755 int vc_tts_request(const char* text, const char* language, bool to_vc_manager, int* utt_id)
2756 {
2757         vc_state_e state;
2758         int ret = -1;
2759         int pid = getpid();
2760
2761         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request tts");
2762
2763         ret = __vc_tts_check_privilege();
2764         if (VC_ERROR_NONE != ret)
2765                 return ret;
2766
2767         if (0 != vc_client_get_client_state(&state)) {
2768                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2769                 return VC_ERROR_INVALID_STATE;
2770         }
2771
2772         /* check state */
2773         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2774
2775         /* Check service state */
2776         vc_service_state_e service_state = -1;
2777         vc_client_get_service_state(&service_state);
2778         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2779         RETVM_IF(NULL == text || NULL == language || NULL == utt_id, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Parameter is NULL");
2780
2781         SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts request, pid(%d), text(%s), language(%s), to_vc_manager(%d)", pid, text, language, to_vc_manager);
2782
2783         int count = 0;
2784         bool is_prepared = false;
2785         do {
2786                 ret = vc_tidl_request_request_tts(pid, text, language, to_vc_manager, utt_id);
2787                 if (0 != ret) {
2788                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2789                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2790                                 if (0 == vc_prepare_sync()) {
2791                                         is_prepared = true;
2792                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2793                                 }
2794                         } else if (VC_ERROR_TIMED_OUT != ret) {
2795                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request tts to vc service : %s", __vc_get_error_code(ret));
2796                                 break;
2797                         } else {
2798                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request tts : %s", __vc_get_error_code(ret));
2799                                 usleep(10000);
2800                                 count++;
2801                                 if (VC_RETRY_COUNT == count) {
2802                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2803                                         break;
2804                                 }
2805                         }
2806                 }
2807         } while (0 != ret);
2808
2809         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request tts DONE");
2810
2811         return ret;
2812 }
2813
2814 int vc_tts_cancel(int utt_id)
2815 {
2816         vc_state_e state;
2817         int ret = -1;
2818         int pid = getpid();
2819
2820         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Cancel tts");
2821
2822         ret = __vc_tts_check_privilege();
2823         if (VC_ERROR_NONE != ret)
2824                 return ret;
2825
2826         if (0 != vc_client_get_client_state(&state)) {
2827                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2828                 return VC_ERROR_INVALID_STATE;
2829         }
2830
2831         /* check state */
2832         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2833
2834         /* Check service state */
2835         vc_service_state_e service_state = -1;
2836         vc_client_get_service_state(&service_state);
2837         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2838         RETVM_IF(0 > utt_id, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] utt_id is negative value");
2839
2840         SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts cancel, pid(%d), utt_id(%d)", pid, utt_id);
2841
2842         ret = vc_data_clear_tts_data_by_uttid(utt_id);
2843         if (0 != ret) {
2844                 SLOG(LOG_INFO, TAG_VCC, "[INFO] There's no data in client pcm queue");
2845         }
2846
2847         int count = 0;
2848         bool is_prepared = false;
2849         do {
2850                 ret = vc_tidl_request_cancel_tts(pid, utt_id);
2851                 if (0 != ret) {
2852                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2853                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2854                                 if (0 == vc_prepare_sync()) {
2855                                         is_prepared = true;
2856                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2857                                 }
2858                         } else if (VC_ERROR_TIMED_OUT != ret) {
2859                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel tts to vc service : %s", __vc_get_error_code(ret));
2860                                 break;
2861                         } else {
2862                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel tts : %s", __vc_get_error_code(ret));
2863                                 usleep(10000);
2864                                 count++;
2865                                 if (VC_RETRY_COUNT == count) {
2866                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel");
2867                                         break;
2868                                 }
2869                         }
2870                 }
2871         } while (0 != ret);
2872
2873         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Cancel tts DONE");
2874
2875         return ret;
2876 }
2877
2878 int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type)
2879 {
2880         vc_state_e state;
2881         int ret = -1;
2882         int pid = getpid();
2883
2884         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get tts audio format");
2885
2886         ret = __vc_tts_check_privilege();
2887         if (VC_ERROR_NONE != ret)
2888                 return ret;
2889
2890         if (0 != vc_client_get_client_state(&state)) {
2891                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2892                 return VC_ERROR_INVALID_STATE;
2893         }
2894
2895         /* check state */
2896         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2897
2898         /* Check service state */
2899         vc_service_state_e service_state = -1;
2900         vc_client_get_service_state(&service_state);
2901         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2902
2903         SLOG(LOG_DEBUG, TAG_VCC, "@@@ get tts audio format, pid(%d)", pid);
2904
2905         int count = 0;
2906         bool is_prepared = false;
2907         do {
2908                 ret = vc_tidl_request_get_tts_audio_format(pid, rate, channel, audio_type);
2909                 if (0 != ret) {
2910                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2911                                 vc_client_set_client_state(VC_STATE_INITIALIZED);
2912                                 if (0 == vc_prepare_sync()) {
2913                                         is_prepared = true;
2914                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2915                                 }
2916                         } else if (VC_ERROR_TIMED_OUT != ret) {
2917                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format : %s", __vc_get_error_code(ret));
2918                                 break;
2919                         } else {
2920                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to get tts audio format : %s", __vc_get_error_code(ret));
2921                                 usleep(10000);
2922                                 count++;
2923                                 if (VC_RETRY_COUNT == count) {
2924                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format");
2925                                         break;
2926                                 }
2927                         }
2928                 }
2929         } while (0 != ret);
2930
2931         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get tts audio format DONE");
2932
2933         return ret;
2934 }
2935 //LCOV_EXCL_STOP
2936
2937 int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
2938 {
2939         int ret;
2940         ret = __vc_tts_check_privilege();
2941         if (VC_ERROR_NONE != ret)
2942                 return ret;
2943
2944         if (NULL == callback)
2945                 return VC_ERROR_INVALID_PARAMETER;
2946
2947         vc_state_e state;
2948         if (0 != vc_client_get_client_state(&state)) {
2949                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : A handle is not available");
2950                 return VC_ERROR_INVALID_STATE;
2951         }
2952
2953         /* check state */
2954         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2955
2956         vc_client_set_tts_streaming_cb(callback,        user_data);
2957
2958         return VC_ERROR_NONE;
2959 }
2960
2961 int vc_tts_unset_streaming_cb(void)
2962 {
2963         int ret;
2964         ret = __vc_tts_check_privilege();
2965         if (VC_ERROR_NONE != ret)
2966                 return ret;
2967
2968         vc_state_e state;
2969         if (0 != vc_client_get_client_state(&state)) {
2970                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : A handle is not available");
2971                 return VC_ERROR_INVALID_STATE;
2972         }
2973
2974         /* check state */
2975         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2976
2977         vc_client_set_tts_streaming_cb(NULL, NULL);
2978
2979         return VC_ERROR_NONE;
2980 }
2981
2982 //LCOV_EXCL_START
2983 int __vc_cb_utterance_status(int utt_id, int utt_status)
2984 {
2985         vc_tts_utterance_status_cb callback = NULL;
2986         void* user_data = NULL;
2987
2988         vc_client_get_tts_utterance_status_cb(&callback, &user_data);
2989         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Utterance status callback is null");
2990
2991         SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
2992         vc_client_use_callback();
2993         callback(utt_id, (vc_tts_utterance_status_e)utt_status, user_data);
2994         vc_client_not_use_callback();
2995
2996         return VC_ERROR_NONE;
2997 }
2998 //LCOV_EXCL_STOP
2999
3000 int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
3001 {
3002         int ret;
3003         ret = __vc_tts_check_privilege();
3004         if (VC_ERROR_NONE != ret)
3005                 return ret;
3006
3007         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Utterance status callback is null");
3008
3009         vc_state_e state;
3010         if (0 != vc_client_get_client_state(&state)) {
3011                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : A handle is not available");
3012                 return VC_ERROR_INVALID_STATE;
3013         }
3014
3015         /* check state */
3016         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
3017
3018         vc_client_set_tts_utterance_status_cb(callback,  user_data);
3019
3020         return VC_ERROR_NONE;
3021 }
3022
3023 int vc_tts_unset_utterance_status_cb(void)
3024 {
3025         int ret;
3026         ret = __vc_tts_check_privilege();
3027         if (VC_ERROR_NONE != ret)
3028                 return ret;
3029
3030         vc_state_e state;
3031         if (0 != vc_client_get_client_state(&state)) {
3032                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : A handle is not available");
3033                 return VC_ERROR_INVALID_STATE;
3034         }
3035
3036         /* check state */
3037         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
3038
3039         vc_client_set_tts_utterance_status_cb(NULL, NULL);
3040
3041         return VC_ERROR_NONE;
3042 }