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"
33 #include "vc_info_parser.h"
34 #include "vc_json_parser.h"
36 #include "voice_control.h"
37 #include "voice_control_internal.h"
38 #include "voice_control_authority.h"
39 #include "voice_control_command.h"
40 #include "voice_control_command_expand.h"
44 static Ecore_Timer* g_connect_timer = NULL;
46 static Ecore_Event_Handler* g_focus_in_handler = NULL;
47 static Ecore_Event_Handler* g_focus_out_handler = NULL;
49 static vc_h g_vc = NULL;
51 static int g_daemon_pid = 0;
53 static int g_feature_enabled = -1;
54 static bool g_backup = false;
56 static int g_privilege_allowed = -1;
57 static cynara *p_cynara = NULL;
59 static void __vc_notify_state_changed(void *data);
60 static void __vc_notify_error(void *data);
62 static int __vc_get_feature_enabled()
64 if (0 == g_feature_enabled) {
66 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
67 return VC_ERROR_NOT_SUPPORTED;
69 } else if (-1 == g_feature_enabled) {
70 bool vc_supported = false;
71 bool mic_supported = false;
72 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
73 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
74 if (false == vc_supported || false == mic_supported) {
75 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
76 g_feature_enabled = 0;
77 return VC_ERROR_NOT_SUPPORTED;
80 g_feature_enabled = 1;
82 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
83 return VC_ERROR_NOT_SUPPORTED;
86 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value"); //LCOV_EXCL_LINE
87 return VC_ERROR_NOT_SUPPORTED;
94 static int __check_privilege_initialize()
96 int ret = cynara_initialize(&p_cynara, NULL);
97 if (CYNARA_API_SUCCESS != ret)
98 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize"); //LCOV_EXCL_LINE
100 return ret == CYNARA_API_SUCCESS;
103 static int __check_privilege(const char* uid, const char * privilege)
106 char label_path[1024] = "/proc/self/attr/current";
107 char smack_label[1024] = {'\0',};
113 fp = fopen(label_path, "r");
115 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
116 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread"); //LCOV_EXCL_LINE
121 pid_t pid = getpid();
122 char *session = cynara_session_from_pid(pid);
123 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
124 SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
128 if (ret != CYNARA_API_ACCESS_ALLOWED)
133 static void __check_privilege_deinitialize()
136 cynara_finish(p_cynara);
140 static int __vc_check_privilege()
144 if (0 == g_privilege_allowed) {
146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
147 return VC_ERROR_PERMISSION_DENIED;
149 } else if (-1 == g_privilege_allowed) {
150 if (false == __check_privilege_initialize()) {
151 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed"); //LCOV_EXCL_LINE
152 return VC_ERROR_PERMISSION_DENIED;
154 snprintf(uid, 16, "%d", getuid());
155 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
156 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
157 g_privilege_allowed = 0;
158 __check_privilege_deinitialize();
159 return VC_ERROR_PERMISSION_DENIED;
161 __check_privilege_deinitialize();
164 g_privilege_allowed = 1;
165 return VC_ERROR_NONE;
169 static const char* __vc_get_error_code(vc_error_e err)
172 case VC_ERROR_NONE: return "VC_ERROR_NONE";
173 case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY";
174 case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR";
175 case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER";
176 case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT";
177 case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY";
178 case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE";
179 case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE";
180 case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
181 case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
182 default: return "Invalid error code";
187 static int __vc_convert_config_error_code(vc_config_error_e code)
189 if (code == VC_CONFIG_ERROR_NONE) return VC_ERROR_NONE;
190 if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY) return VC_ERROR_OUT_OF_MEMORY;
191 if (code == VC_CONFIG_ERROR_IO_ERROR) return VC_ERROR_IO_ERROR;
192 if (code == VC_CONFIG_ERROR_INVALID_PARAMETER) return VC_ERROR_INVALID_PARAMETER;
193 if (code == VC_CONFIG_ERROR_INVALID_STATE) return VC_ERROR_INVALID_STATE;
194 if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE) return VC_ERROR_INVALID_LANGUAGE;
195 if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND) return VC_ERROR_ENGINE_NOT_FOUND;
196 if (code == VC_CONFIG_ERROR_OPERATION_FAILED) return VC_ERROR_OPERATION_FAILED;
198 return VC_ERROR_NONE;
201 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
203 SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
204 before_lang, current_lang);
206 vc_current_language_changed_cb callback;
207 void* lang_user_data;
208 vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
210 if (NULL != callback) {
211 vc_client_use_callback(g_vc);
212 callback(before_lang, current_lang, lang_user_data);
213 vc_client_not_use_callback(g_vc);
214 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
216 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
222 static Eina_Bool __notify_auth_changed_cb(void *data)
224 vc_auth_state_changed_cb callback = NULL;
227 vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
229 vc_auth_state_e before = -1;
230 vc_auth_state_e current = -1;
232 vc_client_get_before_auth_state(g_vc, &before, ¤t);
234 if (NULL != callback) {
235 vc_client_use_callback(g_vc);
236 callback(before, current, user_data);
237 vc_client_not_use_callback(g_vc);
238 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
240 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
246 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
248 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
251 if (ECORE_WL_EVENT_FOCUS_IN == type) {
252 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
253 ret = vc_dbus_set_foreground(getpid(), true);
255 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
258 ret = vc_client_set_is_foreground(g_vc, true);
260 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
263 /* set authority valid */
264 vc_auth_state_e state = VC_AUTH_STATE_NONE;
265 if (0 != vc_client_get_auth_state(g_vc, &state)) {
266 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
268 if (VC_AUTH_STATE_INVALID == state) {
269 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
271 /* notify auth changed cb */
272 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
274 } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
275 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
276 ret = vc_dbus_set_foreground(getpid(), false);
278 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
281 ret = vc_client_set_is_foreground(g_vc, false);
283 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
286 /* set authority valid */
287 vc_auth_state_e state = VC_AUTH_STATE_NONE;
288 if (0 != vc_client_get_auth_state(g_vc, &state)) {
289 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
291 if (VC_AUTH_STATE_VALID == state) {
292 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
294 /* notify authority changed cb */
295 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
298 SLOG(LOG_DEBUG, TAG_VCC, "@@@ type(%d) is NOT valid", type);
301 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
303 return ECORE_CALLBACK_RENEW;
307 int vc_initialize(void)
309 if (0 != __vc_get_feature_enabled()) {
310 return VC_ERROR_NOT_SUPPORTED;
312 if (0 != __vc_check_privilege()) {
313 return VC_ERROR_PERMISSION_DENIED;
316 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Initialize");
319 if (true == vc_client_is_valid(g_vc)) {
320 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
321 return VC_ERROR_NONE; //LCOV_EXCL_LINE
324 if (0 < vc_client_get_count()) {
325 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
326 return VC_ERROR_NONE; //LCOV_EXCL_LINE
329 if (0 != vc_dbus_open_connection()) {
330 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection"); //LCOV_EXCL_LINE
331 return VC_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
334 if (0 != vc_client_create(&g_vc)) {
335 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!"); //LCOV_EXCL_LINE
336 return VC_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
339 int ret = vc_config_mgr_initialize(g_vc->handle);
341 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
342 __vc_get_error_code(__vc_convert_config_error_code(ret))); //LCOV_EXCL_LINE
343 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
344 return __vc_convert_config_error_code(ret); //LCOV_EXCL_LINE
347 ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
349 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret); //LCOV_EXCL_LINE
350 vc_config_mgr_finalize(g_vc->handle); //LCOV_EXCL_LINE
351 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
352 return __vc_convert_config_error_code(ret);
355 ret = vc_db_initialize();
357 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret); //LCOV_EXCL_LINE
358 vc_config_mgr_finalize(g_vc->handle); //LCOV_EXCL_LINE
359 vc_client_destroy(g_vc); //LCOV_EXCL_LINE
363 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
365 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
367 return VC_ERROR_NONE;
370 static void __vc_internal_unprepare(void)
372 /* return authority */
373 vc_auth_state_e state = VC_AUTH_STATE_NONE;
374 if (0 != vc_client_get_auth_state(g_vc, &state)) {
375 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
378 if (VC_AUTH_STATE_NONE != state) {
379 if (0 != vc_auth_disable()) {
380 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable"); //LCOV_EXCL_LINE
384 int ret = vc_dbus_request_finalize(g_vc->handle);
386 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
389 if (NULL != g_focus_in_handler) {
390 ecore_event_handler_del(g_focus_in_handler);
391 g_focus_in_handler = NULL;
393 if (NULL != g_focus_out_handler) {
394 ecore_event_handler_del(g_focus_out_handler);
395 g_focus_out_handler = NULL;
398 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
400 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
405 int vc_deinitialize(void)
407 int ret = VC_ERROR_NONE;
409 if (0 != __vc_get_feature_enabled()) {
410 return VC_ERROR_NOT_SUPPORTED;
412 if (0 != __vc_check_privilege()) {
413 return VC_ERROR_PERMISSION_DENIED;
416 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize");
418 if (false == vc_client_is_valid(g_vc)) {
419 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
420 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
421 return VC_ERROR_INVALID_STATE;
425 vc_client_get_client_state(g_vc, &state);
430 __vc_internal_unprepare();
431 /* no break. need to next step*/
432 case VC_STATE_INITIALIZED:
433 if (NULL != g_connect_timer) {
434 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted"); //LCOV_EXCL_LINE
435 ecore_timer_del(g_connect_timer);
436 g_connect_timer = NULL;
439 vc_config_mgr_unset_lang_cb(g_vc->handle);
440 vc_config_mgr_finalize(g_vc->handle);
442 /* Free client resources */
443 vc_client_destroy(g_vc);
450 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
452 if (true == g_backup) {
453 ret = vc_db_backup_command();
455 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to backup command, ret(%d)", ret); //LCOV_EXCL_LINE
459 ret = vc_db_finalize();
461 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret); //LCOV_EXCL_LINE
464 if (0 != vc_dbus_close_connection()) {
465 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE
468 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
470 return VC_ERROR_NONE;
473 static Eina_Bool __vc_connect_daemon(void *data)
476 if (0 != vc_dbus_request_hello()) {
480 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
482 /* request initialization */
485 int service_state = 0;
487 g_connect_timer = NULL;
489 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
491 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
494 if (true == vc_client_is_valid(g_vc)) {
495 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] g_vc is valid");
497 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
499 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
500 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
502 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
503 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
505 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
508 } else if (0 != ret) {
509 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
511 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
512 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
514 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
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 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
541 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
543 char appid[1024] = {'\0',};
544 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
546 int status = aul_app_get_status(appid);
547 if (STATUS_FOCUS == status) {
548 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground"); //LCOV_EXCL_LINE
549 ret = vc_dbus_set_foreground(getpid(), true);
551 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE
554 ret = vc_client_set_is_foreground(g_vc, true);
556 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret); //LCOV_EXCL_LINE
559 /* set authority valid */
560 vc_auth_state_e state = VC_AUTH_STATE_NONE;
561 if (0 != vc_client_get_auth_state(g_vc, &state)) {
562 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
564 if (VC_AUTH_STATE_INVALID == state) {
565 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
567 /* notify auth changed cb */
568 ecore_idler_add(__notify_auth_changed_cb, NULL);
572 vc_client_set_client_state(g_vc, VC_STATE_READY);
573 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
575 vc_client_set_mgr_pid(g_vc, mgr_pid);
577 SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] g_vc is not valid. It is destroyed."); //LCOV_EXCL_LINE
581 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
586 static void __start_prepare_thread(void *data, Ecore_Thread *thread)
588 SLOG(LOG_ERROR, TAG_VCC, "@@@ Start prepare thread");
589 int ret = -1, retry_count = 0;
593 if (retry_count == 10) {
594 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
598 ret = vc_dbus_request_hello();
600 SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
610 if (retry_count == 10) {
611 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!"); //LCOV_EXCL_LINE
614 ret = __vc_connect_daemon(NULL);
624 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
626 SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
631 if (0 != __vc_get_feature_enabled()) {
632 return VC_ERROR_NOT_SUPPORTED;
634 if (0 != __vc_check_privilege()) {
635 return VC_ERROR_PERMISSION_DENIED;
638 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
641 if (0 != vc_client_get_client_state(g_vc, &state)) {
642 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available"); //LCOV_EXCL_LINE
643 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
644 return VC_ERROR_INVALID_STATE;
648 if (state != VC_STATE_INITIALIZED) {
649 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'"); //LCOV_EXCL_LINE
650 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
651 return VC_ERROR_INVALID_STATE;
654 ecore_thread_run(__start_prepare_thread, __end_prepare_thread, NULL, NULL);
656 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
658 return VC_ERROR_NONE;
662 int vc_prepare_sync(void)
664 if (0 != __vc_get_feature_enabled()) {
665 return VC_ERROR_NOT_SUPPORTED;
667 if (0 != __vc_check_privilege()) {
668 return VC_ERROR_PERMISSION_DENIED;
671 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
674 if (0 != vc_client_get_client_state(g_vc, &state)) {
675 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
676 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
677 return VC_ERROR_INVALID_STATE;
681 if (state != VC_STATE_INITIALIZED) {
682 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'INITIALIZED'");
683 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
684 return VC_ERROR_INVALID_STATE;
688 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
692 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
694 if (VC_CONNECTION_RETRY_COUNT == cnt) {
695 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
696 return VC_ERROR_OPERATION_FAILED;
699 return VC_ERROR_NONE;
703 int vc_unprepare(void)
705 if (0 != __vc_get_feature_enabled()) {
706 return VC_ERROR_NOT_SUPPORTED;
708 if (0 != __vc_check_privilege()) {
709 return VC_ERROR_PERMISSION_DENIED;
712 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
715 if (0 != vc_client_get_client_state(g_vc, &state)) {
716 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
717 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
718 return VC_ERROR_INVALID_STATE;
722 if (state != VC_STATE_READY) {
723 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
724 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
725 return VC_ERROR_INVALID_STATE;
728 __vc_internal_unprepare();
730 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
731 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
733 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
735 return VC_ERROR_NONE;
738 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
740 if (0 != __vc_get_feature_enabled()) {
741 return VC_ERROR_NOT_SUPPORTED;
743 if (0 != __vc_check_privilege()) {
744 return VC_ERROR_PERMISSION_DENIED;
747 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
749 if (NULL == callback) {
750 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
751 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
752 return VC_ERROR_INVALID_PARAMETER;
756 if (0 != vc_client_get_client_state(g_vc, &state)) {
757 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
758 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
759 return VC_ERROR_INVALID_STATE;
763 ret = vc_config_mgr_get_language_list(callback, user_data);
765 ret = vc_config_convert_error_code((vc_config_error_e)ret);
766 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
769 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
771 return VC_ERROR_NONE;
775 int vc_get_current_language(char** language)
777 if (0 != __vc_get_feature_enabled()) {
778 return VC_ERROR_NOT_SUPPORTED;
780 if (0 != __vc_check_privilege()) {
781 return VC_ERROR_PERMISSION_DENIED;
784 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
786 if (NULL == language) {
787 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
788 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
789 return VC_ERROR_INVALID_PARAMETER;
793 if (0 != vc_client_get_client_state(g_vc, &state)) {
794 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
795 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
796 return VC_ERROR_INVALID_STATE;
800 ret = vc_config_mgr_get_default_language(language);
802 ret = vc_config_convert_error_code((vc_config_error_e)ret);
803 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
806 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
811 int vc_get_state(vc_state_e* state)
813 if (0 != __vc_get_feature_enabled()) {
814 return VC_ERROR_NOT_SUPPORTED;
816 if (0 != __vc_check_privilege()) {
817 return VC_ERROR_PERMISSION_DENIED;
820 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
823 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
824 return VC_ERROR_INVALID_PARAMETER;
828 if (0 != vc_client_get_client_state(g_vc, &temp)) {
829 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
830 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
831 return VC_ERROR_INVALID_STATE;
838 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
839 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
840 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
841 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
845 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
847 return VC_ERROR_NONE;
850 int vc_get_service_state(vc_service_state_e* state)
852 if (0 != __vc_get_feature_enabled()) {
853 return VC_ERROR_NOT_SUPPORTED;
855 if (0 != __vc_check_privilege()) {
856 return VC_ERROR_PERMISSION_DENIED;
859 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
862 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
863 return VC_ERROR_INVALID_PARAMETER;
867 if (0 != vc_client_get_client_state(g_vc, &temp)) {
868 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
869 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
870 return VC_ERROR_INVALID_STATE;
873 if (VC_STATE_READY != temp) {
874 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
875 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
876 return VC_ERROR_INVALID_STATE;
879 /* get service state */
880 vc_service_state_e service_state;
881 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
882 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state"); //LCOV_EXCL_LINE
883 return VC_ERROR_OPERATION_FAILED;
886 *state = service_state;
890 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
891 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
892 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
893 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
894 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
898 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
900 return VC_ERROR_NONE;
903 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
905 if (0 != __vc_get_feature_enabled()) {
906 return VC_ERROR_NOT_SUPPORTED;
908 if (0 != __vc_check_privilege()) {
909 return VC_ERROR_PERMISSION_DENIED;
912 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
914 if (NULL == vc_sys_cmd_list) {
915 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
916 return VC_ERROR_INVALID_PARAMETER;
920 if (0 != vc_client_get_client_state(g_vc, &state)) {
921 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
922 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
923 return VC_ERROR_INVALID_STATE;
927 if (state != VC_STATE_READY) {
928 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
929 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
930 return VC_ERROR_INVALID_STATE;
933 /* Check service state */
934 vc_service_state_e service_state = -1;
935 vc_client_get_service_state(g_vc, &service_state);
936 if (service_state != VC_SERVICE_STATE_READY) {
937 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
938 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
939 return VC_ERROR_INVALID_STATE;
942 bool is_sys_cmd_valid = false;
945 bool is_prepared = false;
947 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
950 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
951 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
952 if (0 == vc_prepare_sync()) {
954 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
956 } else if (VC_ERROR_TIMED_OUT != ret) {
957 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
960 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
963 if (VC_RETRY_COUNT == count) {
964 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
973 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
975 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid"); //LCOV_EXCL_LINE
976 return VC_ERROR_OPERATION_FAILED;
979 vc_cmd_list_s* list = NULL;
980 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
981 if (true == is_sys_cmd_valid) {
982 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
984 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
987 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
989 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands"); //LCOV_EXCL_LINE
992 *vc_sys_cmd_list = (vc_cmd_list_h)list;
994 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands"); //LCOV_EXCL_LINE
995 *vc_sys_cmd_list = NULL;
996 return VC_ERROR_NONE;
999 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1006 * @brief Checks whether the command format is supported.
1007 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
1009 * @param[in] format The command format
1010 * @param[out] support The result status @c true = supported, @c false = not supported
1012 * @return 0 on success, otherwise a negative error value
1013 * @retval #VC_ERROR_NONE Successful
1014 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1015 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
1016 * @retval #VC_ERROR_INVALID_STATE Invalid state
1018 * @pre The state should be #VC_STATE_READY.
1020 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
1022 if (0 != __vc_get_feature_enabled()) {
1023 return VC_ERROR_NOT_SUPPORTED;
1025 if (0 != __vc_check_privilege()) {
1026 return VC_ERROR_PERMISSION_DENIED;
1029 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
1032 if (0 != vc_client_get_client_state(g_vc, &state)) {
1033 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1034 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1035 return VC_ERROR_INVALID_STATE;
1039 bool non_fixed_support = false;
1040 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1041 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1045 case VC_CMD_FORMAT_FIXED: *support = true; break;
1046 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
1047 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
1048 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
1049 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
1050 default: *support = false; break;
1053 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1055 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1057 return VC_ERROR_NONE;
1061 static int __vc_get_invocation_name(char** invocation_name)
1063 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
1065 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name"); //LCOV_EXCL_LINE
1066 return ret; //LCOV_EXCL_LINE
1069 if (NULL == *invocation_name) {
1070 char* temp_label = NULL;
1074 ret = app_manager_get_app_id(getpid(), &appid);
1075 if (0 != ret || NULL == appid) {
1076 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret); //LCOV_EXCL_LINE
1077 if (NULL != appid) {
1081 return VC_ERROR_OPERATION_FAILED;
1084 ret = vc_get_current_language(&lang);
1085 if (0 != ret || NULL == lang) {
1086 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current language, ret(%d)", ret); //LCOV_EXCL_LINE
1093 return VC_ERROR_OPERATION_FAILED;
1096 ret = app_info_get_localed_label(appid, lang, &temp_label);
1097 if (0 != ret || NULL == temp_label) {
1098 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang); //LCOV_EXCL_LINE
1103 if (NULL != temp_label) {
1107 return VC_ERROR_OPERATION_FAILED;
1110 *invocation_name = strdup(temp_label);
1111 if (NULL == *invocation_name) {
1112 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
1113 return VC_ERROR_OUT_OF_MEMORY;
1124 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1125 return VC_ERROR_NONE;
1128 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1130 if (0 != __vc_get_feature_enabled()) {
1131 return VC_ERROR_NOT_SUPPORTED;
1133 if (0 != __vc_check_privilege()) {
1134 return VC_ERROR_PERMISSION_DENIED;
1137 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1139 if (NULL == vc_cmd_list) {
1140 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1141 return VC_ERROR_INVALID_PARAMETER;
1145 if (0 != vc_client_get_client_state(g_vc, &state)) {
1146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1147 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1148 return VC_ERROR_INVALID_STATE;
1152 if (state != VC_STATE_READY) {
1153 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1154 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1155 return VC_ERROR_INVALID_STATE;
1159 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1160 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type); //LCOV_EXCL_LINE
1161 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1162 return VC_ERROR_INVALID_PARAMETER;
1165 vc_cmd_list_s* list = NULL;
1166 list = (vc_cmd_list_s*)vc_cmd_list;
1168 if (NULL == list->list) {
1169 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list"); //LCOV_EXCL_LINE
1170 return VC_ERROR_INVALID_PARAMETER;
1174 char* invocation_name = NULL;
1175 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1176 ret = __vc_get_invocation_name(&invocation_name);
1177 if (0 != ret || NULL == invocation_name) {
1178 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret); //LCOV_EXCL_LINE
1183 ret = vc_cmd_parser_delete_file(getpid(), type);
1185 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1187 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1189 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1192 bool is_prepared = false;
1194 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1197 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1198 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1199 if (0 == vc_prepare_sync()) {
1201 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1203 } else if (VC_ERROR_TIMED_OUT != ret) {
1204 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1207 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1210 if (VC_RETRY_COUNT == count) {
1211 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1220 if (NULL != invocation_name) {
1221 free(invocation_name);
1222 invocation_name = NULL;
1225 if (VC_COMMAND_TYPE_BACKGROUND == type)
1228 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1233 int vc_unset_command_list(int type)
1235 if (0 != __vc_get_feature_enabled()) {
1236 return VC_ERROR_NOT_SUPPORTED;
1238 if (0 != __vc_check_privilege()) {
1239 return VC_ERROR_PERMISSION_DENIED;
1242 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1245 if (0 != vc_client_get_client_state(g_vc, &state)) {
1246 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1247 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1248 return VC_ERROR_INVALID_STATE;
1252 if (state != VC_STATE_READY) {
1253 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1254 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1255 return VC_ERROR_INVALID_STATE;
1260 bool is_prepared = false;
1262 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1265 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1266 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1267 if (0 == vc_prepare_sync()) {
1269 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1271 } else if (VC_ERROR_TIMED_OUT != ret) {
1272 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1275 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1278 if (VC_RETRY_COUNT == count) {
1279 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1287 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1289 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1290 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret)); //LCOV_EXCL_LINE
1293 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1299 int vc_set_command_list_from_file(const char* file_path, int type)
1301 if (0 != __vc_get_feature_enabled()) {
1302 return VC_ERROR_NOT_SUPPORTED;
1304 if (0 != __vc_check_privilege()) {
1305 return VC_ERROR_PERMISSION_DENIED;
1308 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1311 if (0 != vc_client_get_client_state(g_vc, &state)) {
1312 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1313 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1314 return VC_ERROR_INVALID_STATE;
1318 if (state != VC_STATE_READY) {
1319 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1320 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1321 return VC_ERROR_INVALID_STATE;
1325 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1326 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1327 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1328 return VC_ERROR_INVALID_PARAMETER;
1332 char* invocation_name = NULL;
1333 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1334 ret = __vc_get_invocation_name(&invocation_name);
1335 if (0 != ret || NULL == invocation_name) {
1336 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1341 ret = vc_cmd_parser_delete_file(getpid(), type);
1343 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1345 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1347 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1350 bool is_prepared = false;
1352 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1355 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1356 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1357 if (0 == vc_prepare_sync()) {
1359 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1361 } else if (VC_ERROR_TIMED_OUT != ret) {
1362 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1365 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1368 if (VC_RETRY_COUNT == count) {
1369 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1378 if (NULL != invocation_name) {
1379 free(invocation_name);
1380 invocation_name = NULL;
1383 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1389 int vc_get_exclusive_command_option(bool* value)
1391 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1394 if (0 != vc_client_get_client_state(g_vc, &state)) {
1395 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1396 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1397 return VC_ERROR_INVALID_STATE;
1401 if (state != VC_STATE_READY) {
1402 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1403 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1404 return VC_ERROR_INVALID_STATE;
1407 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1409 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1410 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1414 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1419 int vc_set_exclusive_command_option(bool value)
1421 if (0 != __vc_get_feature_enabled()) {
1422 return VC_ERROR_NOT_SUPPORTED;
1424 if (0 != __vc_check_privilege()) {
1425 return VC_ERROR_PERMISSION_DENIED;
1428 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1431 if (0 != vc_client_get_client_state(g_vc, &state)) {
1432 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1433 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1434 return VC_ERROR_INVALID_STATE;
1438 if (state != VC_STATE_READY) {
1439 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1440 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1441 return VC_ERROR_INVALID_STATE;
1444 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1446 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1447 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1453 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1455 if (VC_ERROR_TIMED_OUT != ret) {
1456 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1459 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1462 if (VC_RETRY_COUNT == count) {
1463 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1470 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1477 int vc_request_start(bool stop_by_silence)
1479 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1482 if (0 != vc_client_get_client_state(g_vc, &state)) {
1483 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1484 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1485 return VC_ERROR_INVALID_STATE;
1489 if (state != VC_STATE_READY) {
1490 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1491 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1492 return VC_ERROR_INVALID_STATE;
1495 /* Check service state */
1496 vc_service_state_e service_state = -1;
1497 vc_client_get_service_state(g_vc, &service_state);
1498 if (service_state != VC_SERVICE_STATE_READY) {
1499 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1500 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1501 return VC_ERROR_INVALID_STATE;
1511 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1513 if (VC_ERROR_TIMED_OUT != ret) {
1514 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1517 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1520 if (VC_RETRY_COUNT == count) {
1521 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1526 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1530 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1535 int vc_request_stop(void)
1537 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1540 if (0 != vc_client_get_client_state(g_vc, &state)) {
1541 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1542 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1543 return VC_ERROR_INVALID_STATE;
1547 if (state != VC_STATE_READY) {
1548 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1549 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1550 return VC_ERROR_INVALID_STATE;
1553 /* Check service state */
1554 vc_service_state_e service_state = -1;
1555 vc_client_get_service_state(g_vc, &service_state);
1556 if (service_state != VC_SERVICE_STATE_RECORDING) {
1557 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1558 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1559 return VC_ERROR_INVALID_STATE;
1566 ret = vc_dbus_request_stop(g_vc->handle);
1568 if (VC_ERROR_TIMED_OUT != ret) {
1569 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1572 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1575 if (VC_RETRY_COUNT == count) {
1576 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1581 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1585 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1590 int vc_request_cancel(void)
1592 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1595 if (0 != vc_client_get_client_state(g_vc, &state)) {
1596 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1597 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1598 return VC_ERROR_INVALID_STATE;
1602 if (state != VC_STATE_READY) {
1603 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1604 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1605 return VC_ERROR_INVALID_STATE;
1608 /* Check service state */
1609 vc_service_state_e service_state = -1;
1610 vc_client_get_service_state(g_vc, &service_state);
1611 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1612 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1613 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1614 return VC_ERROR_INVALID_STATE;
1620 ret = vc_dbus_request_cancel(g_vc->handle);
1622 if (VC_ERROR_TIMED_OUT != ret) {
1623 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1626 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1629 if (VC_RETRY_COUNT == count) {
1630 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1635 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1639 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1646 static void __vc_notify_error(void *data)
1648 vc_h vc = (vc_h)data;
1650 vc_error_cb callback = NULL;
1654 vc_client_get_error_cb(vc, &callback, &user_data);
1655 vc_client_get_error(vc, &reason);
1657 if (NULL != callback) {
1658 vc_client_use_callback(vc);
1659 callback(reason, user_data);
1660 vc_client_not_use_callback(vc);
1661 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1663 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1667 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1670 if (0 != vc_client_get_client_state(g_vc, &state)) {
1671 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1676 if (state != VC_STATE_READY) {
1677 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] State is not READY");
1678 if (VC_ERROR_SERVICE_RESET != reason) {
1679 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1685 if (VC_ERROR_SERVICE_RESET == reason) {
1686 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1688 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1689 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
1691 if (0 != vc_prepare()) {
1692 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1696 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1698 vc_client_set_error(g_vc, reason);
1699 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
1704 static void __vc_notify_state_changed(void *data)
1706 vc_h vc = (vc_h)data;
1708 vc_state_changed_cb changed_callback = NULL;
1711 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1713 vc_state_e current_state;
1714 vc_state_e before_state;
1716 vc_client_get_before_state(vc, ¤t_state, &before_state);
1718 if (NULL != changed_callback) {
1719 vc_client_use_callback(vc);
1720 changed_callback(before_state, current_state, user_data);
1721 vc_client_not_use_callback(vc);
1722 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1724 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1728 static Eina_Bool __vc_notify_result(void *data)
1732 vc_cmd_list_h vc_cmd_list = NULL;
1734 vc_result_cb callback = NULL;
1735 void* user_data = NULL;
1737 vc_client_get_result_cb(g_vc, &callback, &user_data);
1739 if (NULL == callback) {
1740 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1744 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1745 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1749 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1751 SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1753 vc_cmd_print_list(vc_cmd_list);
1755 vc_client_use_callback(g_vc);
1756 callback(event, vc_cmd_list, temp_text, user_data);
1757 vc_client_not_use_callback(g_vc);
1759 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1761 vc_cmd_list_destroy(vc_cmd_list, true);
1763 /* Release result */
1764 if (NULL != temp_text) free(temp_text);
1769 void __vc_cb_result(void)
1771 ecore_timer_add(0, __vc_notify_result, NULL);
1777 int vc_get_result(vc_result_cb callback, void* user_data)
1779 if (0 != __vc_get_feature_enabled()) {
1780 return VC_ERROR_NOT_SUPPORTED;
1782 if (0 != __vc_check_privilege()) {
1783 return VC_ERROR_PERMISSION_DENIED;
1786 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1789 if (0 != vc_client_get_client_state(g_vc, &state)) {
1790 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1791 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1792 return VC_ERROR_INVALID_STATE;
1796 if (state != VC_STATE_READY) {
1797 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1798 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
1799 return VC_ERROR_INVALID_STATE;
1802 if (NULL == callback) {
1803 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL"); //LCOV_EXCL_LINE
1804 return VC_ERROR_INVALID_PARAMETER;
1807 char* temp_text = NULL;
1809 vc_cmd_list_h vc_cmd_list = NULL;
1811 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1812 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1813 return VC_ERROR_INVALID_PARAMETER;
1816 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1817 if (0 != ret || NULL == temp_text) {
1818 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text); //LCOV_EXCL_LINE
1822 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event); //LCOV_EXCL_LINE
1824 vc_cmd_print_list(vc_cmd_list);
1826 vc_client_use_callback(g_vc);
1827 callback(event, vc_cmd_list, temp_text, user_data);
1828 vc_client_not_use_callback(g_vc);
1830 vc_cmd_list_destroy(vc_cmd_list, true);
1832 /* Release result */
1833 if (NULL != temp_text) {
1838 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1840 return VC_ERROR_NONE;
1843 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1845 if (0 != __vc_get_feature_enabled()) {
1846 return VC_ERROR_NOT_SUPPORTED;
1848 if (0 != __vc_check_privilege()) {
1849 return VC_ERROR_PERMISSION_DENIED;
1852 if (NULL == callback)
1853 return VC_ERROR_INVALID_PARAMETER;
1856 if (0 != vc_client_get_client_state(g_vc, &state)) {
1857 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1858 return VC_ERROR_INVALID_STATE;
1862 if (state != VC_STATE_INITIALIZED) {
1863 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1864 return VC_ERROR_INVALID_STATE;
1867 vc_client_set_result_cb(g_vc, callback, user_data);
1872 int vc_unset_result_cb(void)
1874 if (0 != __vc_get_feature_enabled()) {
1875 return VC_ERROR_NOT_SUPPORTED;
1877 if (0 != __vc_check_privilege()) {
1878 return VC_ERROR_PERMISSION_DENIED;
1882 if (0 != vc_client_get_client_state(g_vc, &state)) {
1883 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1884 return VC_ERROR_INVALID_STATE;
1888 if (state != VC_STATE_INITIALIZED) {
1889 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1890 return VC_ERROR_INVALID_STATE;
1893 vc_client_set_result_cb(g_vc, NULL, NULL);
1899 int __vc_cb_service_state(int state)
1901 vc_service_state_e current_state = (vc_service_state_e)state;
1902 vc_service_state_e before_state;
1903 vc_client_get_service_state(g_vc, &before_state);
1905 if (current_state == before_state) {
1909 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1910 before_state, current_state);
1912 /* Save service state */
1913 vc_client_set_service_state(g_vc, current_state);
1915 vc_service_state_changed_cb callback = NULL;
1916 void* service_user_data;
1917 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1919 if (NULL != callback) {
1920 vc_client_use_callback(g_vc);
1921 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1922 vc_client_not_use_callback(g_vc);
1923 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1925 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1932 int __vc_cb_manager_pid(int manager_pid)
1934 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
1936 /* Save service state */
1937 vc_client_set_mgr_pid(g_vc, manager_pid);
1942 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1944 if (0 != __vc_get_feature_enabled()) {
1945 return VC_ERROR_NOT_SUPPORTED;
1947 if (0 != __vc_check_privilege()) {
1948 return VC_ERROR_PERMISSION_DENIED;
1951 if (NULL == callback)
1952 return VC_ERROR_INVALID_PARAMETER;
1955 if (0 != vc_client_get_client_state(g_vc, &state)) {
1956 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1957 return VC_ERROR_INVALID_STATE;
1961 if (state != VC_STATE_INITIALIZED) {
1962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1963 return VC_ERROR_INVALID_STATE;
1966 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1971 int vc_unset_service_state_changed_cb(void)
1973 if (0 != __vc_get_feature_enabled()) {
1974 return VC_ERROR_NOT_SUPPORTED;
1976 if (0 != __vc_check_privilege()) {
1977 return VC_ERROR_PERMISSION_DENIED;
1981 if (0 != vc_client_get_client_state(g_vc, &state)) {
1982 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1983 return VC_ERROR_INVALID_STATE;
1987 if (state != VC_STATE_INITIALIZED) {
1988 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1989 return VC_ERROR_INVALID_STATE;
1992 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1997 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1999 if (0 != __vc_get_feature_enabled()) {
2000 return VC_ERROR_NOT_SUPPORTED;
2002 if (0 != __vc_check_privilege()) {
2003 return VC_ERROR_PERMISSION_DENIED;
2006 if (callback == NULL)
2007 return VC_ERROR_INVALID_PARAMETER;
2010 if (0 != vc_client_get_client_state(g_vc, &state)) {
2011 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
2012 return VC_ERROR_INVALID_STATE;
2016 if (state != VC_STATE_INITIALIZED) {
2017 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2018 return VC_ERROR_INVALID_STATE;
2021 vc_client_set_state_changed_cb(g_vc, callback, user_data);
2026 int vc_unset_state_changed_cb(void)
2028 if (0 != __vc_get_feature_enabled()) {
2029 return VC_ERROR_NOT_SUPPORTED;
2031 if (0 != __vc_check_privilege()) {
2032 return VC_ERROR_PERMISSION_DENIED;
2036 if (0 != vc_client_get_client_state(g_vc, &state)) {
2037 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
2038 return VC_ERROR_INVALID_STATE;
2042 if (state != VC_STATE_INITIALIZED) {
2043 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2044 return VC_ERROR_INVALID_STATE;
2047 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
2052 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2054 if (0 != __vc_get_feature_enabled()) {
2055 return VC_ERROR_NOT_SUPPORTED;
2057 if (0 != __vc_check_privilege()) {
2058 return VC_ERROR_PERMISSION_DENIED;
2061 if (NULL == callback)
2062 return VC_ERROR_INVALID_PARAMETER;
2065 if (0 != vc_client_get_client_state(g_vc, &state)) {
2066 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
2067 return VC_ERROR_INVALID_STATE;
2071 if (state != VC_STATE_INITIALIZED) {
2072 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
2073 return VC_ERROR_INVALID_STATE;
2076 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2081 int vc_unset_current_language_changed_cb(void)
2083 if (0 != __vc_get_feature_enabled()) {
2084 return VC_ERROR_NOT_SUPPORTED;
2086 if (0 != __vc_check_privilege()) {
2087 return VC_ERROR_PERMISSION_DENIED;
2091 if (0 != vc_client_get_client_state(g_vc, &state)) {
2092 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2093 return VC_ERROR_INVALID_STATE;
2097 if (state != VC_STATE_INITIALIZED) {
2098 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2099 return VC_ERROR_INVALID_STATE;
2102 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2107 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2109 if (0 != __vc_get_feature_enabled()) {
2110 return VC_ERROR_NOT_SUPPORTED;
2112 if (0 != __vc_check_privilege()) {
2113 return VC_ERROR_PERMISSION_DENIED;
2116 if (NULL == callback)
2117 return VC_ERROR_INVALID_PARAMETER;
2120 if (0 != vc_client_get_client_state(g_vc, &state)) {
2121 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2122 return VC_ERROR_INVALID_STATE;
2126 if (state != VC_STATE_INITIALIZED) {
2127 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
2128 return VC_ERROR_INVALID_STATE;
2131 vc_client_set_error_cb(g_vc, callback, user_data);
2136 int vc_unset_error_cb(void)
2138 if (0 != __vc_get_feature_enabled()) {
2139 return VC_ERROR_NOT_SUPPORTED;
2141 if (0 != __vc_check_privilege()) {
2142 return VC_ERROR_PERMISSION_DENIED;
2146 if (0 != vc_client_get_client_state(g_vc, &state)) {
2147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2148 return VC_ERROR_INVALID_STATE;
2152 if (state != VC_STATE_INITIALIZED) {
2153 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2154 return VC_ERROR_INVALID_STATE;
2157 vc_client_set_error_cb(g_vc, NULL, NULL);
2162 int vc_set_invocation_name(const char* name)
2164 if (0 != __vc_get_feature_enabled()) {
2165 return VC_ERROR_NOT_SUPPORTED;
2167 if (0 != __vc_check_privilege()) {
2168 return VC_ERROR_PERMISSION_DENIED;
2172 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2174 int ret = vc_client_get_client_state(g_vc, &state);
2176 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2177 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2182 if (state != VC_STATE_READY) {
2183 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2184 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2185 return VC_ERROR_INVALID_STATE;
2188 ret = vc_client_set_invocation_name(g_vc, name);
2190 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2196 int vc_set_server_dialog(const char* app_id, const char* credential)
2201 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2202 if (0 != __vc_get_feature_enabled()) {
2203 return VC_ERROR_NOT_SUPPORTED;
2205 if (0 != __vc_check_privilege()) {
2206 return VC_ERROR_PERMISSION_DENIED;
2209 if (NULL == credential) {
2210 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Credential is NULL");
2211 return VC_ERROR_INVALID_PARAMETER;
2214 if (0 != vc_client_get_client_state(g_vc, &state)) {
2215 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2216 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2217 return VC_ERROR_INVALID_STATE;
2221 if (state != VC_STATE_READY) {
2222 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2223 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2224 return VC_ERROR_INVALID_STATE;
2227 /* Check service state */
2228 vc_service_state_e service_state = -1;
2229 vc_client_get_service_state(g_vc, &service_state);
2230 if (service_state != VC_SERVICE_STATE_READY) {
2231 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2232 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2233 return VC_ERROR_INVALID_STATE;
2236 char* tmp_appid = NULL;
2237 if (NULL == app_id) {
2238 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2239 if (0 != ret || NULL == tmp_appid) {
2240 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2241 if (NULL != tmp_appid)
2243 return VC_ERROR_INVALID_PARAMETER;
2246 tmp_appid = strdup(app_id);
2250 SLOG(LOG_DEBUG, TAG_VCC, "Set server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2253 bool is_prepared = false;
2255 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2257 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2258 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2259 if (0 == vc_prepare_sync()) {
2261 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2263 } else if (VC_ERROR_TIMED_OUT != ret) {
2264 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set server dialog to vc service : %s", __vc_get_error_code(ret));
2267 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set server dialog : %s", __vc_get_error_code(ret));
2270 if (VC_RETRY_COUNT == count) {
2271 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2279 if (NULL != tmp_appid)
2282 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2287 int vc_unset_server_dialog(const char* app_id)
2292 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2293 if (0 != __vc_get_feature_enabled()) {
2294 return VC_ERROR_NOT_SUPPORTED;
2296 if (0 != __vc_check_privilege()) {
2297 return VC_ERROR_PERMISSION_DENIED;
2300 if (0 != vc_client_get_client_state(g_vc, &state)) {
2301 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2302 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2303 return VC_ERROR_INVALID_STATE;
2307 if (state != VC_STATE_READY) {
2308 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2309 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2310 return VC_ERROR_INVALID_STATE;
2313 /* Check service state */
2314 vc_service_state_e service_state = -1;
2315 vc_client_get_service_state(g_vc, &service_state);
2316 if (service_state != VC_SERVICE_STATE_READY) {
2317 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2318 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2319 return VC_ERROR_INVALID_STATE;
2322 char* tmp_appid = NULL;
2323 if (NULL == app_id) {
2324 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2325 if (0 != ret || NULL == tmp_appid) {
2326 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2327 if (NULL != tmp_appid)
2329 return VC_ERROR_INVALID_PARAMETER;
2332 tmp_appid = strdup(app_id);
2336 SLOG(LOG_DEBUG, TAG_VCC, "Unset server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2339 bool is_prepared = false;
2340 char* credential = strdup("#NULL");
2342 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2344 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2345 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2346 if (0 == vc_prepare_sync()) {
2348 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2350 } else if (VC_ERROR_TIMED_OUT != ret) {
2351 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset server dialog to vc service : %s", __vc_get_error_code(ret));
2354 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset server dialog : %s", __vc_get_error_code(ret));
2357 if (VC_RETRY_COUNT == count) {
2358 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2366 if (NULL != tmp_appid)
2368 if (NULL != credential)
2371 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2377 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2381 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2382 if (0 != __vc_get_feature_enabled()) {
2383 return VC_ERROR_NOT_SUPPORTED;
2385 if (0 != __vc_check_privilege()) {
2386 return VC_ERROR_PERMISSION_DENIED;
2389 if (0 != vc_client_get_client_state(g_vc, &state)) {
2390 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2391 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2392 return VC_ERROR_INVALID_STATE;
2396 if (state != VC_STATE_READY) {
2397 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
2398 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2399 return VC_ERROR_INVALID_STATE;
2402 /* Check service state */
2403 vc_service_state_e service_state = -1;
2404 vc_client_get_service_state(g_vc, &service_state);
2405 if (service_state != VC_SERVICE_STATE_READY) {
2406 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
2407 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2408 return VC_ERROR_INVALID_STATE;
2411 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);
2412 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret);
2415 return VC_ERROR_OPERATION_FAILED;
2418 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2420 return VC_ERROR_NONE;
2425 int vc_auth_enable(void)
2429 if (0 != vc_client_get_client_state(g_vc, &state)) {
2430 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2431 return VC_ERROR_INVALID_STATE;
2434 if (VC_STATE_READY != state) {
2435 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2436 return VC_ERROR_INVALID_STATE;
2439 /* check already authority */
2440 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2441 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2442 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2443 return VC_ERROR_INVALID_STATE;
2446 if (VC_AUTH_STATE_NONE != auth_state) {
2447 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2448 return VC_ERROR_INVALID_STATE;
2451 /* request authority */
2453 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2454 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2455 return VC_ERROR_OPERATION_FAILED;
2458 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2459 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2460 return VC_ERROR_OPERATION_FAILED;
2463 /* set authority into handle */
2464 bool is_foreground = false;
2465 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2466 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2467 return VC_ERROR_OPERATION_FAILED;
2470 if (is_foreground) {
2471 auth_state = VC_AUTH_STATE_VALID;
2473 auth_state = VC_AUTH_STATE_INVALID;
2476 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2477 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2478 return VC_ERROR_OPERATION_FAILED;
2481 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2483 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2485 return VC_ERROR_NONE;
2488 int vc_auth_disable(void)
2492 if (0 != vc_client_get_client_state(g_vc, &state)) {
2493 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2494 return VC_ERROR_INVALID_STATE;
2497 if (VC_STATE_READY != state) {
2498 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2499 return VC_ERROR_INVALID_STATE;
2502 /* check authority */
2503 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2504 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2505 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2506 return VC_ERROR_INVALID_STATE;
2509 if (VC_AUTH_STATE_NONE == auth_state) {
2510 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2511 return VC_ERROR_INVALID_STATE;
2514 if (0 != vc_auth_unset_state_changed_cb()) {
2515 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2518 /* request return authority by dbus */
2520 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2521 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2522 return VC_ERROR_OPERATION_FAILED;
2525 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2526 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
2527 return VC_ERROR_OPERATION_FAILED;
2530 /* unset authority from handle */
2531 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2532 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2533 return VC_ERROR_OPERATION_FAILED;
2536 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2538 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2540 return VC_ERROR_NONE;
2543 int vc_auth_get_state(vc_auth_state_e* state)
2546 vc_state_e vc_state;
2547 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2548 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2549 return VC_ERROR_INVALID_STATE;
2552 if (VC_STATE_READY != vc_state) {
2553 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2554 return VC_ERROR_INVALID_STATE;
2558 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2559 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2560 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2561 return VC_ERROR_INVALID_STATE;
2566 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2568 return VC_ERROR_NONE;
2571 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2573 /* check parameter */
2574 if (NULL == callback) {
2575 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2576 return VC_ERROR_INVALID_PARAMETER;
2580 vc_auth_state_e auth_state;
2581 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2582 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2583 return VC_ERROR_INVALID_STATE;
2586 if (VC_AUTH_STATE_NONE == auth_state) {
2587 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2588 return VC_ERROR_INVALID_STATE;
2591 /* set cb into handle */
2592 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2593 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2594 return VC_ERROR_OPERATION_FAILED;
2597 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2599 return VC_ERROR_NONE;
2602 int vc_auth_unset_state_changed_cb(void)
2605 vc_auth_state_e auth_state;
2606 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2607 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2608 return VC_ERROR_INVALID_STATE;
2611 if (VC_AUTH_STATE_NONE == auth_state) {
2612 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2613 return VC_ERROR_INVALID_STATE;
2616 /* unset cb from handle */
2617 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2618 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2619 return VC_ERROR_OPERATION_FAILED;
2622 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2624 return VC_ERROR_NONE;
2627 int vc_auth_start(void)
2629 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2632 if (0 != vc_client_get_client_state(g_vc, &state)) {
2633 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2634 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2635 return VC_ERROR_INVALID_STATE;
2639 if (state != VC_STATE_READY) {
2640 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2641 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2642 return VC_ERROR_INVALID_STATE;
2645 /* Check service state */
2646 vc_service_state_e service_state = -1;
2647 vc_client_get_service_state(g_vc, &service_state);
2648 if (service_state != VC_SERVICE_STATE_READY) {
2649 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2650 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2651 return VC_ERROR_INVALID_STATE;
2654 /* Check authority */
2655 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2656 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2657 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2658 return VC_ERROR_OPERATION_FAILED;
2661 if (VC_AUTH_STATE_VALID != auth_state) {
2662 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2663 return VC_ERROR_OPERATION_FAILED;
2668 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2669 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2670 return VC_ERROR_OPERATION_FAILED;
2675 bool is_prepared = false;
2678 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2680 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2681 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2682 if (0 == vc_prepare_sync()) {
2684 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2686 } else if (VC_ERROR_TIMED_OUT != ret) {
2687 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2690 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2693 if (VC_RETRY_COUNT == count) {
2694 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2699 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2703 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2708 int vc_auth_stop(void)
2710 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2713 if (0 != vc_client_get_client_state(g_vc, &state)) {
2714 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2715 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2716 return VC_ERROR_INVALID_STATE;
2720 if (state != VC_STATE_READY) {
2721 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2722 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2723 return VC_ERROR_INVALID_STATE;
2726 /* Check service state */
2727 vc_service_state_e service_state = -1;
2728 vc_client_get_service_state(g_vc, &service_state);
2729 if (service_state != VC_SERVICE_STATE_RECORDING) {
2730 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2731 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2732 return VC_ERROR_INVALID_STATE;
2735 /* Check authority */
2736 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2737 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2738 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2739 return VC_ERROR_OPERATION_FAILED;
2742 if (VC_AUTH_STATE_VALID != auth_state) {
2743 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2744 return VC_ERROR_OPERATION_FAILED;
2749 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2750 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2751 return VC_ERROR_OPERATION_FAILED;
2756 bool is_prepared = false;
2759 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2761 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2762 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2763 if (0 == vc_prepare_sync()) {
2765 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2767 } else if (VC_ERROR_TIMED_OUT != ret) {
2768 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2771 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2774 if (VC_RETRY_COUNT == count) {
2775 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2780 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2784 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2789 int vc_auth_cancel(void)
2791 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2794 if (0 != vc_client_get_client_state(g_vc, &state)) {
2795 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2796 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2797 return VC_ERROR_INVALID_STATE;
2801 if (state != VC_STATE_READY) {
2802 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2803 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2804 return VC_ERROR_INVALID_STATE;
2807 /* Check service state */
2808 vc_service_state_e service_state = -1;
2809 vc_client_get_service_state(g_vc, &service_state);
2810 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2811 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2812 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2813 return VC_ERROR_INVALID_STATE;
2816 /* Check authority */
2817 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2818 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2819 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2820 return VC_ERROR_OPERATION_FAILED;
2823 if (VC_AUTH_STATE_VALID != auth_state) {
2824 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2825 return VC_ERROR_OPERATION_FAILED;
2830 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2831 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2832 return VC_ERROR_OPERATION_FAILED;
2837 bool is_prepared = false;
2839 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2841 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2842 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2843 if (0 == vc_prepare_sync()) {
2845 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2847 } else if (VC_ERROR_TIMED_OUT != ret) {
2848 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2851 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2854 if (VC_RETRY_COUNT == count) {
2855 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2860 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2864 SLOG(LOG_DEBUG, TAG_VCC, "@@@");