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_Wl2.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_WL2_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_WL2_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 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
360 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
362 return VC_ERROR_NONE;
365 static void __vc_internal_unprepare(void)
367 /* return authority */
368 vc_auth_state_e state = VC_AUTH_STATE_NONE;
369 if (0 != vc_client_get_auth_state(g_vc, &state)) {
370 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
373 if (VC_AUTH_STATE_NONE != state) {
374 if (0 != vc_auth_disable()) {
375 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable"); //LCOV_EXCL_LINE
379 int ret = vc_dbus_request_finalize(g_vc->handle);
381 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
384 if (NULL != g_focus_in_handler) {
385 ecore_event_handler_del(g_focus_in_handler);
386 g_focus_in_handler = NULL;
388 if (NULL != g_focus_out_handler) {
389 ecore_event_handler_del(g_focus_out_handler);
390 g_focus_out_handler = NULL;
393 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
395 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
400 int vc_deinitialize(void)
402 int ret = VC_ERROR_NONE;
404 if (0 != __vc_get_feature_enabled()) {
405 return VC_ERROR_NOT_SUPPORTED;
407 if (0 != __vc_check_privilege()) {
408 return VC_ERROR_PERMISSION_DENIED;
411 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize");
413 if (false == vc_client_is_valid(g_vc)) {
414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
415 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
416 return VC_ERROR_INVALID_STATE;
420 vc_client_get_client_state(g_vc, &state);
425 __vc_internal_unprepare();
426 /* no break. need to next step*/
427 case VC_STATE_INITIALIZED:
428 if (NULL != g_connect_timer) {
429 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted"); //LCOV_EXCL_LINE
430 ecore_timer_del(g_connect_timer);
431 g_connect_timer = NULL;
434 vc_config_mgr_unset_lang_cb(g_vc->handle);
435 vc_config_mgr_finalize(g_vc->handle);
437 /* Free client resources */
438 vc_client_destroy(g_vc);
445 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
447 if (true == g_backup) {
448 ret = vc_db_backup_command();
450 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to backup command, ret(%d)", ret); //LCOV_EXCL_LINE
454 ret = vc_db_finalize();
456 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret); //LCOV_EXCL_LINE
459 if (0 != vc_dbus_close_connection()) {
460 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE
463 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
465 return VC_ERROR_NONE;
468 static Eina_Bool __vc_connect_daemon(void *data)
470 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
472 /* request initialization */
475 int service_state = 0;
477 g_connect_timer = NULL;
480 if (true == vc_client_is_valid(g_vc)) {
481 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] g_vc is valid");
484 ret = vc_db_initialize();
486 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret); //LCOV_EXCL_LINE
490 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
492 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
494 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
496 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
497 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
499 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
500 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
504 } else if (0 != ret) {
505 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
507 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
508 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
510 ret = vc_db_finalize();
512 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB : %d", ret); //LCOV_EXCL_LINE
517 /* Success to connect */
520 /* Set service state */
521 vc_service_state_e previous_service_state;
522 vc_client_get_service_state(g_vc, &previous_service_state);
524 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
526 vc_service_state_changed_cb service_changed_callback = NULL;
527 void* user_data = NULL;
528 vc_client_get_service_state_changed_cb(g_vc, &service_changed_callback, &user_data);
530 if (NULL != service_changed_callback) {
531 vc_client_use_callback(g_vc);
532 service_changed_callback(previous_service_state, service_state, user_data);
533 vc_client_not_use_callback(g_vc);
534 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called"); //LCOV_EXCL_LINE
536 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null"); //LCOV_EXCL_LINE
539 /* Register focus handler */
540 ecore_thread_main_loop_begin();
541 g_focus_in_handler = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
542 g_focus_out_handler = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
543 ecore_thread_main_loop_end();
545 char appid[1024] = {'\0',};
546 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
548 int status = aul_app_get_status(appid);
549 if (STATUS_FOCUS == status) {
550 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); //LCOV_EXCL_LINE
551 ret = vc_dbus_set_foreground(getpid(), true);
553 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE
556 ret = vc_client_set_is_foreground(g_vc, true);
558 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret); //LCOV_EXCL_LINE
561 /* set authority valid */
562 vc_auth_state_e state = VC_AUTH_STATE_NONE;
563 if (0 != vc_client_get_auth_state(g_vc, &state)) {
564 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
566 if (VC_AUTH_STATE_INVALID == state) {
567 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
569 /* notify auth changed cb */
570 ecore_idler_add(__notify_auth_changed_cb, NULL);
574 vc_client_set_client_state(g_vc, VC_STATE_READY);
575 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
577 vc_client_set_mgr_pid(g_vc, mgr_pid);
579 SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] g_vc is not valid. It is destroyed."); //LCOV_EXCL_LINE
583 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
588 static void __start_prepare_thread(void *data, Ecore_Thread *thread)
590 SLOG(LOG_ERROR, TAG_VCC, "@@@ Start prepare thread");
591 int ret = -1, retry_count = 0;
595 if (retry_count == 10) {
596 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
600 ret = vc_dbus_request_hello();
602 SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
612 if (retry_count == 10) {
613 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!"); //LCOV_EXCL_LINE
616 ret = __vc_connect_daemon(NULL);
626 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
628 SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
633 if (0 != __vc_get_feature_enabled()) {
634 return VC_ERROR_NOT_SUPPORTED;
636 if (0 != __vc_check_privilege()) {
637 return VC_ERROR_PERMISSION_DENIED;
640 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
643 if (0 != vc_client_get_client_state(g_vc, &state)) {
644 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available"); //LCOV_EXCL_LINE
645 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
646 return VC_ERROR_INVALID_STATE;
650 if (state != VC_STATE_INITIALIZED) {
651 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'"); //LCOV_EXCL_LINE
652 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
653 return VC_ERROR_INVALID_STATE;
656 ecore_thread_run(__start_prepare_thread, __end_prepare_thread, NULL, NULL);
658 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
660 return VC_ERROR_NONE;
664 int vc_prepare_sync(void)
666 if (0 != __vc_get_feature_enabled()) {
667 return VC_ERROR_NOT_SUPPORTED;
669 if (0 != __vc_check_privilege()) {
670 return VC_ERROR_PERMISSION_DENIED;
673 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
676 if (0 != vc_client_get_client_state(g_vc, &state)) {
677 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
678 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
679 return VC_ERROR_INVALID_STATE;
683 if (state != VC_STATE_INITIALIZED) {
684 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'INITIALIZED'");
685 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
686 return VC_ERROR_INVALID_STATE;
690 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
694 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
696 if (VC_CONNECTION_RETRY_COUNT == cnt) {
697 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
698 return VC_ERROR_OPERATION_FAILED;
701 return VC_ERROR_NONE;
705 int vc_unprepare(void)
707 if (0 != __vc_get_feature_enabled()) {
708 return VC_ERROR_NOT_SUPPORTED;
710 if (0 != __vc_check_privilege()) {
711 return VC_ERROR_PERMISSION_DENIED;
714 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
717 if (0 != vc_client_get_client_state(g_vc, &state)) {
718 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
719 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
720 return VC_ERROR_INVALID_STATE;
724 if (state != VC_STATE_READY) {
725 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
726 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
727 return VC_ERROR_INVALID_STATE;
730 __vc_internal_unprepare();
732 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
733 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
735 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
737 return VC_ERROR_NONE;
740 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
742 if (0 != __vc_get_feature_enabled()) {
743 return VC_ERROR_NOT_SUPPORTED;
745 if (0 != __vc_check_privilege()) {
746 return VC_ERROR_PERMISSION_DENIED;
749 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
751 if (NULL == callback) {
752 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
753 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
754 return VC_ERROR_INVALID_PARAMETER;
758 if (0 != vc_client_get_client_state(g_vc, &state)) {
759 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
760 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
761 return VC_ERROR_INVALID_STATE;
765 ret = vc_config_mgr_get_language_list(callback, user_data);
767 ret = vc_config_convert_error_code((vc_config_error_e)ret);
768 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
771 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
773 return VC_ERROR_NONE;
777 int vc_get_current_language(char** language)
779 if (0 != __vc_get_feature_enabled()) {
780 return VC_ERROR_NOT_SUPPORTED;
782 if (0 != __vc_check_privilege()) {
783 return VC_ERROR_PERMISSION_DENIED;
786 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
788 if (NULL == language) {
789 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
790 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
791 return VC_ERROR_INVALID_PARAMETER;
795 if (0 != vc_client_get_client_state(g_vc, &state)) {
796 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
797 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
798 return VC_ERROR_INVALID_STATE;
802 ret = vc_config_mgr_get_default_language(language);
804 ret = vc_config_convert_error_code((vc_config_error_e)ret);
805 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
808 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
813 int vc_get_state(vc_state_e* state)
815 if (0 != __vc_get_feature_enabled()) {
816 return VC_ERROR_NOT_SUPPORTED;
818 if (0 != __vc_check_privilege()) {
819 return VC_ERROR_PERMISSION_DENIED;
822 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
825 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
826 return VC_ERROR_INVALID_PARAMETER;
830 if (0 != vc_client_get_client_state(g_vc, &temp)) {
831 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
832 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
833 return VC_ERROR_INVALID_STATE;
840 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
841 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
842 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
843 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
847 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
849 return VC_ERROR_NONE;
852 int vc_get_service_state(vc_service_state_e* state)
854 if (0 != __vc_get_feature_enabled()) {
855 return VC_ERROR_NOT_SUPPORTED;
857 if (0 != __vc_check_privilege()) {
858 return VC_ERROR_PERMISSION_DENIED;
861 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
864 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
865 return VC_ERROR_INVALID_PARAMETER;
869 if (0 != vc_client_get_client_state(g_vc, &temp)) {
870 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
871 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
872 return VC_ERROR_INVALID_STATE;
875 if (VC_STATE_READY != temp) {
876 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
877 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
878 return VC_ERROR_INVALID_STATE;
881 /* get service state */
882 vc_service_state_e service_state;
883 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
884 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state"); //LCOV_EXCL_LINE
885 return VC_ERROR_OPERATION_FAILED;
888 *state = service_state;
892 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
893 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
894 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
895 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
896 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
900 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
902 return VC_ERROR_NONE;
905 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
907 if (0 != __vc_get_feature_enabled()) {
908 return VC_ERROR_NOT_SUPPORTED;
910 if (0 != __vc_check_privilege()) {
911 return VC_ERROR_PERMISSION_DENIED;
914 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
916 if (NULL == vc_sys_cmd_list) {
917 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
918 return VC_ERROR_INVALID_PARAMETER;
922 if (0 != vc_client_get_client_state(g_vc, &state)) {
923 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
924 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
925 return VC_ERROR_INVALID_STATE;
929 if (state != VC_STATE_READY) {
930 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
931 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
932 return VC_ERROR_INVALID_STATE;
935 /* Check service state */
936 vc_service_state_e service_state = -1;
937 vc_client_get_service_state(g_vc, &service_state);
938 if (service_state != VC_SERVICE_STATE_READY) {
939 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
940 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
941 return VC_ERROR_INVALID_STATE;
944 bool is_sys_cmd_valid = false;
947 bool is_prepared = false;
949 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
952 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
953 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
954 if (0 == vc_prepare_sync()) {
956 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
958 } else if (VC_ERROR_TIMED_OUT != ret) {
959 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
962 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
965 if (VC_RETRY_COUNT == count) {
966 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
975 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
977 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid"); //LCOV_EXCL_LINE
978 return VC_ERROR_OPERATION_FAILED;
981 vc_cmd_list_s* list = NULL;
982 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
983 if (true == is_sys_cmd_valid) {
984 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
986 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
989 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
991 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
994 *vc_sys_cmd_list = (vc_cmd_list_h)list;
996 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands"); //LCOV_EXCL_LINE
997 *vc_sys_cmd_list = NULL;
998 return VC_ERROR_NONE;
1001 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1008 * @brief Checks whether the command format is supported.
1009 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
1011 * @param[in] format The command format
1012 * @param[out] support The result status @c true = supported, @c false = not supported
1014 * @return 0 on success, otherwise a negative error value
1015 * @retval #VC_ERROR_NONE Successful
1016 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1017 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
1018 * @retval #VC_ERROR_INVALID_STATE Invalid state
1020 * @pre The state should be #VC_STATE_READY.
1022 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
1024 if (0 != __vc_get_feature_enabled()) {
1025 return VC_ERROR_NOT_SUPPORTED;
1027 if (0 != __vc_check_privilege()) {
1028 return VC_ERROR_PERMISSION_DENIED;
1031 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
1034 if (0 != vc_client_get_client_state(g_vc, &state)) {
1035 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1036 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1037 return VC_ERROR_INVALID_STATE;
1041 bool non_fixed_support = false;
1042 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1043 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1047 case VC_CMD_FORMAT_FIXED: *support = true; break;
1048 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
1049 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
1050 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
1051 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
1052 default: *support = false; break;
1055 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1057 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1059 return VC_ERROR_NONE;
1063 static int __vc_get_invocation_name(char** invocation_name)
1065 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
1067 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name"); //LCOV_EXCL_LINE
1068 return ret; //LCOV_EXCL_LINE
1071 if (NULL == *invocation_name) {
1072 char* temp_label = NULL;
1076 ret = app_manager_get_app_id(getpid(), &appid);
1077 if (0 != ret || NULL == appid) {
1078 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret); //LCOV_EXCL_LINE
1079 if (NULL != appid) {
1083 return VC_ERROR_OPERATION_FAILED;
1086 ret = vc_get_current_language(&lang);
1087 if (0 != ret || NULL == lang) {
1088 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current language, ret(%d)", ret); //LCOV_EXCL_LINE
1095 return VC_ERROR_OPERATION_FAILED;
1098 ret = app_info_get_localed_label(appid, lang, &temp_label);
1099 if (0 != ret || NULL == temp_label) {
1100 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang); //LCOV_EXCL_LINE
1105 if (NULL != temp_label) {
1109 return VC_ERROR_OPERATION_FAILED;
1112 *invocation_name = strdup(temp_label);
1113 if (NULL == *invocation_name) {
1114 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
1115 return VC_ERROR_OUT_OF_MEMORY;
1126 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1127 return VC_ERROR_NONE;
1130 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1132 if (0 != __vc_get_feature_enabled()) {
1133 return VC_ERROR_NOT_SUPPORTED;
1135 if (0 != __vc_check_privilege()) {
1136 return VC_ERROR_PERMISSION_DENIED;
1139 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1141 if (NULL == vc_cmd_list) {
1142 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1143 return VC_ERROR_INVALID_PARAMETER;
1147 if (0 != vc_client_get_client_state(g_vc, &state)) {
1148 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1149 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1150 return VC_ERROR_INVALID_STATE;
1154 if (state != VC_STATE_READY) {
1155 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1156 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1157 return VC_ERROR_INVALID_STATE;
1161 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1162 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type); //LCOV_EXCL_LINE
1163 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1164 return VC_ERROR_INVALID_PARAMETER;
1167 vc_cmd_list_s* list = NULL;
1168 list = (vc_cmd_list_s*)vc_cmd_list;
1170 if (NULL == list->list) {
1171 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list"); //LCOV_EXCL_LINE
1172 return VC_ERROR_INVALID_PARAMETER;
1176 char* invocation_name = NULL;
1177 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1178 ret = __vc_get_invocation_name(&invocation_name);
1179 if (0 != ret || NULL == invocation_name) {
1180 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret); //LCOV_EXCL_LINE
1185 ret = vc_cmd_parser_delete_file(getpid(), type);
1187 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1189 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1191 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1194 bool is_prepared = false;
1196 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1199 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1200 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1201 if (0 == vc_prepare_sync()) {
1203 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1205 } else if (VC_ERROR_TIMED_OUT != ret) {
1206 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1209 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1212 if (VC_RETRY_COUNT == count) {
1213 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1222 if (NULL != invocation_name) {
1223 free(invocation_name);
1224 invocation_name = NULL;
1227 if (VC_COMMAND_TYPE_BACKGROUND == type)
1230 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1235 int vc_unset_command_list(int type)
1237 if (0 != __vc_get_feature_enabled()) {
1238 return VC_ERROR_NOT_SUPPORTED;
1240 if (0 != __vc_check_privilege()) {
1241 return VC_ERROR_PERMISSION_DENIED;
1244 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1247 if (0 != vc_client_get_client_state(g_vc, &state)) {
1248 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1249 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1250 return VC_ERROR_INVALID_STATE;
1254 if (state != VC_STATE_READY) {
1255 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1256 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1257 return VC_ERROR_INVALID_STATE;
1262 bool is_prepared = false;
1264 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1267 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1268 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1269 if (0 == vc_prepare_sync()) {
1271 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1273 } else if (VC_ERROR_TIMED_OUT != ret) {
1274 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1277 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1280 if (VC_RETRY_COUNT == count) {
1281 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1289 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1291 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1292 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret)); //LCOV_EXCL_LINE
1295 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1301 int vc_set_command_list_from_file(const char* file_path, int type)
1303 if (0 != __vc_get_feature_enabled()) {
1304 return VC_ERROR_NOT_SUPPORTED;
1306 if (0 != __vc_check_privilege()) {
1307 return VC_ERROR_PERMISSION_DENIED;
1310 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1313 if (0 != vc_client_get_client_state(g_vc, &state)) {
1314 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1315 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1316 return VC_ERROR_INVALID_STATE;
1320 if (state != VC_STATE_READY) {
1321 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1322 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1323 return VC_ERROR_INVALID_STATE;
1327 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1329 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1330 return VC_ERROR_INVALID_PARAMETER;
1334 char* invocation_name = NULL;
1335 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1336 ret = __vc_get_invocation_name(&invocation_name);
1337 if (0 != ret || NULL == invocation_name) {
1338 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1343 ret = vc_cmd_parser_delete_file(getpid(), type);
1345 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1347 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1349 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1352 bool is_prepared = false;
1354 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1357 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1358 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1359 if (0 == vc_prepare_sync()) {
1361 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1363 } else if (VC_ERROR_TIMED_OUT != ret) {
1364 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1367 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1370 if (VC_RETRY_COUNT == count) {
1371 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1380 if (NULL != invocation_name) {
1381 free(invocation_name);
1382 invocation_name = NULL;
1385 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1391 int vc_get_exclusive_command_option(bool* value)
1393 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1396 if (0 != vc_client_get_client_state(g_vc, &state)) {
1397 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1398 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1399 return VC_ERROR_INVALID_STATE;
1403 if (state != VC_STATE_READY) {
1404 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1405 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1406 return VC_ERROR_INVALID_STATE;
1409 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1411 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1412 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1416 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1421 int vc_set_exclusive_command_option(bool value)
1423 if (0 != __vc_get_feature_enabled()) {
1424 return VC_ERROR_NOT_SUPPORTED;
1426 if (0 != __vc_check_privilege()) {
1427 return VC_ERROR_PERMISSION_DENIED;
1430 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1433 if (0 != vc_client_get_client_state(g_vc, &state)) {
1434 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1435 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1436 return VC_ERROR_INVALID_STATE;
1440 if (state != VC_STATE_READY) {
1441 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1442 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1443 return VC_ERROR_INVALID_STATE;
1446 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1448 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1449 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1455 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1457 if (VC_ERROR_TIMED_OUT != ret) {
1458 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1461 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1464 if (VC_RETRY_COUNT == count) {
1465 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1472 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1479 int vc_request_start(bool stop_by_silence)
1481 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1484 if (0 != vc_client_get_client_state(g_vc, &state)) {
1485 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1486 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1487 return VC_ERROR_INVALID_STATE;
1491 if (state != VC_STATE_READY) {
1492 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1493 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1494 return VC_ERROR_INVALID_STATE;
1497 /* Check service state */
1498 vc_service_state_e service_state = -1;
1499 vc_client_get_service_state(g_vc, &service_state);
1500 if (service_state != VC_SERVICE_STATE_READY) {
1501 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1502 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1503 return VC_ERROR_INVALID_STATE;
1513 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1515 if (VC_ERROR_TIMED_OUT != ret) {
1516 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1519 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1522 if (VC_RETRY_COUNT == count) {
1523 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1528 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1532 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1537 int vc_request_stop(void)
1539 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1542 if (0 != vc_client_get_client_state(g_vc, &state)) {
1543 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1544 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1545 return VC_ERROR_INVALID_STATE;
1549 if (state != VC_STATE_READY) {
1550 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1551 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1552 return VC_ERROR_INVALID_STATE;
1555 /* Check service state */
1556 vc_service_state_e service_state = -1;
1557 vc_client_get_service_state(g_vc, &service_state);
1558 if (service_state != VC_SERVICE_STATE_RECORDING) {
1559 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1560 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1561 return VC_ERROR_INVALID_STATE;
1568 ret = vc_dbus_request_stop(g_vc->handle);
1570 if (VC_ERROR_TIMED_OUT != ret) {
1571 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1574 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1577 if (VC_RETRY_COUNT == count) {
1578 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1583 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1587 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1592 int vc_request_cancel(void)
1594 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1597 if (0 != vc_client_get_client_state(g_vc, &state)) {
1598 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1599 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1600 return VC_ERROR_INVALID_STATE;
1604 if (state != VC_STATE_READY) {
1605 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1606 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1607 return VC_ERROR_INVALID_STATE;
1610 /* Check service state */
1611 vc_service_state_e service_state = -1;
1612 vc_client_get_service_state(g_vc, &service_state);
1613 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1614 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1615 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1616 return VC_ERROR_INVALID_STATE;
1622 ret = vc_dbus_request_cancel(g_vc->handle);
1624 if (VC_ERROR_TIMED_OUT != ret) {
1625 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1628 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1631 if (VC_RETRY_COUNT == count) {
1632 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1637 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1641 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1648 static void __vc_notify_error(void *data)
1650 vc_h vc = (vc_h)data;
1652 vc_error_cb callback = NULL;
1656 vc_client_get_error_cb(vc, &callback, &user_data);
1657 vc_client_get_error(vc, &reason);
1659 if (NULL != callback) {
1660 vc_client_use_callback(vc);
1661 callback(reason, user_data);
1662 vc_client_not_use_callback(vc);
1663 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1665 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1669 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1672 if (0 != vc_client_get_client_state(g_vc, &state)) {
1673 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1678 if (state != VC_STATE_READY) {
1679 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] State is not READY");
1680 if (VC_ERROR_SERVICE_RESET != reason) {
1681 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1687 if (VC_ERROR_SERVICE_RESET == reason) {
1688 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1690 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1691 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
1693 if (0 != vc_prepare()) {
1694 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1698 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1700 vc_client_set_error(g_vc, reason);
1701 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
1706 static void __vc_notify_state_changed(void *data)
1708 vc_h vc = (vc_h)data;
1710 vc_state_changed_cb changed_callback = NULL;
1713 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1715 vc_state_e current_state;
1716 vc_state_e before_state;
1718 vc_client_get_before_state(vc, ¤t_state, &before_state);
1720 if (NULL != changed_callback) {
1721 vc_client_use_callback(vc);
1722 changed_callback(before_state, current_state, user_data);
1723 vc_client_not_use_callback(vc);
1724 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1726 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1730 static Eina_Bool __vc_notify_result(void *data)
1734 vc_cmd_list_h vc_cmd_list = NULL;
1736 vc_result_cb callback = NULL;
1737 void* user_data = NULL;
1739 vc_client_get_result_cb(g_vc, &callback, &user_data);
1741 if (NULL == callback) {
1742 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1746 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1747 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1751 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1753 SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1755 vc_cmd_print_list(vc_cmd_list);
1757 vc_client_use_callback(g_vc);
1758 callback(event, vc_cmd_list, temp_text, user_data);
1759 vc_client_not_use_callback(g_vc);
1761 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1763 vc_cmd_list_destroy(vc_cmd_list, true);
1765 /* Release result */
1766 if (NULL != temp_text) free(temp_text);
1771 void __vc_cb_result(void)
1773 ecore_timer_add(0, __vc_notify_result, NULL);
1779 int vc_get_result(vc_result_cb callback, void* user_data)
1781 if (0 != __vc_get_feature_enabled()) {
1782 return VC_ERROR_NOT_SUPPORTED;
1784 if (0 != __vc_check_privilege()) {
1785 return VC_ERROR_PERMISSION_DENIED;
1788 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1791 if (0 != vc_client_get_client_state(g_vc, &state)) {
1792 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1793 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1794 return VC_ERROR_INVALID_STATE;
1798 if (state != VC_STATE_READY) {
1799 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1800 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
1801 return VC_ERROR_INVALID_STATE;
1804 if (NULL == callback) {
1805 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL"); //LCOV_EXCL_LINE
1806 return VC_ERROR_INVALID_PARAMETER;
1809 char* temp_text = NULL;
1811 vc_cmd_list_h vc_cmd_list = NULL;
1813 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1814 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1815 return VC_ERROR_INVALID_PARAMETER;
1818 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1819 if (0 != ret || NULL == temp_text) {
1820 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text); //LCOV_EXCL_LINE
1824 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event); //LCOV_EXCL_LINE
1826 vc_cmd_print_list(vc_cmd_list);
1828 vc_client_use_callback(g_vc);
1829 callback(event, vc_cmd_list, temp_text, user_data);
1830 vc_client_not_use_callback(g_vc);
1832 vc_cmd_list_destroy(vc_cmd_list, true);
1834 /* Release result */
1835 if (NULL != temp_text) {
1840 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1842 return VC_ERROR_NONE;
1845 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1847 if (0 != __vc_get_feature_enabled()) {
1848 return VC_ERROR_NOT_SUPPORTED;
1850 if (0 != __vc_check_privilege()) {
1851 return VC_ERROR_PERMISSION_DENIED;
1854 if (NULL == callback)
1855 return VC_ERROR_INVALID_PARAMETER;
1858 if (0 != vc_client_get_client_state(g_vc, &state)) {
1859 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1860 return VC_ERROR_INVALID_STATE;
1864 if (state != VC_STATE_INITIALIZED) {
1865 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1866 return VC_ERROR_INVALID_STATE;
1869 vc_client_set_result_cb(g_vc, callback, user_data);
1874 int vc_unset_result_cb(void)
1876 if (0 != __vc_get_feature_enabled()) {
1877 return VC_ERROR_NOT_SUPPORTED;
1879 if (0 != __vc_check_privilege()) {
1880 return VC_ERROR_PERMISSION_DENIED;
1884 if (0 != vc_client_get_client_state(g_vc, &state)) {
1885 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1886 return VC_ERROR_INVALID_STATE;
1890 if (state != VC_STATE_INITIALIZED) {
1891 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1892 return VC_ERROR_INVALID_STATE;
1895 vc_client_set_result_cb(g_vc, NULL, NULL);
1901 int __vc_cb_service_state(int state)
1903 vc_service_state_e current_state = (vc_service_state_e)state;
1904 vc_service_state_e before_state;
1905 vc_client_get_service_state(g_vc, &before_state);
1907 if (current_state == before_state) {
1911 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1912 before_state, current_state);
1914 /* Save service state */
1915 vc_client_set_service_state(g_vc, current_state);
1917 vc_service_state_changed_cb callback = NULL;
1918 void* service_user_data;
1919 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1921 if (NULL != callback) {
1922 vc_client_use_callback(g_vc);
1923 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1924 vc_client_not_use_callback(g_vc);
1925 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1927 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1934 int __vc_cb_manager_pid(int manager_pid)
1936 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
1938 /* Save service state */
1939 vc_client_set_mgr_pid(g_vc, manager_pid);
1944 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1946 if (0 != __vc_get_feature_enabled()) {
1947 return VC_ERROR_NOT_SUPPORTED;
1949 if (0 != __vc_check_privilege()) {
1950 return VC_ERROR_PERMISSION_DENIED;
1953 if (NULL == callback)
1954 return VC_ERROR_INVALID_PARAMETER;
1957 if (0 != vc_client_get_client_state(g_vc, &state)) {
1958 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1959 return VC_ERROR_INVALID_STATE;
1963 if (state != VC_STATE_INITIALIZED) {
1964 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1965 return VC_ERROR_INVALID_STATE;
1968 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1973 int vc_unset_service_state_changed_cb(void)
1975 if (0 != __vc_get_feature_enabled()) {
1976 return VC_ERROR_NOT_SUPPORTED;
1978 if (0 != __vc_check_privilege()) {
1979 return VC_ERROR_PERMISSION_DENIED;
1983 if (0 != vc_client_get_client_state(g_vc, &state)) {
1984 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1985 return VC_ERROR_INVALID_STATE;
1989 if (state != VC_STATE_INITIALIZED) {
1990 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1991 return VC_ERROR_INVALID_STATE;
1994 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1999 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
2001 if (0 != __vc_get_feature_enabled()) {
2002 return VC_ERROR_NOT_SUPPORTED;
2004 if (0 != __vc_check_privilege()) {
2005 return VC_ERROR_PERMISSION_DENIED;
2008 if (callback == NULL)
2009 return VC_ERROR_INVALID_PARAMETER;
2012 if (0 != vc_client_get_client_state(g_vc, &state)) {
2013 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
2014 return VC_ERROR_INVALID_STATE;
2018 if (state != VC_STATE_INITIALIZED) {
2019 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2020 return VC_ERROR_INVALID_STATE;
2023 vc_client_set_state_changed_cb(g_vc, callback, user_data);
2028 int vc_unset_state_changed_cb(void)
2030 if (0 != __vc_get_feature_enabled()) {
2031 return VC_ERROR_NOT_SUPPORTED;
2033 if (0 != __vc_check_privilege()) {
2034 return VC_ERROR_PERMISSION_DENIED;
2038 if (0 != vc_client_get_client_state(g_vc, &state)) {
2039 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
2040 return VC_ERROR_INVALID_STATE;
2044 if (state != VC_STATE_INITIALIZED) {
2045 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2046 return VC_ERROR_INVALID_STATE;
2049 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
2054 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2056 if (0 != __vc_get_feature_enabled()) {
2057 return VC_ERROR_NOT_SUPPORTED;
2059 if (0 != __vc_check_privilege()) {
2060 return VC_ERROR_PERMISSION_DENIED;
2063 if (NULL == callback)
2064 return VC_ERROR_INVALID_PARAMETER;
2067 if (0 != vc_client_get_client_state(g_vc, &state)) {
2068 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
2069 return VC_ERROR_INVALID_STATE;
2073 if (state != VC_STATE_INITIALIZED) {
2074 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
2075 return VC_ERROR_INVALID_STATE;
2078 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2083 int vc_unset_current_language_changed_cb(void)
2085 if (0 != __vc_get_feature_enabled()) {
2086 return VC_ERROR_NOT_SUPPORTED;
2088 if (0 != __vc_check_privilege()) {
2089 return VC_ERROR_PERMISSION_DENIED;
2093 if (0 != vc_client_get_client_state(g_vc, &state)) {
2094 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2095 return VC_ERROR_INVALID_STATE;
2099 if (state != VC_STATE_INITIALIZED) {
2100 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2101 return VC_ERROR_INVALID_STATE;
2104 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2109 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2111 if (0 != __vc_get_feature_enabled()) {
2112 return VC_ERROR_NOT_SUPPORTED;
2114 if (0 != __vc_check_privilege()) {
2115 return VC_ERROR_PERMISSION_DENIED;
2118 if (NULL == callback)
2119 return VC_ERROR_INVALID_PARAMETER;
2122 if (0 != vc_client_get_client_state(g_vc, &state)) {
2123 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2124 return VC_ERROR_INVALID_STATE;
2128 if (state != VC_STATE_INITIALIZED) {
2129 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
2130 return VC_ERROR_INVALID_STATE;
2133 vc_client_set_error_cb(g_vc, callback, user_data);
2138 int vc_unset_error_cb(void)
2140 if (0 != __vc_get_feature_enabled()) {
2141 return VC_ERROR_NOT_SUPPORTED;
2143 if (0 != __vc_check_privilege()) {
2144 return VC_ERROR_PERMISSION_DENIED;
2148 if (0 != vc_client_get_client_state(g_vc, &state)) {
2149 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2150 return VC_ERROR_INVALID_STATE;
2154 if (state != VC_STATE_INITIALIZED) {
2155 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2156 return VC_ERROR_INVALID_STATE;
2159 vc_client_set_error_cb(g_vc, NULL, NULL);
2164 int vc_set_invocation_name(const char* name)
2166 if (0 != __vc_get_feature_enabled()) {
2167 return VC_ERROR_NOT_SUPPORTED;
2169 if (0 != __vc_check_privilege()) {
2170 return VC_ERROR_PERMISSION_DENIED;
2174 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2176 int ret = vc_client_get_client_state(g_vc, &state);
2178 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2179 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2184 if (state != VC_STATE_READY) {
2185 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2186 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2187 return VC_ERROR_INVALID_STATE;
2190 ret = vc_client_set_invocation_name(g_vc, name);
2192 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2198 int vc_set_server_dialog(const char* app_id, const char* credential)
2203 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2204 if (0 != __vc_get_feature_enabled()) {
2205 return VC_ERROR_NOT_SUPPORTED;
2207 if (0 != __vc_check_privilege()) {
2208 return VC_ERROR_PERMISSION_DENIED;
2211 if (NULL == credential) {
2212 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Credential is NULL");
2213 return VC_ERROR_INVALID_PARAMETER;
2216 if (0 != vc_client_get_client_state(g_vc, &state)) {
2217 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2218 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2219 return VC_ERROR_INVALID_STATE;
2223 if (state != VC_STATE_READY) {
2224 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2225 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2226 return VC_ERROR_INVALID_STATE;
2229 /* Check service state */
2230 vc_service_state_e service_state = -1;
2231 vc_client_get_service_state(g_vc, &service_state);
2232 if (service_state != VC_SERVICE_STATE_READY) {
2233 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2234 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2235 return VC_ERROR_INVALID_STATE;
2238 char* tmp_appid = NULL;
2239 if (NULL == app_id) {
2240 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2241 if (0 != ret || NULL == tmp_appid) {
2242 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2243 if (NULL != tmp_appid)
2245 return VC_ERROR_INVALID_PARAMETER;
2248 tmp_appid = strdup(app_id);
2252 SLOG(LOG_DEBUG, TAG_VCC, "Set server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2255 bool is_prepared = false;
2257 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2259 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2260 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2261 if (0 == vc_prepare_sync()) {
2263 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2265 } else if (VC_ERROR_TIMED_OUT != ret) {
2266 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set server dialog to vc service : %s", __vc_get_error_code(ret));
2269 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set server dialog : %s", __vc_get_error_code(ret));
2272 if (VC_RETRY_COUNT == count) {
2273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2281 if (NULL != tmp_appid)
2284 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2289 int vc_unset_server_dialog(const char* app_id)
2294 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2295 if (0 != __vc_get_feature_enabled()) {
2296 return VC_ERROR_NOT_SUPPORTED;
2298 if (0 != __vc_check_privilege()) {
2299 return VC_ERROR_PERMISSION_DENIED;
2302 if (0 != vc_client_get_client_state(g_vc, &state)) {
2303 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2304 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2305 return VC_ERROR_INVALID_STATE;
2309 if (state != VC_STATE_READY) {
2310 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2311 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2312 return VC_ERROR_INVALID_STATE;
2315 /* Check service state */
2316 vc_service_state_e service_state = -1;
2317 vc_client_get_service_state(g_vc, &service_state);
2318 if (service_state != VC_SERVICE_STATE_READY) {
2319 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2320 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2321 return VC_ERROR_INVALID_STATE;
2324 char* tmp_appid = NULL;
2325 if (NULL == app_id) {
2326 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2327 if (0 != ret || NULL == tmp_appid) {
2328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2329 if (NULL != tmp_appid)
2331 return VC_ERROR_INVALID_PARAMETER;
2334 tmp_appid = strdup(app_id);
2338 SLOG(LOG_DEBUG, TAG_VCC, "Unset server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2341 bool is_prepared = false;
2342 char* credential = strdup("#NULL");
2344 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2346 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2347 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2348 if (0 == vc_prepare_sync()) {
2350 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2352 } else if (VC_ERROR_TIMED_OUT != ret) {
2353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset server dialog to vc service : %s", __vc_get_error_code(ret));
2356 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset server dialog : %s", __vc_get_error_code(ret));
2359 if (VC_RETRY_COUNT == count) {
2360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2368 if (NULL != tmp_appid)
2370 if (NULL != credential)
2373 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2379 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2383 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2384 if (0 != __vc_get_feature_enabled()) {
2385 return VC_ERROR_NOT_SUPPORTED;
2387 if (0 != __vc_check_privilege()) {
2388 return VC_ERROR_PERMISSION_DENIED;
2391 if (0 != vc_client_get_client_state(g_vc, &state)) {
2392 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2393 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2394 return VC_ERROR_INVALID_STATE;
2398 if (state != VC_STATE_READY) {
2399 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
2400 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2401 return VC_ERROR_INVALID_STATE;
2404 /* Check service state */
2405 vc_service_state_e service_state = -1;
2406 vc_client_get_service_state(g_vc, &service_state);
2407 if (service_state != VC_SERVICE_STATE_READY) {
2408 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
2409 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2410 return VC_ERROR_INVALID_STATE;
2413 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);
2414 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2416 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret);
2417 return VC_ERROR_OPERATION_FAILED;
2420 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2422 return VC_ERROR_NONE;
2427 int vc_auth_enable(void)
2431 if (0 != vc_client_get_client_state(g_vc, &state)) {
2432 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2433 return VC_ERROR_INVALID_STATE;
2436 if (VC_STATE_READY != state) {
2437 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2438 return VC_ERROR_INVALID_STATE;
2441 /* check already authority */
2442 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2443 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2444 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2445 return VC_ERROR_INVALID_STATE;
2448 if (VC_AUTH_STATE_NONE != auth_state) {
2449 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2450 return VC_ERROR_INVALID_STATE;
2453 /* request authority */
2455 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2456 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2457 return VC_ERROR_OPERATION_FAILED;
2460 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2461 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2462 return VC_ERROR_OPERATION_FAILED;
2465 /* set authority into handle */
2466 bool is_foreground = false;
2467 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2468 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2469 return VC_ERROR_OPERATION_FAILED;
2472 if (is_foreground) {
2473 auth_state = VC_AUTH_STATE_VALID;
2475 auth_state = VC_AUTH_STATE_INVALID;
2478 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2480 return VC_ERROR_OPERATION_FAILED;
2483 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2485 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2487 return VC_ERROR_NONE;
2490 int vc_auth_disable(void)
2494 if (0 != vc_client_get_client_state(g_vc, &state)) {
2495 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2496 return VC_ERROR_INVALID_STATE;
2499 if (VC_STATE_READY != state) {
2500 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2501 return VC_ERROR_INVALID_STATE;
2504 /* check authority */
2505 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2506 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2507 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2508 return VC_ERROR_INVALID_STATE;
2511 if (VC_AUTH_STATE_NONE == auth_state) {
2512 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2513 return VC_ERROR_INVALID_STATE;
2516 if (0 != vc_auth_unset_state_changed_cb()) {
2517 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2520 /* request return authority by dbus */
2522 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2523 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2524 return VC_ERROR_OPERATION_FAILED;
2527 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2528 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
2529 return VC_ERROR_OPERATION_FAILED;
2532 /* unset authority from handle */
2533 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2534 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2535 return VC_ERROR_OPERATION_FAILED;
2538 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2540 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2542 return VC_ERROR_NONE;
2545 int vc_auth_get_state(vc_auth_state_e* state)
2548 vc_state_e vc_state;
2549 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2550 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2551 return VC_ERROR_INVALID_STATE;
2554 if (VC_STATE_READY != vc_state) {
2555 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2556 return VC_ERROR_INVALID_STATE;
2560 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2561 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2562 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2563 return VC_ERROR_INVALID_STATE;
2568 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2570 return VC_ERROR_NONE;
2573 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2575 /* check parameter */
2576 if (NULL == callback) {
2577 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2578 return VC_ERROR_INVALID_PARAMETER;
2582 vc_auth_state_e auth_state;
2583 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2584 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2585 return VC_ERROR_INVALID_STATE;
2588 if (VC_AUTH_STATE_NONE == auth_state) {
2589 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2590 return VC_ERROR_INVALID_STATE;
2593 /* set cb into handle */
2594 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2595 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2596 return VC_ERROR_OPERATION_FAILED;
2599 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2601 return VC_ERROR_NONE;
2604 int vc_auth_unset_state_changed_cb(void)
2607 vc_auth_state_e auth_state;
2608 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2609 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2610 return VC_ERROR_INVALID_STATE;
2613 if (VC_AUTH_STATE_NONE == auth_state) {
2614 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2615 return VC_ERROR_INVALID_STATE;
2618 /* unset cb from handle */
2619 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2620 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2621 return VC_ERROR_OPERATION_FAILED;
2624 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2626 return VC_ERROR_NONE;
2629 int vc_auth_start(void)
2631 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2634 if (0 != vc_client_get_client_state(g_vc, &state)) {
2635 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2636 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2637 return VC_ERROR_INVALID_STATE;
2641 if (state != VC_STATE_READY) {
2642 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2643 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2644 return VC_ERROR_INVALID_STATE;
2647 /* Check service state */
2648 vc_service_state_e service_state = -1;
2649 vc_client_get_service_state(g_vc, &service_state);
2650 if (service_state != VC_SERVICE_STATE_READY) {
2651 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2652 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2653 return VC_ERROR_INVALID_STATE;
2656 /* Check authority */
2657 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2658 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2659 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2660 return VC_ERROR_OPERATION_FAILED;
2663 if (VC_AUTH_STATE_VALID != auth_state) {
2664 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2665 return VC_ERROR_OPERATION_FAILED;
2670 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2671 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2672 return VC_ERROR_OPERATION_FAILED;
2677 bool is_prepared = false;
2680 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2682 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2683 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2684 if (0 == vc_prepare_sync()) {
2686 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2688 } else if (VC_ERROR_TIMED_OUT != ret) {
2689 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2692 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2695 if (VC_RETRY_COUNT == count) {
2696 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2701 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2705 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2710 int vc_auth_stop(void)
2712 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2715 if (0 != vc_client_get_client_state(g_vc, &state)) {
2716 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2717 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2718 return VC_ERROR_INVALID_STATE;
2722 if (state != VC_STATE_READY) {
2723 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2724 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2725 return VC_ERROR_INVALID_STATE;
2728 /* Check service state */
2729 vc_service_state_e service_state = -1;
2730 vc_client_get_service_state(g_vc, &service_state);
2731 if (service_state != VC_SERVICE_STATE_RECORDING) {
2732 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2733 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2734 return VC_ERROR_INVALID_STATE;
2737 /* Check authority */
2738 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2739 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2740 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2741 return VC_ERROR_OPERATION_FAILED;
2744 if (VC_AUTH_STATE_VALID != auth_state) {
2745 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2746 return VC_ERROR_OPERATION_FAILED;
2751 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2752 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2753 return VC_ERROR_OPERATION_FAILED;
2758 bool is_prepared = false;
2761 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2763 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2764 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2765 if (0 == vc_prepare_sync()) {
2767 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2769 } else if (VC_ERROR_TIMED_OUT != ret) {
2770 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2773 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2776 if (VC_RETRY_COUNT == count) {
2777 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2782 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2786 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2791 int vc_auth_cancel(void)
2793 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2796 if (0 != vc_client_get_client_state(g_vc, &state)) {
2797 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2798 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2799 return VC_ERROR_INVALID_STATE;
2803 if (state != VC_STATE_READY) {
2804 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2805 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2806 return VC_ERROR_INVALID_STATE;
2809 /* Check service state */
2810 vc_service_state_e service_state = -1;
2811 vc_client_get_service_state(g_vc, &service_state);
2812 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2813 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2814 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2815 return VC_ERROR_INVALID_STATE;
2818 /* Check authority */
2819 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2820 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2821 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2822 return VC_ERROR_OPERATION_FAILED;
2825 if (VC_AUTH_STATE_VALID != auth_state) {
2826 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2827 return VC_ERROR_OPERATION_FAILED;
2832 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2833 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2834 return VC_ERROR_OPERATION_FAILED;
2839 bool is_prepared = false;
2841 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2843 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2844 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2845 if (0 == vc_prepare_sync()) {
2847 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2849 } else if (VC_ERROR_TIMED_OUT != ret) {
2850 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2853 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2856 if (VC_RETRY_COUNT == count) {
2857 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2862 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2866 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2871 static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
2873 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Start tts streaming thread");
2875 vc_tts_data_s* tts_data = NULL;
2876 vc_tts_streaming_cb callback = NULL;
2877 void* user_data = NULL;
2879 vc_client_get_tts_streaming_cb(g_vc, &callback, &user_data);
2880 if (NULL == callback) {
2881 SLOG(LOG_WARN, TAG_VCC, "[WARNING] tts streaming callback is null");
2890 ret = vc_data_get_tts_data(&tts_data);
2891 if (0 != ret || NULL == tts_data) {
2893 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] No tts data. Waiting mode");
2898 if (0 < vc_data_get_tts_data_size()) {
2899 SLOG(LOG_INFO, TAG_VCC, "[INFO] Resume thread");
2903 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Wrong request, there's no pcm data");
2904 vc_data_clear_tts_data(&tts_data);
2909 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish to wait for new tts data come");
2911 /* resume tts thread */
2912 vc_data_clear_tts_data(&tts_data);
2916 if (NULL != tts_data) {
2917 SLOG(LOG_DEBUG, TAG_VCC, "tts streaming callback is called");
2918 vc_client_use_callback(g_vc);
2919 callback(tts_data->event, tts_data->data, tts_data->data_size, tts_data->utt_id, user_data);
2920 vc_client_not_use_callback(g_vc);
2922 /* If no tts data and EVENT_FINISH */
2923 if (0 >= vc_data_get_tts_data_size() && VC_TTS_EVENT_FINISH == tts_data->event) {
2924 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish tts");
2935 static void __end_tts_streaming_thread(void* data, Ecore_Thread* thread)
2937 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] End tts streaming thread");
2938 g_tts_thread = NULL;
2941 int __vc_cb_tts_streaming(int utt_id, vc_tts_event_e event, char* buffer, int len)
2944 vc_tts_data_s* temp_tts_data = NULL;
2945 temp_tts_data = (vc_tts_data_s*)calloc(1, sizeof(vc_tts_data_s));
2946 if (NULL == temp_tts_data) {
2947 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Out of memory");
2948 return VC_ERROR_OUT_OF_MEMORY;
2951 temp_tts_data->data = NULL;
2952 temp_tts_data->data_size = 0;
2955 temp_tts_data->data = (char*)calloc(len + 5, sizeof(char));
2956 if (NULL != temp_tts_data->data) {
2957 memcpy(temp_tts_data->data, buffer, len);
2958 temp_tts_data->data_size = len;
2959 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG][memcpy] data(%p) size(%d)",
2960 temp_tts_data->data, temp_tts_data->data_size);
2962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to allocate memory");
2965 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] tts data is NULL");
2968 temp_tts_data->utt_id = utt_id;
2969 temp_tts_data->event = event;
2971 int ret = vc_data_add_tts_data(temp_tts_data);
2973 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to add tts data");
2974 if (NULL != temp_tts_data->data) {
2975 free(temp_tts_data->data);
2976 temp_tts_data->data = NULL;
2978 if (NULL != temp_tts_data) {
2979 free(temp_tts_data);
2980 temp_tts_data = NULL;
2984 bool is_canceled = ecore_thread_check(g_tts_thread);
2985 if (NULL == g_tts_thread || TRUE == is_canceled) {
2986 SLOG(LOG_INFO, TAG_VCC, "ecore thread run : __start_tts_streaming_thread ");
2987 g_tts_thread = ecore_thread_run(__start_tts_streaming_thread, __end_tts_streaming_thread, NULL, NULL);
2993 int vc_tts_request(const char* text, const char* language, bool to_vcm, int* utt_id)
2999 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request tts");
3001 if (0 != __vc_get_feature_enabled()) {
3002 return VC_ERROR_NOT_SUPPORTED;
3004 if (0 != __vc_check_privilege()) {
3005 return VC_ERROR_PERMISSION_DENIED;
3008 if (0 != vc_client_get_client_state(g_vc, &state)) {
3009 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3010 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3011 return VC_ERROR_INVALID_STATE;
3015 if (state != VC_STATE_READY) {
3016 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3017 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3018 return VC_ERROR_INVALID_STATE;
3021 /* Check service state */
3022 vc_service_state_e service_state = -1;
3023 vc_client_get_service_state(g_vc, &service_state);
3024 if (service_state != VC_SERVICE_STATE_READY) {
3025 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3026 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3027 return VC_ERROR_INVALID_STATE;
3030 SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts request, pid(%d), text(%s), language(%s), to_vcm(%d)", pid, text, language, to_vcm);
3033 bool is_prepared = false;
3035 ret = vc_dbus_request_tts(pid, text, language, to_vcm, utt_id);
3037 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3038 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3039 if (0 == vc_prepare_sync()) {
3041 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3043 } else if (VC_ERROR_TIMED_OUT != ret) {
3044 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request tts to vc service : %s", __vc_get_error_code(ret));
3047 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request tts : %s", __vc_get_error_code(ret));
3050 if (VC_RETRY_COUNT == count) {
3051 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
3058 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3063 int vc_tts_cancel(int utt_id)
3069 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Cancel tts");
3071 if (0 != __vc_get_feature_enabled()) {
3072 return VC_ERROR_NOT_SUPPORTED;
3074 if (0 != __vc_check_privilege()) {
3075 return VC_ERROR_PERMISSION_DENIED;
3078 if (0 != vc_client_get_client_state(g_vc, &state)) {
3079 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3080 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3081 return VC_ERROR_INVALID_STATE;
3085 if (state != VC_STATE_READY) {
3086 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3087 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3088 return VC_ERROR_INVALID_STATE;
3091 /* Check service state */
3092 vc_service_state_e service_state = -1;
3093 vc_client_get_service_state(g_vc, &service_state);
3094 if (service_state != VC_SERVICE_STATE_READY) {
3095 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3096 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3097 return VC_ERROR_INVALID_STATE;
3100 SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts cancel, pid(%d), utt_id(%d)", pid, utt_id);
3102 ret = vc_data_clear_tts_data_by_uttid(utt_id);
3104 SLOG(LOG_INFO, TAG_VCC, "[INFO] There's no data in client pcm queue");
3108 bool is_prepared = false;
3110 ret = vc_dbus_cancel_tts(pid, utt_id);
3112 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3113 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3114 if (0 == vc_prepare_sync()) {
3116 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3118 } else if (VC_ERROR_TIMED_OUT != ret) {
3119 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel tts to vc service : %s", __vc_get_error_code(ret));
3122 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel tts : %s", __vc_get_error_code(ret));
3125 if (VC_RETRY_COUNT == count) {
3126 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel");
3133 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3138 int vc_tts_get_audio_format(int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type)
3144 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get tts audio format");
3146 if (0 != __vc_get_feature_enabled()) {
3147 return VC_ERROR_NOT_SUPPORTED;
3149 if (0 != __vc_check_privilege()) {
3150 return VC_ERROR_PERMISSION_DENIED;
3153 if (0 != vc_client_get_client_state(g_vc, &state)) {
3154 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3155 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3156 return VC_ERROR_INVALID_STATE;
3160 if (state != VC_STATE_READY) {
3161 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3162 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3163 return VC_ERROR_INVALID_STATE;
3166 /* Check service state */
3167 vc_service_state_e service_state = -1;
3168 vc_client_get_service_state(g_vc, &service_state);
3169 if (service_state != VC_SERVICE_STATE_READY) {
3170 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3171 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3172 return VC_ERROR_INVALID_STATE;
3175 SLOG(LOG_DEBUG, TAG_VCC, "@@@ get tts audio format, pid(%d)", pid);
3178 bool is_prepared = false;
3180 ret = vc_dbus_get_tts_audio_format(pid, rate, channel, audio_type);
3182 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3183 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3184 if (0 == vc_prepare_sync()) {
3186 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3188 } else if (VC_ERROR_TIMED_OUT != ret) {
3189 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format : %s", __vc_get_error_code(ret));
3192 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to get tts audio format : %s", __vc_get_error_code(ret));
3195 if (VC_RETRY_COUNT == count) {
3196 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format");
3203 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3208 int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
3210 if (0 != __vc_get_feature_enabled()) {
3211 return VC_ERROR_NOT_SUPPORTED;
3213 if (0 != __vc_check_privilege()) {
3214 return VC_ERROR_PERMISSION_DENIED;
3217 if (NULL == callback)
3218 return VC_ERROR_INVALID_PARAMETER;
3221 if (0 != vc_client_get_client_state(g_vc, &state)) {
3222 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : A handle is not available");
3223 return VC_ERROR_INVALID_STATE;
3227 if (state != VC_STATE_INITIALIZED) {
3228 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : Current state(%d) is not 'Initialized'", state);
3229 return VC_ERROR_INVALID_STATE;
3232 vc_client_set_tts_streaming_cb(g_vc, callback, user_data);
3237 int vc_tts_unset_streaming_cb(void)
3239 if (0 != __vc_get_feature_enabled()) {
3240 return VC_ERROR_NOT_SUPPORTED;
3242 if (0 != __vc_check_privilege()) {
3243 return VC_ERROR_PERMISSION_DENIED;
3247 if (0 != vc_client_get_client_state(g_vc, &state)) {
3248 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : A handle is not available");
3249 return VC_ERROR_INVALID_STATE;
3253 if (state != VC_STATE_INITIALIZED) {
3254 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : Current state(%d) is not 'Initialized'", state);
3255 return VC_ERROR_INVALID_STATE;
3258 vc_client_set_tts_streaming_cb(g_vc, NULL, NULL);
3263 int __vc_cb_utterance_status(int utt_id, int utt_status)
3265 vc_tts_utterance_status_cb callback = NULL;
3266 void* user_data = NULL;
3268 vc_client_get_tts_utterance_status_cb(g_vc, &callback, &user_data);
3269 if (NULL == callback) {
3270 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Utterance status callback is null");
3274 SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
3275 vc_client_use_callback(g_vc);
3276 callback(utt_id, (vc_tts_utterance_status_e)utt_status);
3277 vc_client_not_use_callback(g_vc);
3282 int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
3284 if (0 != __vc_get_feature_enabled()) {
3285 return VC_ERROR_NOT_SUPPORTED;
3287 if (0 != __vc_check_privilege()) {
3288 return VC_ERROR_PERMISSION_DENIED;
3291 if (NULL == callback)
3292 return VC_ERROR_INVALID_PARAMETER;
3295 if (0 != vc_client_get_client_state(g_vc, &state)) {
3296 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : A handle is not available");
3297 return VC_ERROR_INVALID_STATE;
3301 if (state != VC_STATE_INITIALIZED) {
3302 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3303 return VC_ERROR_INVALID_STATE;
3306 vc_client_set_tts_utterance_status_cb(g_vc, callback, user_data);
3311 int vc_tts_unset_utterance_status_cb(void)
3313 if (0 != __vc_get_feature_enabled()) {
3314 return VC_ERROR_NOT_SUPPORTED;
3316 if (0 != __vc_check_privilege()) {
3317 return VC_ERROR_PERMISSION_DENIED;
3321 if (0 != vc_client_get_client_state(g_vc, &state)) {
3322 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : A handle is not available");
3323 return VC_ERROR_INVALID_STATE;
3327 if (state != VC_STATE_INITIALIZED) {
3328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3329 return VC_ERROR_INVALID_STATE;
3332 vc_client_set_tts_utterance_status_cb(g_vc, NULL, NULL);