2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <app_manager.h>
19 #include <cynara-client.h>
20 #include <cynara-error.h>
21 #include <cynara-session.h>
22 #include <Ecore_Wayland.h>
26 #include <system_info.h>
28 #include "vc_client.h"
29 #include "vc_cmd_db.h"
30 #include "vc_command.h"
31 #include "vc_config_mgr.h"
34 #include "vc_info_parser.h"
35 #include "vc_json_parser.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"
45 static Ecore_Timer* g_connect_timer = NULL;
47 static Ecore_Event_Handler* g_focus_in_handler = NULL;
48 static Ecore_Event_Handler* g_focus_out_handler = NULL;
50 static Ecore_Thread* g_tts_thread = NULL;
52 static vc_h g_vc = NULL;
54 static int g_daemon_pid = 0;
56 static int g_feature_enabled = -1;
57 static bool g_backup = false;
59 static int g_privilege_allowed = -1;
60 static cynara *p_cynara = NULL;
62 static void __vc_notify_state_changed(void *data);
63 static void __vc_notify_error(void *data);
65 static int __vc_get_feature_enabled()
67 if (0 == g_feature_enabled) {
69 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
70 return VC_ERROR_NOT_SUPPORTED;
72 } else if (-1 == g_feature_enabled) {
73 bool vc_supported = false;
74 bool mic_supported = false;
75 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
76 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
77 if (false == vc_supported || false == mic_supported) {
78 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
79 g_feature_enabled = 0;
80 return VC_ERROR_NOT_SUPPORTED;
83 g_feature_enabled = 1;
85 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
86 return VC_ERROR_NOT_SUPPORTED;
89 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
90 return VC_ERROR_NOT_SUPPORTED;
97 static int __check_privilege_initialize()
99 int ret = cynara_initialize(&p_cynara, NULL);
100 if (CYNARA_API_SUCCESS != ret)
101 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize"); //LCOV_EXCL_LINE
103 return ret == CYNARA_API_SUCCESS;
106 static int __check_privilege(const char* uid, const char * privilege)
109 char label_path[1024] = "/proc/self/attr/current";
110 char smack_label[1024] = {'\0',};
116 fp = fopen(label_path, "r");
118 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
119 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread"); //LCOV_EXCL_LINE
124 pid_t pid = getpid();
125 char *session = cynara_session_from_pid(pid);
126 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
127 SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
131 if (ret != CYNARA_API_ACCESS_ALLOWED)
136 static void __check_privilege_deinitialize()
139 cynara_finish(p_cynara);
143 static int __vc_check_privilege()
147 if (0 == g_privilege_allowed) {
149 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
150 return VC_ERROR_PERMISSION_DENIED;
152 } else if (-1 == g_privilege_allowed) {
153 if (false == __check_privilege_initialize()) {
154 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed"); //LCOV_EXCL_LINE
155 return VC_ERROR_PERMISSION_DENIED;
157 snprintf(uid, 16, "%d", getuid());
158 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
159 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
160 g_privilege_allowed = 0;
161 __check_privilege_deinitialize();
162 return VC_ERROR_PERMISSION_DENIED;
164 __check_privilege_deinitialize();
167 g_privilege_allowed = 1;
168 return VC_ERROR_NONE;
172 static const char* __vc_get_error_code(vc_error_e err)
175 case VC_ERROR_NONE: return "VC_ERROR_NONE";
176 case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY";
177 case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR";
178 case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER";
179 case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT";
180 case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY";
181 case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE";
182 case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE";
183 case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
184 case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
185 default: return "Invalid error code";
190 static int __vc_convert_config_error_code(vc_config_error_e code)
192 if (code == VC_CONFIG_ERROR_NONE) return VC_ERROR_NONE;
193 if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY) return VC_ERROR_OUT_OF_MEMORY;
194 if (code == VC_CONFIG_ERROR_IO_ERROR) return VC_ERROR_IO_ERROR;
195 if (code == VC_CONFIG_ERROR_INVALID_PARAMETER) return VC_ERROR_INVALID_PARAMETER;
196 if (code == VC_CONFIG_ERROR_INVALID_STATE) return VC_ERROR_INVALID_STATE;
197 if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE) return VC_ERROR_INVALID_LANGUAGE;
198 if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND) return VC_ERROR_ENGINE_NOT_FOUND;
199 if (code == VC_CONFIG_ERROR_OPERATION_FAILED) return VC_ERROR_OPERATION_FAILED;
201 return VC_ERROR_NONE;
204 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
206 SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
207 before_lang, current_lang);
209 vc_current_language_changed_cb callback;
210 void* lang_user_data;
211 vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
213 if (NULL != callback) {
214 vc_client_use_callback(g_vc);
215 callback(before_lang, current_lang, lang_user_data);
216 vc_client_not_use_callback(g_vc);
217 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
219 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
225 static Eina_Bool __notify_auth_changed_cb(void *data)
227 vc_auth_state_changed_cb callback = NULL;
230 vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
232 vc_auth_state_e before = -1;
233 vc_auth_state_e current = -1;
235 vc_client_get_before_auth_state(g_vc, &before, ¤t);
237 if (NULL != callback) {
238 vc_client_use_callback(g_vc);
239 callback(before, current, user_data);
240 vc_client_not_use_callback(g_vc);
241 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
243 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
249 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
251 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
254 if (ECORE_WL_EVENT_FOCUS_IN == type) {
255 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
256 ret = vc_dbus_set_foreground(getpid(), true);
258 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
261 ret = vc_client_set_is_foreground(g_vc, true);
263 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
266 /* set authority valid */
267 vc_auth_state_e state = VC_AUTH_STATE_NONE;
268 if (0 != vc_client_get_auth_state(g_vc, &state)) {
269 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
271 if (VC_AUTH_STATE_INVALID == state) {
272 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
274 /* notify auth changed cb */
275 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
277 } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
278 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
279 ret = vc_dbus_set_foreground(getpid(), false);
281 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
284 ret = vc_client_set_is_foreground(g_vc, false);
286 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
289 /* set authority valid */
290 vc_auth_state_e state = VC_AUTH_STATE_NONE;
291 if (0 != vc_client_get_auth_state(g_vc, &state)) {
292 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
294 if (VC_AUTH_STATE_VALID == state) {
295 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
297 /* notify authority changed cb */
298 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
301 SLOG(LOG_DEBUG, TAG_VCC, "@@@ type(%d) is NOT valid", type);
304 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
306 return ECORE_CALLBACK_RENEW;
310 int vc_initialize(void)
312 if (0 != __vc_get_feature_enabled()) {
313 return VC_ERROR_NOT_SUPPORTED;
315 if (0 != __vc_check_privilege()) {
316 return VC_ERROR_PERMISSION_DENIED;
319 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Initialize");
322 if (true == vc_client_is_valid(g_vc)) {
323 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
324 return VC_ERROR_NONE; //LCOV_EXCL_LINE
327 if (0 < vc_client_get_count()) {
328 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
329 return VC_ERROR_NONE; //LCOV_EXCL_LINE
332 if (0 != vc_dbus_open_connection()) {
333 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection"); //LCOV_EXCL_LINE
334 return VC_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
337 if (0 != vc_client_create(&g_vc)) {
338 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!"); //LCOV_EXCL_LINE
339 return VC_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
342 int ret = vc_config_mgr_initialize(g_vc->handle);
344 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
345 __vc_get_error_code(__vc_convert_config_error_code(ret))); //LCOV_EXCL_LINE
346 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
347 return __vc_convert_config_error_code(ret); //LCOV_EXCL_LINE
350 ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
352 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret); //LCOV_EXCL_LINE
353 vc_config_mgr_finalize(g_vc->handle); //LCOV_EXCL_LINE
354 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
355 return __vc_convert_config_error_code(ret);
358 ret = vc_db_initialize();
360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret); //LCOV_EXCL_LINE
361 vc_config_mgr_finalize(g_vc->handle); //LCOV_EXCL_LINE
362 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
366 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
368 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
370 return VC_ERROR_NONE;
373 static void __vc_internal_unprepare(void)
375 /* return authority */
376 vc_auth_state_e state = VC_AUTH_STATE_NONE;
377 if (0 != vc_client_get_auth_state(g_vc, &state)) {
378 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
381 if (VC_AUTH_STATE_NONE != state) {
382 if (0 != vc_auth_disable()) {
383 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable"); //LCOV_EXCL_LINE
387 int ret = vc_dbus_request_finalize(g_vc->handle);
389 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
392 if (NULL != g_focus_in_handler) {
393 ecore_event_handler_del(g_focus_in_handler);
394 g_focus_in_handler = NULL;
396 if (NULL != g_focus_out_handler) {
397 ecore_event_handler_del(g_focus_out_handler);
398 g_focus_out_handler = NULL;
401 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
403 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
408 int vc_deinitialize(void)
410 int ret = VC_ERROR_NONE;
412 if (0 != __vc_get_feature_enabled()) {
413 return VC_ERROR_NOT_SUPPORTED;
415 if (0 != __vc_check_privilege()) {
416 return VC_ERROR_PERMISSION_DENIED;
419 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize");
421 if (false == vc_client_is_valid(g_vc)) {
422 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
423 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
424 return VC_ERROR_INVALID_STATE;
428 vc_client_get_client_state(g_vc, &state);
433 __vc_internal_unprepare();
434 /* no break. need to next step*/
435 case VC_STATE_INITIALIZED:
436 if (NULL != g_connect_timer) {
437 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted"); //LCOV_EXCL_LINE
438 ecore_timer_del(g_connect_timer);
439 g_connect_timer = NULL;
442 vc_config_mgr_unset_lang_cb(g_vc->handle);
443 vc_config_mgr_finalize(g_vc->handle);
445 /* Free client resources */
446 vc_client_destroy(g_vc);
453 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
455 if (true == g_backup) {
456 ret = vc_db_backup_command();
458 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to backup command, ret(%d)", ret); //LCOV_EXCL_LINE
462 ret = vc_db_finalize();
464 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret); //LCOV_EXCL_LINE
467 if (0 != vc_dbus_close_connection()) {
468 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE
471 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
473 return VC_ERROR_NONE;
476 static Eina_Bool __vc_connect_daemon(void *data)
478 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
480 /* request initialization */
483 int service_state = 0;
485 g_connect_timer = NULL;
487 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
489 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
492 if (true == vc_client_is_valid(g_vc)) {
493 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] g_vc is valid");
495 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
497 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
498 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
500 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
501 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
505 } else if (0 != ret) {
506 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
508 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
509 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
513 /* Success to connect */
516 /* Set service state */
517 vc_service_state_e previous_service_state;
518 vc_client_get_service_state(g_vc, &previous_service_state);
520 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
522 vc_service_state_changed_cb service_changed_callback = NULL;
523 void* user_data = NULL;
524 vc_client_get_service_state_changed_cb(g_vc, &service_changed_callback, &user_data);
526 if (NULL != service_changed_callback) {
527 vc_client_use_callback(g_vc);
528 service_changed_callback(previous_service_state, service_state, user_data);
529 vc_client_not_use_callback(g_vc);
530 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called"); //LCOV_EXCL_LINE
532 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null"); //LCOV_EXCL_LINE
535 /* Register focus handler */
536 ecore_thread_main_loop_begin();
537 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
538 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
539 ecore_thread_main_loop_end();
541 char appid[1024] = {'\0',};
542 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
544 int status = aul_app_get_status(appid);
545 if (STATUS_FOCUS == status) {
546 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); //LCOV_EXCL_LINE
547 ret = vc_dbus_set_foreground(getpid(), true);
549 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE
552 ret = vc_client_set_is_foreground(g_vc, true);
554 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret); //LCOV_EXCL_LINE
557 /* set authority valid */
558 vc_auth_state_e state = VC_AUTH_STATE_NONE;
559 if (0 != vc_client_get_auth_state(g_vc, &state)) {
560 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
562 if (VC_AUTH_STATE_INVALID == state) {
563 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
565 /* notify auth changed cb */
566 ecore_idler_add(__notify_auth_changed_cb, NULL);
570 vc_client_set_client_state(g_vc, VC_STATE_READY);
571 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
573 vc_client_set_mgr_pid(g_vc, mgr_pid);
575 SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] g_vc is not valid. It is destroyed."); //LCOV_EXCL_LINE
579 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
584 static void __start_prepare_thread(void *data, Ecore_Thread *thread)
586 SLOG(LOG_ERROR, TAG_VCC, "@@@ Start prepare thread");
587 int ret = -1, retry_count = 0;
591 if (retry_count == 10) {
592 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
596 ret = vc_dbus_request_hello();
598 SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
608 if (retry_count == 10) {
609 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!"); //LCOV_EXCL_LINE
612 ret = __vc_connect_daemon(NULL);
622 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
624 SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
629 if (0 != __vc_get_feature_enabled()) {
630 return VC_ERROR_NOT_SUPPORTED;
632 if (0 != __vc_check_privilege()) {
633 return VC_ERROR_PERMISSION_DENIED;
636 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
639 if (0 != vc_client_get_client_state(g_vc, &state)) {
640 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available"); //LCOV_EXCL_LINE
641 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
642 return VC_ERROR_INVALID_STATE;
646 if (state != VC_STATE_INITIALIZED) {
647 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'"); //LCOV_EXCL_LINE
648 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
649 return VC_ERROR_INVALID_STATE;
652 ecore_thread_run(__start_prepare_thread, __end_prepare_thread, NULL, NULL);
654 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
656 return VC_ERROR_NONE;
660 int vc_prepare_sync(void)
662 if (0 != __vc_get_feature_enabled()) {
663 return VC_ERROR_NOT_SUPPORTED;
665 if (0 != __vc_check_privilege()) {
666 return VC_ERROR_PERMISSION_DENIED;
669 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
672 if (0 != vc_client_get_client_state(g_vc, &state)) {
673 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
674 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
675 return VC_ERROR_INVALID_STATE;
679 if (state != VC_STATE_INITIALIZED) {
680 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'INITIALIZED'");
681 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
682 return VC_ERROR_INVALID_STATE;
686 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
690 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
692 if (VC_CONNECTION_RETRY_COUNT == cnt) {
693 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
694 return VC_ERROR_OPERATION_FAILED;
697 return VC_ERROR_NONE;
701 int vc_unprepare(void)
703 if (0 != __vc_get_feature_enabled()) {
704 return VC_ERROR_NOT_SUPPORTED;
706 if (0 != __vc_check_privilege()) {
707 return VC_ERROR_PERMISSION_DENIED;
710 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
713 if (0 != vc_client_get_client_state(g_vc, &state)) {
714 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
715 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
716 return VC_ERROR_INVALID_STATE;
720 if (state != VC_STATE_READY) {
721 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
722 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
723 return VC_ERROR_INVALID_STATE;
726 __vc_internal_unprepare();
728 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
729 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
731 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
733 return VC_ERROR_NONE;
736 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
738 if (0 != __vc_get_feature_enabled()) {
739 return VC_ERROR_NOT_SUPPORTED;
741 if (0 != __vc_check_privilege()) {
742 return VC_ERROR_PERMISSION_DENIED;
745 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
747 if (NULL == callback) {
748 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
749 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
750 return VC_ERROR_INVALID_PARAMETER;
754 if (0 != vc_client_get_client_state(g_vc, &state)) {
755 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
756 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
757 return VC_ERROR_INVALID_STATE;
761 ret = vc_config_mgr_get_language_list(callback, user_data);
763 ret = vc_config_convert_error_code((vc_config_error_e)ret);
764 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
767 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
769 return VC_ERROR_NONE;
773 int vc_get_current_language(char** language)
775 if (0 != __vc_get_feature_enabled()) {
776 return VC_ERROR_NOT_SUPPORTED;
778 if (0 != __vc_check_privilege()) {
779 return VC_ERROR_PERMISSION_DENIED;
782 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
784 if (NULL == language) {
785 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
786 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
787 return VC_ERROR_INVALID_PARAMETER;
791 if (0 != vc_client_get_client_state(g_vc, &state)) {
792 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
793 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
794 return VC_ERROR_INVALID_STATE;
798 ret = vc_config_mgr_get_default_language(language);
800 ret = vc_config_convert_error_code((vc_config_error_e)ret);
801 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
804 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
809 int vc_get_state(vc_state_e* state)
811 if (0 != __vc_get_feature_enabled()) {
812 return VC_ERROR_NOT_SUPPORTED;
814 if (0 != __vc_check_privilege()) {
815 return VC_ERROR_PERMISSION_DENIED;
818 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
821 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
822 return VC_ERROR_INVALID_PARAMETER;
826 if (0 != vc_client_get_client_state(g_vc, &temp)) {
827 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
828 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
829 return VC_ERROR_INVALID_STATE;
836 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
837 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
838 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
839 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
843 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
845 return VC_ERROR_NONE;
848 int vc_get_service_state(vc_service_state_e* state)
850 if (0 != __vc_get_feature_enabled()) {
851 return VC_ERROR_NOT_SUPPORTED;
853 if (0 != __vc_check_privilege()) {
854 return VC_ERROR_PERMISSION_DENIED;
857 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
860 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
861 return VC_ERROR_INVALID_PARAMETER;
865 if (0 != vc_client_get_client_state(g_vc, &temp)) {
866 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
867 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
868 return VC_ERROR_INVALID_STATE;
871 if (VC_STATE_READY != temp) {
872 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
873 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
874 return VC_ERROR_INVALID_STATE;
877 /* get service state */
878 vc_service_state_e service_state;
879 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
880 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state"); //LCOV_EXCL_LINE
881 return VC_ERROR_OPERATION_FAILED;
884 *state = service_state;
888 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
889 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
890 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
891 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
892 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
896 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
898 return VC_ERROR_NONE;
901 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
903 if (0 != __vc_get_feature_enabled()) {
904 return VC_ERROR_NOT_SUPPORTED;
906 if (0 != __vc_check_privilege()) {
907 return VC_ERROR_PERMISSION_DENIED;
910 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
912 if (NULL == vc_sys_cmd_list) {
913 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
914 return VC_ERROR_INVALID_PARAMETER;
918 if (0 != vc_client_get_client_state(g_vc, &state)) {
919 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
920 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
921 return VC_ERROR_INVALID_STATE;
925 if (state != VC_STATE_READY) {
926 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
927 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
928 return VC_ERROR_INVALID_STATE;
931 /* Check service state */
932 vc_service_state_e service_state = -1;
933 vc_client_get_service_state(g_vc, &service_state);
934 if (service_state != VC_SERVICE_STATE_READY) {
935 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
936 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
937 return VC_ERROR_INVALID_STATE;
940 bool is_sys_cmd_valid = false;
943 bool is_prepared = false;
945 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
948 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
949 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
950 if (0 == vc_prepare_sync()) {
952 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
954 } else if (VC_ERROR_TIMED_OUT != ret) {
955 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
958 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
961 if (VC_RETRY_COUNT == count) {
962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
971 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
973 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid"); //LCOV_EXCL_LINE
974 return VC_ERROR_OPERATION_FAILED;
977 vc_cmd_list_s* list = NULL;
978 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
979 if (true == is_sys_cmd_valid) {
980 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
982 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
985 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
987 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
990 *vc_sys_cmd_list = (vc_cmd_list_h)list;
992 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands"); //LCOV_EXCL_LINE
993 *vc_sys_cmd_list = NULL;
994 return VC_ERROR_NONE;
997 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1004 * @brief Checks whether the command format is supported.
1005 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
1007 * @param[in] format The command format
1008 * @param[out] support The result status @c true = supported, @c false = not supported
1010 * @return 0 on success, otherwise a negative error value
1011 * @retval #VC_ERROR_NONE Successful
1012 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1013 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
1014 * @retval #VC_ERROR_INVALID_STATE Invalid state
1016 * @pre The state should be #VC_STATE_READY.
1018 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
1020 if (0 != __vc_get_feature_enabled()) {
1021 return VC_ERROR_NOT_SUPPORTED;
1023 if (0 != __vc_check_privilege()) {
1024 return VC_ERROR_PERMISSION_DENIED;
1027 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
1030 if (0 != vc_client_get_client_state(g_vc, &state)) {
1031 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1032 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1033 return VC_ERROR_INVALID_STATE;
1037 bool non_fixed_support = false;
1038 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1039 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1043 case VC_CMD_FORMAT_FIXED: *support = true; break;
1044 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
1045 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
1046 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
1047 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
1048 default: *support = false; break;
1051 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1053 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1055 return VC_ERROR_NONE;
1059 static int __vc_get_invocation_name(char** invocation_name)
1061 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
1063 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name"); //LCOV_EXCL_LINE
1064 return ret; //LCOV_EXCL_LINE
1067 if (NULL == *invocation_name) {
1068 char* temp_label = NULL;
1072 ret = app_manager_get_app_id(getpid(), &appid);
1073 if (0 != ret || NULL == appid) {
1074 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret); //LCOV_EXCL_LINE
1075 if (NULL != appid) {
1079 return VC_ERROR_OPERATION_FAILED;
1082 ret = vc_get_current_language(&lang);
1083 if (0 != ret || NULL == lang) {
1084 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current language, ret(%d)", ret); //LCOV_EXCL_LINE
1091 return VC_ERROR_OPERATION_FAILED;
1094 ret = app_info_get_localed_label(appid, lang, &temp_label);
1095 if (0 != ret || NULL == temp_label) {
1096 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang); //LCOV_EXCL_LINE
1101 if (NULL != temp_label) {
1105 return VC_ERROR_OPERATION_FAILED;
1108 *invocation_name = strdup(temp_label);
1109 if (NULL == *invocation_name) {
1110 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
1111 return VC_ERROR_OUT_OF_MEMORY;
1122 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1123 return VC_ERROR_NONE;
1126 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1128 if (0 != __vc_get_feature_enabled()) {
1129 return VC_ERROR_NOT_SUPPORTED;
1131 if (0 != __vc_check_privilege()) {
1132 return VC_ERROR_PERMISSION_DENIED;
1135 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1137 if (NULL == vc_cmd_list) {
1138 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1139 return VC_ERROR_INVALID_PARAMETER;
1143 if (0 != vc_client_get_client_state(g_vc, &state)) {
1144 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1145 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1146 return VC_ERROR_INVALID_STATE;
1150 if (state != VC_STATE_READY) {
1151 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1152 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1153 return VC_ERROR_INVALID_STATE;
1157 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1158 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type); //LCOV_EXCL_LINE
1159 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1160 return VC_ERROR_INVALID_PARAMETER;
1163 vc_cmd_list_s* list = NULL;
1164 list = (vc_cmd_list_s*)vc_cmd_list;
1166 if (NULL == list->list) {
1167 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list"); //LCOV_EXCL_LINE
1168 return VC_ERROR_INVALID_PARAMETER;
1172 char* invocation_name = NULL;
1173 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1174 ret = __vc_get_invocation_name(&invocation_name);
1175 if (0 != ret || NULL == invocation_name) {
1176 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret); //LCOV_EXCL_LINE
1181 ret = vc_cmd_parser_delete_file(getpid(), type);
1183 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1185 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1187 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1190 bool is_prepared = false;
1192 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1195 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1196 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1197 if (0 == vc_prepare_sync()) {
1199 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1201 } else if (VC_ERROR_TIMED_OUT != ret) {
1202 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1205 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1208 if (VC_RETRY_COUNT == count) {
1209 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1218 if (NULL != invocation_name) {
1219 free(invocation_name);
1220 invocation_name = NULL;
1223 if (VC_COMMAND_TYPE_BACKGROUND == type)
1226 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1231 int vc_unset_command_list(int type)
1233 if (0 != __vc_get_feature_enabled()) {
1234 return VC_ERROR_NOT_SUPPORTED;
1236 if (0 != __vc_check_privilege()) {
1237 return VC_ERROR_PERMISSION_DENIED;
1240 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1243 if (0 != vc_client_get_client_state(g_vc, &state)) {
1244 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1245 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1246 return VC_ERROR_INVALID_STATE;
1250 if (state != VC_STATE_READY) {
1251 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1252 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1253 return VC_ERROR_INVALID_STATE;
1258 bool is_prepared = false;
1260 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1263 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1264 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1265 if (0 == vc_prepare_sync()) {
1267 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1269 } else if (VC_ERROR_TIMED_OUT != ret) {
1270 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1273 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1276 if (VC_RETRY_COUNT == count) {
1277 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1285 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1287 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1288 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret)); //LCOV_EXCL_LINE
1291 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1297 int vc_set_command_list_from_file(const char* file_path, int type)
1299 if (0 != __vc_get_feature_enabled()) {
1300 return VC_ERROR_NOT_SUPPORTED;
1302 if (0 != __vc_check_privilege()) {
1303 return VC_ERROR_PERMISSION_DENIED;
1306 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1309 if (0 != vc_client_get_client_state(g_vc, &state)) {
1310 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1311 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1312 return VC_ERROR_INVALID_STATE;
1316 if (state != VC_STATE_READY) {
1317 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1318 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1319 return VC_ERROR_INVALID_STATE;
1323 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1324 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1325 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1326 return VC_ERROR_INVALID_PARAMETER;
1330 char* invocation_name = NULL;
1331 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1332 ret = __vc_get_invocation_name(&invocation_name);
1333 if (0 != ret || NULL == invocation_name) {
1334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1339 ret = vc_cmd_parser_delete_file(getpid(), type);
1341 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1343 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1345 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1348 bool is_prepared = false;
1350 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1353 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1354 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1355 if (0 == vc_prepare_sync()) {
1357 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1359 } else if (VC_ERROR_TIMED_OUT != ret) {
1360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1363 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1366 if (VC_RETRY_COUNT == count) {
1367 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1376 if (NULL != invocation_name) {
1377 free(invocation_name);
1378 invocation_name = NULL;
1381 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1387 int vc_get_exclusive_command_option(bool* value)
1389 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1392 if (0 != vc_client_get_client_state(g_vc, &state)) {
1393 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1394 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1395 return VC_ERROR_INVALID_STATE;
1399 if (state != VC_STATE_READY) {
1400 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1401 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1402 return VC_ERROR_INVALID_STATE;
1405 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1407 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1408 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1412 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1417 int vc_set_exclusive_command_option(bool value)
1419 if (0 != __vc_get_feature_enabled()) {
1420 return VC_ERROR_NOT_SUPPORTED;
1422 if (0 != __vc_check_privilege()) {
1423 return VC_ERROR_PERMISSION_DENIED;
1426 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1429 if (0 != vc_client_get_client_state(g_vc, &state)) {
1430 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1431 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1432 return VC_ERROR_INVALID_STATE;
1436 if (state != VC_STATE_READY) {
1437 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1438 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1439 return VC_ERROR_INVALID_STATE;
1442 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1444 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1445 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1451 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1453 if (VC_ERROR_TIMED_OUT != ret) {
1454 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1457 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1460 if (VC_RETRY_COUNT == count) {
1461 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1468 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1475 int vc_request_start(bool stop_by_silence)
1477 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1480 if (0 != vc_client_get_client_state(g_vc, &state)) {
1481 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1482 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1483 return VC_ERROR_INVALID_STATE;
1487 if (state != VC_STATE_READY) {
1488 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1489 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1490 return VC_ERROR_INVALID_STATE;
1493 /* Check service state */
1494 vc_service_state_e service_state = -1;
1495 vc_client_get_service_state(g_vc, &service_state);
1496 if (service_state != VC_SERVICE_STATE_READY) {
1497 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1498 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1499 return VC_ERROR_INVALID_STATE;
1509 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1511 if (VC_ERROR_TIMED_OUT != ret) {
1512 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1515 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1518 if (VC_RETRY_COUNT == count) {
1519 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1524 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1528 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1533 int vc_request_stop(void)
1535 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1538 if (0 != vc_client_get_client_state(g_vc, &state)) {
1539 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1540 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1541 return VC_ERROR_INVALID_STATE;
1545 if (state != VC_STATE_READY) {
1546 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1547 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1548 return VC_ERROR_INVALID_STATE;
1551 /* Check service state */
1552 vc_service_state_e service_state = -1;
1553 vc_client_get_service_state(g_vc, &service_state);
1554 if (service_state != VC_SERVICE_STATE_RECORDING) {
1555 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1556 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1557 return VC_ERROR_INVALID_STATE;
1564 ret = vc_dbus_request_stop(g_vc->handle);
1566 if (VC_ERROR_TIMED_OUT != ret) {
1567 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1570 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1573 if (VC_RETRY_COUNT == count) {
1574 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1579 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1583 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1588 int vc_request_cancel(void)
1590 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1593 if (0 != vc_client_get_client_state(g_vc, &state)) {
1594 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1595 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1596 return VC_ERROR_INVALID_STATE;
1600 if (state != VC_STATE_READY) {
1601 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1602 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1603 return VC_ERROR_INVALID_STATE;
1606 /* Check service state */
1607 vc_service_state_e service_state = -1;
1608 vc_client_get_service_state(g_vc, &service_state);
1609 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1610 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1611 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1612 return VC_ERROR_INVALID_STATE;
1618 ret = vc_dbus_request_cancel(g_vc->handle);
1620 if (VC_ERROR_TIMED_OUT != ret) {
1621 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1624 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1627 if (VC_RETRY_COUNT == count) {
1628 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1633 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1637 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1644 static void __vc_notify_error(void *data)
1646 vc_h vc = (vc_h)data;
1648 vc_error_cb callback = NULL;
1652 vc_client_get_error_cb(vc, &callback, &user_data);
1653 vc_client_get_error(vc, &reason);
1655 if (NULL != callback) {
1656 vc_client_use_callback(vc);
1657 callback(reason, user_data);
1658 vc_client_not_use_callback(vc);
1659 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1661 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1665 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1668 if (0 != vc_client_get_client_state(g_vc, &state)) {
1669 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1674 if (state != VC_STATE_READY) {
1675 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] State is not READY");
1676 if (VC_ERROR_SERVICE_RESET != reason) {
1677 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1683 if (VC_ERROR_SERVICE_RESET == reason) {
1684 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1686 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1687 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
1689 if (0 != vc_prepare()) {
1690 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1694 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1696 vc_client_set_error(g_vc, reason);
1697 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
1702 static void __vc_notify_state_changed(void *data)
1704 vc_h vc = (vc_h)data;
1706 vc_state_changed_cb changed_callback = NULL;
1709 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1711 vc_state_e current_state;
1712 vc_state_e before_state;
1714 vc_client_get_before_state(vc, ¤t_state, &before_state);
1716 if (NULL != changed_callback) {
1717 vc_client_use_callback(vc);
1718 changed_callback(before_state, current_state, user_data);
1719 vc_client_not_use_callback(vc);
1720 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1722 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1726 static Eina_Bool __vc_notify_result(void *data)
1730 vc_cmd_list_h vc_cmd_list = NULL;
1732 vc_result_cb callback = NULL;
1733 void* user_data = NULL;
1735 vc_client_get_result_cb(g_vc, &callback, &user_data);
1737 if (NULL == callback) {
1738 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1742 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1743 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1747 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1749 SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1751 vc_cmd_print_list(vc_cmd_list);
1753 vc_client_use_callback(g_vc);
1754 callback(event, vc_cmd_list, temp_text, user_data);
1755 vc_client_not_use_callback(g_vc);
1757 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1759 vc_cmd_list_destroy(vc_cmd_list, true);
1761 /* Release result */
1762 if (NULL != temp_text) free(temp_text);
1767 void __vc_cb_result(void)
1769 ecore_timer_add(0, __vc_notify_result, NULL);
1775 int vc_get_result(vc_result_cb callback, void* user_data)
1777 if (0 != __vc_get_feature_enabled()) {
1778 return VC_ERROR_NOT_SUPPORTED;
1780 if (0 != __vc_check_privilege()) {
1781 return VC_ERROR_PERMISSION_DENIED;
1784 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1787 if (0 != vc_client_get_client_state(g_vc, &state)) {
1788 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1789 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1790 return VC_ERROR_INVALID_STATE;
1794 if (state != VC_STATE_READY) {
1795 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1796 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
1797 return VC_ERROR_INVALID_STATE;
1800 if (NULL == callback) {
1801 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL"); //LCOV_EXCL_LINE
1802 return VC_ERROR_INVALID_PARAMETER;
1805 char* temp_text = NULL;
1807 vc_cmd_list_h vc_cmd_list = NULL;
1809 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1810 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1811 return VC_ERROR_INVALID_PARAMETER;
1814 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1815 if (0 != ret || NULL == temp_text) {
1816 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text); //LCOV_EXCL_LINE
1820 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event); //LCOV_EXCL_LINE
1822 vc_cmd_print_list(vc_cmd_list);
1824 vc_client_use_callback(g_vc);
1825 callback(event, vc_cmd_list, temp_text, user_data);
1826 vc_client_not_use_callback(g_vc);
1828 vc_cmd_list_destroy(vc_cmd_list, true);
1830 /* Release result */
1831 if (NULL != temp_text) {
1836 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1838 return VC_ERROR_NONE;
1841 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1843 if (0 != __vc_get_feature_enabled()) {
1844 return VC_ERROR_NOT_SUPPORTED;
1846 if (0 != __vc_check_privilege()) {
1847 return VC_ERROR_PERMISSION_DENIED;
1850 if (NULL == callback)
1851 return VC_ERROR_INVALID_PARAMETER;
1854 if (0 != vc_client_get_client_state(g_vc, &state)) {
1855 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1856 return VC_ERROR_INVALID_STATE;
1860 if (state != VC_STATE_INITIALIZED) {
1861 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1862 return VC_ERROR_INVALID_STATE;
1865 vc_client_set_result_cb(g_vc, callback, user_data);
1870 int vc_unset_result_cb(void)
1872 if (0 != __vc_get_feature_enabled()) {
1873 return VC_ERROR_NOT_SUPPORTED;
1875 if (0 != __vc_check_privilege()) {
1876 return VC_ERROR_PERMISSION_DENIED;
1880 if (0 != vc_client_get_client_state(g_vc, &state)) {
1881 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1882 return VC_ERROR_INVALID_STATE;
1886 if (state != VC_STATE_INITIALIZED) {
1887 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1888 return VC_ERROR_INVALID_STATE;
1891 vc_client_set_result_cb(g_vc, NULL, NULL);
1897 int __vc_cb_service_state(int state)
1899 vc_service_state_e current_state = (vc_service_state_e)state;
1900 vc_service_state_e before_state;
1901 vc_client_get_service_state(g_vc, &before_state);
1903 if (current_state == before_state) {
1907 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1908 before_state, current_state);
1910 /* Save service state */
1911 vc_client_set_service_state(g_vc, current_state);
1913 vc_service_state_changed_cb callback = NULL;
1914 void* service_user_data;
1915 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1917 if (NULL != callback) {
1918 vc_client_use_callback(g_vc);
1919 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1920 vc_client_not_use_callback(g_vc);
1921 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1923 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1930 int __vc_cb_manager_pid(int manager_pid)
1932 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
1934 /* Save service state */
1935 vc_client_set_mgr_pid(g_vc, manager_pid);
1940 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1942 if (0 != __vc_get_feature_enabled()) {
1943 return VC_ERROR_NOT_SUPPORTED;
1945 if (0 != __vc_check_privilege()) {
1946 return VC_ERROR_PERMISSION_DENIED;
1949 if (NULL == callback)
1950 return VC_ERROR_INVALID_PARAMETER;
1953 if (0 != vc_client_get_client_state(g_vc, &state)) {
1954 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1955 return VC_ERROR_INVALID_STATE;
1959 if (state != VC_STATE_INITIALIZED) {
1960 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1961 return VC_ERROR_INVALID_STATE;
1964 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1969 int vc_unset_service_state_changed_cb(void)
1971 if (0 != __vc_get_feature_enabled()) {
1972 return VC_ERROR_NOT_SUPPORTED;
1974 if (0 != __vc_check_privilege()) {
1975 return VC_ERROR_PERMISSION_DENIED;
1979 if (0 != vc_client_get_client_state(g_vc, &state)) {
1980 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1981 return VC_ERROR_INVALID_STATE;
1985 if (state != VC_STATE_INITIALIZED) {
1986 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1987 return VC_ERROR_INVALID_STATE;
1990 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1995 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1997 if (0 != __vc_get_feature_enabled()) {
1998 return VC_ERROR_NOT_SUPPORTED;
2000 if (0 != __vc_check_privilege()) {
2001 return VC_ERROR_PERMISSION_DENIED;
2004 if (callback == NULL)
2005 return VC_ERROR_INVALID_PARAMETER;
2008 if (0 != vc_client_get_client_state(g_vc, &state)) {
2009 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
2010 return VC_ERROR_INVALID_STATE;
2014 if (state != VC_STATE_INITIALIZED) {
2015 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2016 return VC_ERROR_INVALID_STATE;
2019 vc_client_set_state_changed_cb(g_vc, callback, user_data);
2024 int vc_unset_state_changed_cb(void)
2026 if (0 != __vc_get_feature_enabled()) {
2027 return VC_ERROR_NOT_SUPPORTED;
2029 if (0 != __vc_check_privilege()) {
2030 return VC_ERROR_PERMISSION_DENIED;
2034 if (0 != vc_client_get_client_state(g_vc, &state)) {
2035 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
2036 return VC_ERROR_INVALID_STATE;
2040 if (state != VC_STATE_INITIALIZED) {
2041 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2042 return VC_ERROR_INVALID_STATE;
2045 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
2050 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2052 if (0 != __vc_get_feature_enabled()) {
2053 return VC_ERROR_NOT_SUPPORTED;
2055 if (0 != __vc_check_privilege()) {
2056 return VC_ERROR_PERMISSION_DENIED;
2059 if (NULL == callback)
2060 return VC_ERROR_INVALID_PARAMETER;
2063 if (0 != vc_client_get_client_state(g_vc, &state)) {
2064 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
2065 return VC_ERROR_INVALID_STATE;
2069 if (state != VC_STATE_INITIALIZED) {
2070 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
2071 return VC_ERROR_INVALID_STATE;
2074 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2079 int vc_unset_current_language_changed_cb(void)
2081 if (0 != __vc_get_feature_enabled()) {
2082 return VC_ERROR_NOT_SUPPORTED;
2084 if (0 != __vc_check_privilege()) {
2085 return VC_ERROR_PERMISSION_DENIED;
2089 if (0 != vc_client_get_client_state(g_vc, &state)) {
2090 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2091 return VC_ERROR_INVALID_STATE;
2095 if (state != VC_STATE_INITIALIZED) {
2096 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2097 return VC_ERROR_INVALID_STATE;
2100 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2105 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2107 if (0 != __vc_get_feature_enabled()) {
2108 return VC_ERROR_NOT_SUPPORTED;
2110 if (0 != __vc_check_privilege()) {
2111 return VC_ERROR_PERMISSION_DENIED;
2114 if (NULL == callback)
2115 return VC_ERROR_INVALID_PARAMETER;
2118 if (0 != vc_client_get_client_state(g_vc, &state)) {
2119 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2120 return VC_ERROR_INVALID_STATE;
2124 if (state != VC_STATE_INITIALIZED) {
2125 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
2126 return VC_ERROR_INVALID_STATE;
2129 vc_client_set_error_cb(g_vc, callback, user_data);
2134 int vc_unset_error_cb(void)
2136 if (0 != __vc_get_feature_enabled()) {
2137 return VC_ERROR_NOT_SUPPORTED;
2139 if (0 != __vc_check_privilege()) {
2140 return VC_ERROR_PERMISSION_DENIED;
2144 if (0 != vc_client_get_client_state(g_vc, &state)) {
2145 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2146 return VC_ERROR_INVALID_STATE;
2150 if (state != VC_STATE_INITIALIZED) {
2151 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2152 return VC_ERROR_INVALID_STATE;
2155 vc_client_set_error_cb(g_vc, NULL, NULL);
2160 int vc_set_invocation_name(const char* name)
2162 if (0 != __vc_get_feature_enabled()) {
2163 return VC_ERROR_NOT_SUPPORTED;
2165 if (0 != __vc_check_privilege()) {
2166 return VC_ERROR_PERMISSION_DENIED;
2170 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2172 int ret = vc_client_get_client_state(g_vc, &state);
2174 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2175 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2180 if (state != VC_STATE_READY) {
2181 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2182 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2183 return VC_ERROR_INVALID_STATE;
2186 ret = vc_client_set_invocation_name(g_vc, name);
2188 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2194 int vc_set_server_dialog(const char* app_id, const char* credential)
2199 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2200 if (0 != __vc_get_feature_enabled()) {
2201 return VC_ERROR_NOT_SUPPORTED;
2203 if (0 != __vc_check_privilege()) {
2204 return VC_ERROR_PERMISSION_DENIED;
2207 if (NULL == credential) {
2208 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Credential is NULL");
2209 return VC_ERROR_INVALID_PARAMETER;
2212 if (0 != vc_client_get_client_state(g_vc, &state)) {
2213 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2214 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2215 return VC_ERROR_INVALID_STATE;
2219 if (state != VC_STATE_READY) {
2220 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2221 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2222 return VC_ERROR_INVALID_STATE;
2225 /* Check service state */
2226 vc_service_state_e service_state = -1;
2227 vc_client_get_service_state(g_vc, &service_state);
2228 if (service_state != VC_SERVICE_STATE_READY) {
2229 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2230 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2231 return VC_ERROR_INVALID_STATE;
2234 char* tmp_appid = NULL;
2235 if (NULL == app_id) {
2236 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2237 if (0 != ret || NULL == tmp_appid) {
2238 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2239 if (NULL != tmp_appid)
2241 return VC_ERROR_INVALID_PARAMETER;
2244 tmp_appid = strdup(app_id);
2248 SLOG(LOG_DEBUG, TAG_VCC, "Set server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2251 bool is_prepared = false;
2253 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2255 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2256 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2257 if (0 == vc_prepare_sync()) {
2259 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2261 } else if (VC_ERROR_TIMED_OUT != ret) {
2262 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set server dialog to vc service : %s", __vc_get_error_code(ret));
2265 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set server dialog : %s", __vc_get_error_code(ret));
2268 if (VC_RETRY_COUNT == count) {
2269 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2277 if (NULL != tmp_appid)
2280 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2285 int vc_unset_server_dialog(const char* app_id)
2290 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2291 if (0 != __vc_get_feature_enabled()) {
2292 return VC_ERROR_NOT_SUPPORTED;
2294 if (0 != __vc_check_privilege()) {
2295 return VC_ERROR_PERMISSION_DENIED;
2298 if (0 != vc_client_get_client_state(g_vc, &state)) {
2299 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2300 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2301 return VC_ERROR_INVALID_STATE;
2305 if (state != VC_STATE_READY) {
2306 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2307 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2308 return VC_ERROR_INVALID_STATE;
2311 /* Check service state */
2312 vc_service_state_e service_state = -1;
2313 vc_client_get_service_state(g_vc, &service_state);
2314 if (service_state != VC_SERVICE_STATE_READY) {
2315 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2316 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2317 return VC_ERROR_INVALID_STATE;
2320 char* tmp_appid = NULL;
2321 if (NULL == app_id) {
2322 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2323 if (0 != ret || NULL == tmp_appid) {
2324 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2325 if (NULL != tmp_appid)
2327 return VC_ERROR_INVALID_PARAMETER;
2330 tmp_appid = strdup(app_id);
2334 SLOG(LOG_DEBUG, TAG_VCC, "Unset server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2337 bool is_prepared = false;
2338 char* credential = strdup("#NULL");
2340 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2342 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2343 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2344 if (0 == vc_prepare_sync()) {
2346 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2348 } else if (VC_ERROR_TIMED_OUT != ret) {
2349 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset server dialog to vc service : %s", __vc_get_error_code(ret));
2352 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset server dialog : %s", __vc_get_error_code(ret));
2355 if (VC_RETRY_COUNT == count) {
2356 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2364 if (NULL != tmp_appid)
2366 if (NULL != credential)
2369 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2375 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2379 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2380 if (0 != __vc_get_feature_enabled()) {
2381 return VC_ERROR_NOT_SUPPORTED;
2383 if (0 != __vc_check_privilege()) {
2384 return VC_ERROR_PERMISSION_DENIED;
2387 if (0 != vc_client_get_client_state(g_vc, &state)) {
2388 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2389 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2390 return VC_ERROR_INVALID_STATE;
2394 if (state != VC_STATE_READY) {
2395 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
2396 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2397 return VC_ERROR_INVALID_STATE;
2400 /* Check service state */
2401 vc_service_state_e service_state = -1;
2402 vc_client_get_service_state(g_vc, &service_state);
2403 if (service_state != VC_SERVICE_STATE_READY) {
2404 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
2405 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2406 return VC_ERROR_INVALID_STATE;
2409 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);
2410 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2412 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret);
2413 return VC_ERROR_OPERATION_FAILED;
2416 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2418 return VC_ERROR_NONE;
2423 int vc_auth_enable(void)
2427 if (0 != vc_client_get_client_state(g_vc, &state)) {
2428 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2429 return VC_ERROR_INVALID_STATE;
2432 if (VC_STATE_READY != state) {
2433 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2434 return VC_ERROR_INVALID_STATE;
2437 /* check already authority */
2438 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2439 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2440 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2441 return VC_ERROR_INVALID_STATE;
2444 if (VC_AUTH_STATE_NONE != auth_state) {
2445 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2446 return VC_ERROR_INVALID_STATE;
2449 /* request authority */
2451 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2452 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2453 return VC_ERROR_OPERATION_FAILED;
2456 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2457 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2458 return VC_ERROR_OPERATION_FAILED;
2461 /* set authority into handle */
2462 bool is_foreground = false;
2463 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2464 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2465 return VC_ERROR_OPERATION_FAILED;
2468 if (is_foreground) {
2469 auth_state = VC_AUTH_STATE_VALID;
2471 auth_state = VC_AUTH_STATE_INVALID;
2474 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2475 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2476 return VC_ERROR_OPERATION_FAILED;
2479 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2481 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2483 return VC_ERROR_NONE;
2486 int vc_auth_disable(void)
2490 if (0 != vc_client_get_client_state(g_vc, &state)) {
2491 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2492 return VC_ERROR_INVALID_STATE;
2495 if (VC_STATE_READY != state) {
2496 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2497 return VC_ERROR_INVALID_STATE;
2500 /* check authority */
2501 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2502 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2503 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2504 return VC_ERROR_INVALID_STATE;
2507 if (VC_AUTH_STATE_NONE == auth_state) {
2508 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2509 return VC_ERROR_INVALID_STATE;
2512 if (0 != vc_auth_unset_state_changed_cb()) {
2513 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2516 /* request return authority by dbus */
2518 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2519 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2520 return VC_ERROR_OPERATION_FAILED;
2523 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2524 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
2525 return VC_ERROR_OPERATION_FAILED;
2528 /* unset authority from handle */
2529 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2530 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2531 return VC_ERROR_OPERATION_FAILED;
2534 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2536 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2538 return VC_ERROR_NONE;
2541 int vc_auth_get_state(vc_auth_state_e* state)
2544 vc_state_e vc_state;
2545 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2546 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2547 return VC_ERROR_INVALID_STATE;
2550 if (VC_STATE_READY != vc_state) {
2551 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2552 return VC_ERROR_INVALID_STATE;
2556 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2557 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2558 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2559 return VC_ERROR_INVALID_STATE;
2564 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2566 return VC_ERROR_NONE;
2569 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2571 /* check parameter */
2572 if (NULL == callback) {
2573 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2574 return VC_ERROR_INVALID_PARAMETER;
2578 vc_auth_state_e auth_state;
2579 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2580 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2581 return VC_ERROR_INVALID_STATE;
2584 if (VC_AUTH_STATE_NONE == auth_state) {
2585 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2586 return VC_ERROR_INVALID_STATE;
2589 /* set cb into handle */
2590 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2591 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2592 return VC_ERROR_OPERATION_FAILED;
2595 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2597 return VC_ERROR_NONE;
2600 int vc_auth_unset_state_changed_cb(void)
2603 vc_auth_state_e auth_state;
2604 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2605 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2606 return VC_ERROR_INVALID_STATE;
2609 if (VC_AUTH_STATE_NONE == auth_state) {
2610 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2611 return VC_ERROR_INVALID_STATE;
2614 /* unset cb from handle */
2615 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2616 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2617 return VC_ERROR_OPERATION_FAILED;
2620 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2622 return VC_ERROR_NONE;
2625 int vc_auth_start(void)
2627 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2630 if (0 != vc_client_get_client_state(g_vc, &state)) {
2631 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2632 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2633 return VC_ERROR_INVALID_STATE;
2637 if (state != VC_STATE_READY) {
2638 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2639 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2640 return VC_ERROR_INVALID_STATE;
2643 /* Check service state */
2644 vc_service_state_e service_state = -1;
2645 vc_client_get_service_state(g_vc, &service_state);
2646 if (service_state != VC_SERVICE_STATE_READY) {
2647 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2648 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2649 return VC_ERROR_INVALID_STATE;
2652 /* Check authority */
2653 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2654 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2655 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2656 return VC_ERROR_OPERATION_FAILED;
2659 if (VC_AUTH_STATE_VALID != auth_state) {
2660 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2661 return VC_ERROR_OPERATION_FAILED;
2666 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2667 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2668 return VC_ERROR_OPERATION_FAILED;
2673 bool is_prepared = false;
2676 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2678 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2679 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2680 if (0 == vc_prepare_sync()) {
2682 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2684 } else if (VC_ERROR_TIMED_OUT != ret) {
2685 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2688 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2691 if (VC_RETRY_COUNT == count) {
2692 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2697 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2701 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2706 int vc_auth_stop(void)
2708 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2711 if (0 != vc_client_get_client_state(g_vc, &state)) {
2712 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2713 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2714 return VC_ERROR_INVALID_STATE;
2718 if (state != VC_STATE_READY) {
2719 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2720 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2721 return VC_ERROR_INVALID_STATE;
2724 /* Check service state */
2725 vc_service_state_e service_state = -1;
2726 vc_client_get_service_state(g_vc, &service_state);
2727 if (service_state != VC_SERVICE_STATE_RECORDING) {
2728 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2729 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2730 return VC_ERROR_INVALID_STATE;
2733 /* Check authority */
2734 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2735 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2736 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2737 return VC_ERROR_OPERATION_FAILED;
2740 if (VC_AUTH_STATE_VALID != auth_state) {
2741 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2742 return VC_ERROR_OPERATION_FAILED;
2747 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2748 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2749 return VC_ERROR_OPERATION_FAILED;
2754 bool is_prepared = false;
2757 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2759 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2760 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2761 if (0 == vc_prepare_sync()) {
2763 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2765 } else if (VC_ERROR_TIMED_OUT != ret) {
2766 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2769 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2772 if (VC_RETRY_COUNT == count) {
2773 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2778 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2782 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2787 int vc_auth_cancel(void)
2789 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2792 if (0 != vc_client_get_client_state(g_vc, &state)) {
2793 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2794 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2795 return VC_ERROR_INVALID_STATE;
2799 if (state != VC_STATE_READY) {
2800 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2801 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2802 return VC_ERROR_INVALID_STATE;
2805 /* Check service state */
2806 vc_service_state_e service_state = -1;
2807 vc_client_get_service_state(g_vc, &service_state);
2808 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2809 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2810 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2811 return VC_ERROR_INVALID_STATE;
2814 /* Check authority */
2815 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2816 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2817 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2818 return VC_ERROR_OPERATION_FAILED;
2821 if (VC_AUTH_STATE_VALID != auth_state) {
2822 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2823 return VC_ERROR_OPERATION_FAILED;
2828 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2829 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2830 return VC_ERROR_OPERATION_FAILED;
2835 bool is_prepared = false;
2837 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2839 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2840 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2841 if (0 == vc_prepare_sync()) {
2843 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2845 } else if (VC_ERROR_TIMED_OUT != ret) {
2846 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2849 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2852 if (VC_RETRY_COUNT == count) {
2853 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2858 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2862 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2868 static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
2870 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Start tts streaming thread");
2872 vc_tts_data_s* tts_data = NULL;
2873 vc_tts_streaming_cb callback = NULL;
2874 void* user_data = NULL;
2876 vc_client_get_tts_streaming_cb(g_vc, &callback, &user_data);
2877 if (NULL == callback) {
2878 SLOG(LOG_WARN, TAG_VCC, "[WARNING] tts streaming callback is null");
2887 ret = vc_data_get_tts_data(&tts_data);
2888 if (0 != ret || NULL == tts_data) {
2890 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] No tts data. Waiting mode");
2895 if (0 < vc_data_get_tts_data_size()) {
2896 SLOG(LOG_INFO, TAG_VCC, "[INFO] Resume thread");
2900 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Wrong request, there's no pcm data");
2905 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish to wait for new tts data come");
2907 /* resume tts thread */
2911 SLOG(LOG_DEBUG, TAG_VCC, "tts streaming callback is called");
2912 vc_client_use_callback(g_vc);
2913 callback(tts_data->event, tts_data->data, tts_data->data_size, tts_data->utt_id, user_data);
2914 vc_client_not_use_callback(g_vc);
2916 /* If no tts data and EVENT_FINISH */
2917 if (0 >= vc_data_get_tts_data_size() && VC_TTS_EVENT_FINISH == tts_data->event) {
2918 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish tts");
2924 static void __end_tts_streaming_thread(void* data, Ecore_Thread* thread)
2926 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] End tts streaming thread");
2927 g_tts_thread = NULL;
2930 int __vc_cb_tts_streaming(int utt_id, vc_tts_event_e event, char* buffer, int len)
2933 vc_tts_data_s* temp_tts_data = NULL;
2934 temp_tts_data = (vc_tts_data_s*)calloc(1, sizeof(vc_tts_data_s));
2935 if (NULL == temp_tts_data) {
2936 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Out of memory");
2937 return VC_ERROR_OUT_OF_MEMORY;
2940 temp_tts_data->data = NULL;
2941 temp_tts_data->data_size = 0;
2944 temp_tts_data->data = (char*)calloc(len + 5, sizeof(char));
2945 if (NULL != temp_tts_data->data) {
2946 memcpy(temp_tts_data->data, buffer, len);
2947 temp_tts_data->data_size = len;
2948 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG][memcpy] data(%p) size(%d)",
2949 temp_tts_data->data, temp_tts_data->data_size);
2951 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to allocate memory");
2954 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] tts data is NULL");
2957 temp_tts_data->utt_id = utt_id;
2958 temp_tts_data->event = event;
2960 int ret = vc_data_add_tts_data(temp_tts_data);
2962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to add tts data");
2963 if (NULL != temp_tts_data->data) {
2964 free(temp_tts_data->data);
2965 temp_tts_data->data = NULL;
2967 if (NULL != temp_tts_data) {
2968 free(temp_tts_data);
2969 temp_tts_data = NULL;
2973 bool is_canceled = ecore_thread_check(g_tts_thread);
2974 if (NULL == g_tts_thread || TRUE == is_canceled) {
2975 SLOG(LOG_INFO, TAG_VCC, "ecore thread run : __start_tts_streaming_thread ");
2976 g_tts_thread = ecore_thread_run(__start_tts_streaming_thread, __end_tts_streaming_thread, NULL, NULL);
2982 int vc_tts_request(const char* text, const char* language, bool to_vcm, int* utt_id)
2988 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request tts");
2990 if (0 != __vc_get_feature_enabled()) {
2991 return VC_ERROR_NOT_SUPPORTED;
2993 if (0 != __vc_check_privilege()) {
2994 return VC_ERROR_PERMISSION_DENIED;
2997 if (0 != vc_client_get_client_state(g_vc, &state)) {
2998 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2999 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3000 return VC_ERROR_INVALID_STATE;
3004 if (state != VC_STATE_READY) {
3005 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3006 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3007 return VC_ERROR_INVALID_STATE;
3010 /* Check service state */
3011 vc_service_state_e service_state = -1;
3012 vc_client_get_service_state(g_vc, &service_state);
3013 if (service_state != VC_SERVICE_STATE_READY) {
3014 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3015 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3016 return VC_ERROR_INVALID_STATE;
3019 SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts request, pid(%d), text(%s), language(%s), to_vcm(%d)", pid, text, language, to_vcm);
3022 bool is_prepared = false;
3024 ret = vc_dbus_request_tts(pid, text, language, to_vcm, utt_id);
3026 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3027 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3028 if (0 == vc_prepare_sync()) {
3030 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3032 } else if (VC_ERROR_TIMED_OUT != ret) {
3033 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request tts to vc service : %s", __vc_get_error_code(ret));
3036 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request tts : %s", __vc_get_error_code(ret));
3039 if (VC_RETRY_COUNT == count) {
3040 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
3047 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3052 int vc_tts_cancel(int utt_id)
3058 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Cancel tts");
3060 if (0 != __vc_get_feature_enabled()) {
3061 return VC_ERROR_NOT_SUPPORTED;
3063 if (0 != __vc_check_privilege()) {
3064 return VC_ERROR_PERMISSION_DENIED;
3067 if (0 != vc_client_get_client_state(g_vc, &state)) {
3068 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3069 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3070 return VC_ERROR_INVALID_STATE;
3074 if (state != VC_STATE_READY) {
3075 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3076 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3077 return VC_ERROR_INVALID_STATE;
3080 /* Check service state */
3081 vc_service_state_e service_state = -1;
3082 vc_client_get_service_state(g_vc, &service_state);
3083 if (service_state != VC_SERVICE_STATE_READY) {
3084 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3085 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3086 return VC_ERROR_INVALID_STATE;
3089 SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts cancel, pid(%d), utt_id(%d)", pid, utt_id);
3091 ret = vc_data_clear_tts_data_by_uttid(utt_id);
3093 SLOG(LOG_INFO, TAG_VCC, "[INFO] There's no data in client pcm queue");
3097 bool is_prepared = false;
3099 ret = vc_dbus_cancel_tts(pid, utt_id);
3101 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3102 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3103 if (0 == vc_prepare_sync()) {
3105 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3107 } else if (VC_ERROR_TIMED_OUT != ret) {
3108 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel tts to vc service : %s", __vc_get_error_code(ret));
3111 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel tts : %s", __vc_get_error_code(ret));
3114 if (VC_RETRY_COUNT == count) {
3115 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel");
3122 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3127 int vc_tts_get_audio_format(int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type)
3133 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get tts audio format");
3135 if (0 != __vc_get_feature_enabled()) {
3136 return VC_ERROR_NOT_SUPPORTED;
3138 if (0 != __vc_check_privilege()) {
3139 return VC_ERROR_PERMISSION_DENIED;
3142 if (0 != vc_client_get_client_state(g_vc, &state)) {
3143 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3144 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3145 return VC_ERROR_INVALID_STATE;
3149 if (state != VC_STATE_READY) {
3150 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3151 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3152 return VC_ERROR_INVALID_STATE;
3155 /* Check service state */
3156 vc_service_state_e service_state = -1;
3157 vc_client_get_service_state(g_vc, &service_state);
3158 if (service_state != VC_SERVICE_STATE_READY) {
3159 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3160 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3161 return VC_ERROR_INVALID_STATE;
3164 SLOG(LOG_DEBUG, TAG_VCC, "@@@ get tts audio format, pid(%d)", pid);
3167 bool is_prepared = false;
3169 ret = vc_dbus_get_tts_audio_format(pid, rate, channel, audio_type);
3171 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3172 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3173 if (0 == vc_prepare_sync()) {
3175 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3177 } else if (VC_ERROR_TIMED_OUT != ret) {
3178 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format : %s", __vc_get_error_code(ret));
3181 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to get tts audio format : %s", __vc_get_error_code(ret));
3184 if (VC_RETRY_COUNT == count) {
3185 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format");
3192 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3197 int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
3199 if (0 != __vc_get_feature_enabled()) {
3200 return VC_ERROR_NOT_SUPPORTED;
3202 if (0 != __vc_check_privilege()) {
3203 return VC_ERROR_PERMISSION_DENIED;
3206 if (NULL == callback)
3207 return VC_ERROR_INVALID_PARAMETER;
3210 if (0 != vc_client_get_client_state(g_vc, &state)) {
3211 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : A handle is not available");
3212 return VC_ERROR_INVALID_STATE;
3216 if (state != VC_STATE_INITIALIZED) {
3217 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : Current state(%d) is not 'Initialized'", state);
3218 return VC_ERROR_INVALID_STATE;
3221 vc_client_set_tts_streaming_cb(g_vc, callback, user_data);
3226 int vc_tts_unset_streaming_cb(void)
3228 if (0 != __vc_get_feature_enabled()) {
3229 return VC_ERROR_NOT_SUPPORTED;
3231 if (0 != __vc_check_privilege()) {
3232 return VC_ERROR_PERMISSION_DENIED;
3236 if (0 != vc_client_get_client_state(g_vc, &state)) {
3237 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : A handle is not available");
3238 return VC_ERROR_INVALID_STATE;
3242 if (state != VC_STATE_INITIALIZED) {
3243 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : Current state(%d) is not 'Initialized'", state);
3244 return VC_ERROR_INVALID_STATE;
3247 vc_client_set_tts_streaming_cb(g_vc, NULL, NULL);
3252 int __vc_cb_utterance_status(int utt_id, int utt_status)
3254 vc_tts_utterance_status_cb callback = NULL;
3255 void* user_data = NULL;
3257 vc_client_get_tts_utterance_status_cb(g_vc, &callback, &user_data);
3258 if (NULL == callback) {
3259 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Utterance status callback is null");
3263 SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
3264 vc_client_use_callback(g_vc);
3265 callback(utt_id, (vc_tts_utterance_status_e)utt_status);
3266 vc_client_not_use_callback(g_vc);
3271 int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
3273 if (0 != __vc_get_feature_enabled()) {
3274 return VC_ERROR_NOT_SUPPORTED;
3276 if (0 != __vc_check_privilege()) {
3277 return VC_ERROR_PERMISSION_DENIED;
3280 if (NULL == callback)
3281 return VC_ERROR_INVALID_PARAMETER;
3284 if (0 != vc_client_get_client_state(g_vc, &state)) {
3285 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : A handle is not available");
3286 return VC_ERROR_INVALID_STATE;
3290 if (state != VC_STATE_INITIALIZED) {
3291 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3292 return VC_ERROR_INVALID_STATE;
3295 vc_client_set_tts_utterance_status_cb(g_vc, callback, user_data);
3300 int vc_tts_unset_utterance_status_cb(void)
3302 if (0 != __vc_get_feature_enabled()) {
3303 return VC_ERROR_NOT_SUPPORTED;
3305 if (0 != __vc_check_privilege()) {
3306 return VC_ERROR_PERMISSION_DENIED;
3310 if (0 != vc_client_get_client_state(g_vc, &state)) {
3311 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : A handle is not available");
3312 return VC_ERROR_INVALID_STATE;
3316 if (state != VC_STATE_INITIALIZED) {
3317 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3318 return VC_ERROR_INVALID_STATE;
3321 vc_client_set_tts_utterance_status_cb(g_vc, NULL, NULL);