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) {
65 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
66 return VC_ERROR_NOT_SUPPORTED;
67 } else if (-1 == g_feature_enabled) {
68 bool vc_supported = false;
69 bool mic_supported = false;
70 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
71 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
72 if (false == vc_supported || false == mic_supported) {
73 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
74 g_feature_enabled = 0;
75 return VC_ERROR_NOT_SUPPORTED;
78 g_feature_enabled = 1;
80 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
81 return VC_ERROR_NOT_SUPPORTED;
84 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
85 return VC_ERROR_NOT_SUPPORTED;
92 static int __check_privilege_initialize()
94 int ret = cynara_initialize(&p_cynara, NULL);
95 if (CYNARA_API_SUCCESS != ret)
96 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize");
98 return ret == CYNARA_API_SUCCESS;
101 static int __check_privilege(const char* uid, const char * privilege)
104 char label_path[1024] = "/proc/self/attr/current";
105 char smack_label[1024] = {'\0',};
111 fp = fopen(label_path, "r");
113 if (strlen(smack_label) != fread(smack_label, 1, sizeof(smack_label), fp))
114 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread");
119 pid_t pid = getpid();
120 char *session = cynara_session_from_pid(pid);
121 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
122 SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
126 if (ret != CYNARA_API_ACCESS_ALLOWED)
131 static void __check_privilege_deinitialize()
134 cynara_finish(p_cynara);
138 static int __vc_check_privilege()
142 if (0 == g_privilege_allowed) {
143 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
144 return VC_ERROR_PERMISSION_DENIED;
145 } else if (-1 == g_privilege_allowed) {
146 if (false == __check_privilege_initialize()) {
147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
148 return VC_ERROR_PERMISSION_DENIED;
150 snprintf(uid, 16, "%d", getuid());
151 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
152 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
153 g_privilege_allowed = 0;
154 __check_privilege_deinitialize();
155 return VC_ERROR_PERMISSION_DENIED;
157 __check_privilege_deinitialize();
160 g_privilege_allowed = 1;
161 return VC_ERROR_NONE;
164 static const char* __vc_get_error_code(vc_error_e err)
167 case VC_ERROR_NONE: return "VC_ERROR_NONE";
168 case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY";
169 case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR";
170 case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER";
171 case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT";
172 case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY";
173 case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE";
174 case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE";
175 case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
176 case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
177 default: return "Invalid error code";
182 static int __vc_convert_config_error_code(vc_config_error_e code)
184 if (code == VC_CONFIG_ERROR_NONE) return VC_ERROR_NONE;
185 if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY) return VC_ERROR_OUT_OF_MEMORY;
186 if (code == VC_CONFIG_ERROR_IO_ERROR) return VC_ERROR_IO_ERROR;
187 if (code == VC_CONFIG_ERROR_INVALID_PARAMETER) return VC_ERROR_INVALID_PARAMETER;
188 if (code == VC_CONFIG_ERROR_INVALID_STATE) return VC_ERROR_INVALID_STATE;
189 if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE) return VC_ERROR_INVALID_LANGUAGE;
190 if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND) return VC_ERROR_ENGINE_NOT_FOUND;
191 if (code == VC_CONFIG_ERROR_OPERATION_FAILED) return VC_ERROR_OPERATION_FAILED;
193 return VC_ERROR_NONE;
196 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
198 SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
199 before_lang, current_lang);
201 vc_current_language_changed_cb callback;
202 void* lang_user_data;
203 vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
205 if (NULL != callback) {
206 vc_client_use_callback(g_vc);
207 callback(before_lang, current_lang, lang_user_data);
208 vc_client_not_use_callback(g_vc);
209 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
211 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
217 static Eina_Bool __notify_auth_changed_cb(void *data)
219 vc_auth_state_changed_cb callback = NULL;
222 vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
224 vc_auth_state_e before = -1;
225 vc_auth_state_e current = -1;
227 vc_client_get_before_auth_state(g_vc, &before, ¤t);
229 if (NULL != callback) {
230 vc_client_use_callback(g_vc);
231 callback(before, current, user_data);
232 vc_client_not_use_callback(g_vc);
233 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
235 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
241 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
243 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
246 if (ECORE_WL_EVENT_FOCUS_IN == type) {
247 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
248 ret = vc_dbus_set_foreground(getpid(), true);
250 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
253 ret = vc_client_set_is_foreground(g_vc, true);
255 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
258 /* set authority valid */
259 vc_auth_state_e state = VC_AUTH_STATE_NONE;
260 if (0 != vc_client_get_auth_state(g_vc, &state)) {
261 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
263 if (VC_AUTH_STATE_INVALID == state) {
264 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
266 /* notify auth changed cb */
267 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
269 } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
270 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
271 ret = vc_dbus_set_foreground(getpid(), false);
273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
276 ret = vc_client_set_is_foreground(g_vc, false);
278 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
281 /* set authority valid */
282 vc_auth_state_e state = VC_AUTH_STATE_NONE;
283 if (0 != vc_client_get_auth_state(g_vc, &state)) {
284 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
286 if (VC_AUTH_STATE_VALID == state) {
287 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
289 /* notify authority changed cb */
290 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
293 SLOG(LOG_DEBUG, TAG_VCC, "@@@ type(%d) is NOT valid", type);
296 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
298 return ECORE_CALLBACK_RENEW;
301 int vc_initialize(void)
303 if (0 != __vc_get_feature_enabled()) {
304 return VC_ERROR_NOT_SUPPORTED;
306 if (0 != __vc_check_privilege()) {
307 return VC_ERROR_PERMISSION_DENIED;
310 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Initialize");
313 if (true == vc_client_is_valid(g_vc)) {
314 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
315 return VC_ERROR_NONE;
318 if (0 < vc_client_get_count()) {
319 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
320 return VC_ERROR_NONE;
323 if (0 != vc_dbus_open_connection()) {
324 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
325 return VC_ERROR_OPERATION_FAILED;
328 if (0 != vc_client_create(&g_vc)) {
329 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
330 return VC_ERROR_OUT_OF_MEMORY;
333 int ret = vc_config_mgr_initialize(g_vc->handle);
335 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
336 __vc_get_error_code(__vc_convert_config_error_code(ret)));
337 vc_client_destroy(g_vc);
338 return __vc_convert_config_error_code(ret);
341 ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
343 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
344 vc_config_mgr_finalize(g_vc->handle);
345 vc_client_destroy(g_vc);
346 return __vc_convert_config_error_code(ret);
349 ret = vc_db_initialize();
351 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret);
352 vc_config_mgr_finalize(g_vc->handle);
353 vc_client_destroy(g_vc);
357 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
359 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
361 return VC_ERROR_NONE;
364 static void __vc_internal_unprepare(void)
366 /* return authority */
367 vc_auth_state_e state = VC_AUTH_STATE_NONE;
368 if (0 != vc_client_get_auth_state(g_vc, &state)) {
369 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
372 if (VC_AUTH_STATE_NONE != state) {
373 if (0 != vc_auth_disable()) {
374 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
378 int ret = vc_dbus_request_finalize(g_vc->handle);
380 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
383 if (NULL != g_focus_in_handler) {
384 ecore_event_handler_del(g_focus_in_handler);
385 g_focus_in_handler = NULL;
387 if (NULL != g_focus_out_handler) {
388 ecore_event_handler_del(g_focus_out_handler);
389 g_focus_out_handler = NULL;
392 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
394 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
399 int vc_deinitialize(void)
401 int ret = VC_ERROR_NONE;
403 if (0 != __vc_get_feature_enabled()) {
404 return VC_ERROR_NOT_SUPPORTED;
406 if (0 != __vc_check_privilege()) {
407 return VC_ERROR_PERMISSION_DENIED;
410 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize");
412 if (false == vc_client_is_valid(g_vc)) {
413 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
414 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
415 return VC_ERROR_INVALID_STATE;
419 vc_client_get_client_state(g_vc, &state);
424 __vc_internal_unprepare();
425 /* no break. need to next step*/
426 case VC_STATE_INITIALIZED:
427 if (NULL != g_connect_timer) {
428 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
429 ecore_timer_del(g_connect_timer);
430 g_connect_timer = NULL;
433 vc_config_mgr_unset_lang_cb(g_vc->handle);
434 vc_config_mgr_finalize(g_vc->handle);
436 /* Free client resources */
437 vc_client_destroy(g_vc);
444 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
446 if (true == g_backup) {
447 ret = vc_db_backup_command();
449 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to backup command, ret(%d)", ret);
453 ret = vc_db_finalize();
455 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret);
458 if (0 != vc_dbus_close_connection()) {
459 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
462 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
464 return VC_ERROR_NONE;
467 static Eina_Bool __vc_connect_daemon(void *data)
470 if (0 != vc_dbus_request_hello()) {
474 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
476 /* request initialization */
479 int service_state = 0;
481 g_connect_timer = NULL;
483 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
485 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
488 if (true == vc_client_is_valid(g_vc)) {
489 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] g_vc is valid");
491 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
492 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
493 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
495 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
496 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
498 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
501 } else if (0 != ret) {
502 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
504 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
505 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
507 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
510 /* Success to connect */
513 /* Set service state */
514 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
516 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
517 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
519 char appid[1024] = {'\0',};
520 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
522 int status = aul_app_get_status(appid);
523 if (STATUS_FOCUS == status) {
524 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
525 ret = vc_dbus_set_foreground(getpid(), true);
527 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
530 ret = vc_client_set_is_foreground(g_vc, true);
532 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
535 /* set authority valid */
536 vc_auth_state_e state = VC_AUTH_STATE_NONE;
537 if (0 != vc_client_get_auth_state(g_vc, &state)) {
538 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
540 if (VC_AUTH_STATE_INVALID == state) {
541 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
543 /* notify auth changed cb */
544 ecore_idler_add(__notify_auth_changed_cb, NULL);
548 vc_client_set_client_state(g_vc, VC_STATE_READY);
549 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
551 vc_client_set_mgr_pid(g_vc, mgr_pid);
553 SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] g_vc is not valid. It is destroyed.");
557 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
562 static void __start_prepare_thread(void *data, Ecore_Thread *thread)
564 SLOG(LOG_ERROR, TAG_VCC, "@@@ Start prepare thread");
565 int ret = -1, retry_count = 0;
570 if (retry_count == 10) {
571 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!");
575 ret = vc_dbus_request_hello();
577 SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
587 if (retry_count == 10) {
588 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!");
591 ret = __vc_connect_daemon(NULL);
601 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
603 SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
608 if (0 != __vc_get_feature_enabled()) {
609 return VC_ERROR_NOT_SUPPORTED;
611 if (0 != __vc_check_privilege()) {
612 return VC_ERROR_PERMISSION_DENIED;
615 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
618 if (0 != vc_client_get_client_state(g_vc, &state)) {
619 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
620 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
621 return VC_ERROR_INVALID_STATE;
625 if (state != VC_STATE_INITIALIZED) {
626 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
627 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
628 return VC_ERROR_INVALID_STATE;
631 ecore_thread_run(__start_prepare_thread, __end_prepare_thread, NULL, NULL);
633 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
635 return VC_ERROR_NONE;
638 int vc_prepare_sync(void)
640 if (0 != __vc_get_feature_enabled()) {
641 return VC_ERROR_NOT_SUPPORTED;
643 if (0 != __vc_check_privilege()) {
644 return VC_ERROR_PERMISSION_DENIED;
647 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
650 if (0 != vc_client_get_client_state(g_vc, &state)) {
651 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
652 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
653 return VC_ERROR_INVALID_STATE;
657 if (state != VC_STATE_INITIALIZED) {
658 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
659 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
660 return VC_ERROR_INVALID_STATE;
664 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
668 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
670 if (VC_CONNECTION_RETRY_COUNT == cnt) {
671 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
672 return VC_ERROR_OPERATION_FAILED;
675 return VC_ERROR_NONE;
678 int vc_unprepare(void)
680 if (0 != __vc_get_feature_enabled()) {
681 return VC_ERROR_NOT_SUPPORTED;
683 if (0 != __vc_check_privilege()) {
684 return VC_ERROR_PERMISSION_DENIED;
687 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
690 if (0 != vc_client_get_client_state(g_vc, &state)) {
691 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
692 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
693 return VC_ERROR_INVALID_STATE;
697 if (state != VC_STATE_READY) {
698 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
699 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
700 return VC_ERROR_INVALID_STATE;
703 __vc_internal_unprepare();
705 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
706 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
708 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
710 return VC_ERROR_NONE;
713 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
715 if (0 != __vc_get_feature_enabled()) {
716 return VC_ERROR_NOT_SUPPORTED;
718 if (0 != __vc_check_privilege()) {
719 return VC_ERROR_PERMISSION_DENIED;
722 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
724 if (NULL == callback) {
725 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
726 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
727 return VC_ERROR_INVALID_PARAMETER;
731 if (0 != vc_client_get_client_state(g_vc, &state)) {
732 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
733 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
734 return VC_ERROR_INVALID_STATE;
738 ret = vc_config_mgr_get_language_list(callback, user_data);
740 ret = vc_config_convert_error_code((vc_config_error_e)ret);
741 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
744 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
746 return VC_ERROR_NONE;
750 int vc_get_current_language(char** language)
752 if (0 != __vc_get_feature_enabled()) {
753 return VC_ERROR_NOT_SUPPORTED;
755 if (0 != __vc_check_privilege()) {
756 return VC_ERROR_PERMISSION_DENIED;
759 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
761 if (NULL == language) {
762 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
763 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
764 return VC_ERROR_INVALID_PARAMETER;
768 if (0 != vc_client_get_client_state(g_vc, &state)) {
769 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
770 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
771 return VC_ERROR_INVALID_STATE;
775 ret = vc_config_mgr_get_default_language(language);
777 ret = vc_config_convert_error_code((vc_config_error_e)ret);
778 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
781 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
786 int vc_get_state(vc_state_e* state)
788 if (0 != __vc_get_feature_enabled()) {
789 return VC_ERROR_NOT_SUPPORTED;
791 if (0 != __vc_check_privilege()) {
792 return VC_ERROR_PERMISSION_DENIED;
795 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
798 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
799 return VC_ERROR_INVALID_PARAMETER;
803 if (0 != vc_client_get_client_state(g_vc, &temp)) {
804 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
805 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
806 return VC_ERROR_INVALID_STATE;
812 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
813 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
814 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
815 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
818 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
820 return VC_ERROR_NONE;
823 int vc_get_service_state(vc_service_state_e* state)
825 if (0 != __vc_get_feature_enabled()) {
826 return VC_ERROR_NOT_SUPPORTED;
828 if (0 != __vc_check_privilege()) {
829 return VC_ERROR_PERMISSION_DENIED;
832 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
835 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
836 return VC_ERROR_INVALID_PARAMETER;
840 if (0 != vc_client_get_client_state(g_vc, &temp)) {
841 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
842 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
843 return VC_ERROR_INVALID_STATE;
846 if (VC_STATE_READY != temp) {
847 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
848 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
849 return VC_ERROR_INVALID_STATE;
852 /* get service state */
853 vc_service_state_e service_state;
854 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
855 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
856 return VC_ERROR_OPERATION_FAILED;
859 *state = service_state;
862 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
863 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
864 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
865 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
866 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
869 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
871 return VC_ERROR_NONE;
874 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
876 if (0 != __vc_get_feature_enabled()) {
877 return VC_ERROR_NOT_SUPPORTED;
879 if (0 != __vc_check_privilege()) {
880 return VC_ERROR_PERMISSION_DENIED;
883 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
885 if (NULL == vc_sys_cmd_list) {
886 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
887 return VC_ERROR_INVALID_PARAMETER;
891 if (0 != vc_client_get_client_state(g_vc, &state)) {
892 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
893 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
894 return VC_ERROR_INVALID_STATE;
898 if (state != VC_STATE_READY) {
899 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
900 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
901 return VC_ERROR_INVALID_STATE;
904 /* Check service state */
905 vc_service_state_e service_state = -1;
906 vc_client_get_service_state(g_vc, &service_state);
907 if (service_state != VC_SERVICE_STATE_READY) {
908 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
909 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
910 return VC_ERROR_INVALID_STATE;
913 bool is_sys_cmd_valid = false;
918 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
920 if (VC_ERROR_TIMED_OUT != ret) {
921 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
924 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
927 if (VC_RETRY_COUNT == count) {
928 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
936 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
938 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
939 return VC_ERROR_OPERATION_FAILED;
942 vc_cmd_list_s* list = NULL;
943 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
944 if (true == is_sys_cmd_valid) {
945 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
947 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
950 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
952 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
955 *vc_sys_cmd_list = (vc_cmd_list_h)list;
957 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
958 *vc_sys_cmd_list = NULL;
959 return VC_ERROR_NONE;
962 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
968 * @brief Checks whether the command format is supported.
969 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
971 * @param[in] format The command format
972 * @param[out] support The result status @c true = supported, @c false = not supported
974 * @return 0 on success, otherwise a negative error value
975 * @retval #VC_ERROR_NONE Successful
976 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
977 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
978 * @retval #VC_ERROR_INVALID_STATE Invalid state
980 * @pre The state should be #VC_STATE_READY.
982 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
984 if (0 != __vc_get_feature_enabled()) {
985 return VC_ERROR_NOT_SUPPORTED;
987 if (0 != __vc_check_privilege()) {
988 return VC_ERROR_PERMISSION_DENIED;
991 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
994 if (0 != vc_client_get_client_state(g_vc, &state)) {
995 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
996 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
997 return VC_ERROR_INVALID_STATE;
1001 bool non_fixed_support = false;
1002 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1003 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1007 case VC_CMD_FORMAT_FIXED: *support = true; break;
1008 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
1009 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
1010 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
1011 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
1012 default: *support = false; break;
1015 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1017 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1019 return VC_ERROR_NONE;
1022 static int __vc_get_invocation_name(char** invocation_name)
1024 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
1026 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
1030 if (NULL == *invocation_name) {
1031 char* temp_label = NULL;
1035 ret = app_manager_get_app_id(getpid(), &appid);
1036 if (0 != ret || NULL == appid) {
1037 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
1038 if (NULL != appid) {
1042 return VC_ERROR_OPERATION_FAILED;
1045 ret = vc_get_current_language(&lang);
1046 if (0 != ret || NULL == lang) {
1047 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
1054 return VC_ERROR_OPERATION_FAILED;
1057 ret = app_info_get_localed_label(appid, lang, &temp_label);
1058 if (0 != ret || NULL == temp_label) {
1059 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
1064 if (NULL != temp_label) {
1068 return VC_ERROR_OPERATION_FAILED;
1071 *invocation_name = strdup(temp_label);
1072 if (NULL == *invocation_name) {
1073 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1074 return VC_ERROR_OUT_OF_MEMORY;
1085 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1086 return VC_ERROR_NONE;
1089 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1091 if (0 != __vc_get_feature_enabled()) {
1092 return VC_ERROR_NOT_SUPPORTED;
1094 if (0 != __vc_check_privilege()) {
1095 return VC_ERROR_PERMISSION_DENIED;
1098 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1100 if (NULL == vc_cmd_list) {
1101 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1102 return VC_ERROR_INVALID_PARAMETER;
1106 if (0 != vc_client_get_client_state(g_vc, &state)) {
1107 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1108 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1109 return VC_ERROR_INVALID_STATE;
1113 if (state != VC_STATE_READY) {
1114 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1115 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1116 return VC_ERROR_INVALID_STATE;
1120 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1121 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1122 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1123 return VC_ERROR_INVALID_PARAMETER;
1126 vc_cmd_list_s* list = NULL;
1127 list = (vc_cmd_list_s*)vc_cmd_list;
1129 if (NULL == list->list) {
1130 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list");
1131 return VC_ERROR_INVALID_PARAMETER;
1135 char* invocation_name = NULL;
1136 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1137 ret = __vc_get_invocation_name(&invocation_name);
1138 if (0 != ret || NULL == invocation_name) {
1139 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1144 ret = vc_cmd_parser_delete_file(getpid(), type);
1146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1148 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1150 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1154 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1156 if (VC_ERROR_TIMED_OUT != ret) {
1157 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1160 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1163 if (VC_RETRY_COUNT == count) {
1164 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1172 if (NULL != invocation_name) {
1173 free(invocation_name);
1174 invocation_name = NULL;
1177 if (VC_COMMAND_TYPE_BACKGROUND == type)
1180 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1185 int vc_unset_command_list(int type)
1187 if (0 != __vc_get_feature_enabled()) {
1188 return VC_ERROR_NOT_SUPPORTED;
1190 if (0 != __vc_check_privilege()) {
1191 return VC_ERROR_PERMISSION_DENIED;
1194 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1197 if (0 != vc_client_get_client_state(g_vc, &state)) {
1198 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1199 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1200 return VC_ERROR_INVALID_STATE;
1204 if (state != VC_STATE_READY) {
1205 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1206 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1207 return VC_ERROR_INVALID_STATE;
1213 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1215 if (VC_ERROR_TIMED_OUT != ret) {
1216 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1219 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1222 if (VC_RETRY_COUNT == count) {
1223 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1230 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1232 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1233 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1236 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1241 int vc_set_command_list_from_file(const char* file_path, int type)
1243 if (0 != __vc_get_feature_enabled()) {
1244 return VC_ERROR_NOT_SUPPORTED;
1246 if (0 != __vc_check_privilege()) {
1247 return VC_ERROR_PERMISSION_DENIED;
1250 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1253 if (0 != vc_client_get_client_state(g_vc, &state)) {
1254 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1255 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1256 return VC_ERROR_INVALID_STATE;
1260 if (state != VC_STATE_READY) {
1261 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1262 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1263 return VC_ERROR_INVALID_STATE;
1267 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1268 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1269 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1270 return VC_ERROR_INVALID_PARAMETER;
1274 char* invocation_name = NULL;
1275 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1276 ret = __vc_get_invocation_name(&invocation_name);
1277 if (0 != ret || NULL == invocation_name) {
1278 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1283 ret = vc_cmd_parser_delete_file(getpid(), type);
1285 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1287 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1289 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1293 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1295 if (VC_ERROR_TIMED_OUT != ret) {
1296 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1299 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1302 if (VC_RETRY_COUNT == count) {
1303 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1311 if (NULL != invocation_name) {
1312 free(invocation_name);
1313 invocation_name = NULL;
1316 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1321 int vc_get_exclusive_command_option(bool* value)
1323 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1326 if (0 != vc_client_get_client_state(g_vc, &state)) {
1327 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1328 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1329 return VC_ERROR_INVALID_STATE;
1333 if (state != VC_STATE_READY) {
1334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1335 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1336 return VC_ERROR_INVALID_STATE;
1339 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1341 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1342 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1346 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1351 int vc_set_exclusive_command_option(bool value)
1353 if (0 != __vc_get_feature_enabled()) {
1354 return VC_ERROR_NOT_SUPPORTED;
1356 if (0 != __vc_check_privilege()) {
1357 return VC_ERROR_PERMISSION_DENIED;
1360 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1363 if (0 != vc_client_get_client_state(g_vc, &state)) {
1364 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1365 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1366 return VC_ERROR_INVALID_STATE;
1370 if (state != VC_STATE_READY) {
1371 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1372 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1373 return VC_ERROR_INVALID_STATE;
1376 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1378 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1379 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1385 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1387 if (VC_ERROR_TIMED_OUT != ret) {
1388 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1391 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1394 if (VC_RETRY_COUNT == count) {
1395 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1402 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1409 int vc_request_start(bool stop_by_silence)
1411 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1414 if (0 != vc_client_get_client_state(g_vc, &state)) {
1415 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1416 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1417 return VC_ERROR_INVALID_STATE;
1421 if (state != VC_STATE_READY) {
1422 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1423 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1424 return VC_ERROR_INVALID_STATE;
1427 /* Check service state */
1428 vc_service_state_e service_state = -1;
1429 vc_client_get_service_state(g_vc, &service_state);
1430 if (service_state != VC_SERVICE_STATE_READY) {
1431 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1432 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1433 return VC_ERROR_INVALID_STATE;
1443 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1445 if (VC_ERROR_TIMED_OUT != ret) {
1446 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1449 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1452 if (VC_RETRY_COUNT == count) {
1453 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1458 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1462 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1467 int vc_request_stop(void)
1469 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1472 if (0 != vc_client_get_client_state(g_vc, &state)) {
1473 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1474 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1475 return VC_ERROR_INVALID_STATE;
1479 if (state != VC_STATE_READY) {
1480 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1481 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1482 return VC_ERROR_INVALID_STATE;
1485 /* Check service state */
1486 vc_service_state_e service_state = -1;
1487 vc_client_get_service_state(g_vc, &service_state);
1488 if (service_state != VC_SERVICE_STATE_RECORDING) {
1489 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1490 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1491 return VC_ERROR_INVALID_STATE;
1498 ret = vc_dbus_request_stop(g_vc->handle);
1500 if (VC_ERROR_TIMED_OUT != ret) {
1501 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1504 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1507 if (VC_RETRY_COUNT == count) {
1508 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1513 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1517 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1522 int vc_request_cancel(void)
1524 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1527 if (0 != vc_client_get_client_state(g_vc, &state)) {
1528 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1529 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1530 return VC_ERROR_INVALID_STATE;
1534 if (state != VC_STATE_READY) {
1535 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1536 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1537 return VC_ERROR_INVALID_STATE;
1540 /* Check service state */
1541 vc_service_state_e service_state = -1;
1542 vc_client_get_service_state(g_vc, &service_state);
1543 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1544 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1545 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1546 return VC_ERROR_INVALID_STATE;
1552 ret = vc_dbus_request_cancel(g_vc->handle);
1554 if (VC_ERROR_TIMED_OUT != ret) {
1555 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1558 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1561 if (VC_RETRY_COUNT == count) {
1562 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1567 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1571 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1577 static void __vc_notify_error(void *data)
1579 vc_h vc = (vc_h)data;
1581 vc_error_cb callback = NULL;
1585 vc_client_get_error_cb(vc, &callback, &user_data);
1586 vc_client_get_error(vc, &reason);
1588 if (NULL != callback) {
1589 vc_client_use_callback(vc);
1590 callback(reason, user_data);
1591 vc_client_not_use_callback(vc);
1592 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1594 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1598 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1601 if (0 != vc_client_get_client_state(g_vc, &state)) {
1602 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1607 if (state != VC_STATE_READY) {
1608 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1612 if (VC_ERROR_SERVICE_RESET == reason) {
1613 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1615 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1616 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
1618 if (0 != vc_prepare()) {
1619 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1623 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1625 vc_client_set_error(g_vc, reason);
1626 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
1631 static void __vc_notify_state_changed(void *data)
1633 vc_h vc = (vc_h)data;
1635 vc_state_changed_cb changed_callback = NULL;
1638 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1640 vc_state_e current_state;
1641 vc_state_e before_state;
1643 vc_client_get_before_state(vc, ¤t_state, &before_state);
1645 if (NULL != changed_callback) {
1646 vc_client_use_callback(vc);
1647 changed_callback(before_state, current_state, user_data);
1648 vc_client_not_use_callback(vc);
1649 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1651 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1655 static Eina_Bool __vc_notify_result(void *data)
1659 vc_cmd_list_h vc_cmd_list = NULL;
1661 vc_result_cb callback = NULL;
1662 void* user_data = NULL;
1664 vc_client_get_result_cb(g_vc, &callback, &user_data);
1666 if (NULL == callback) {
1667 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1671 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1672 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1676 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1678 SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1680 vc_cmd_print_list(vc_cmd_list);
1682 vc_client_use_callback(g_vc);
1683 callback(event, vc_cmd_list, temp_text, user_data);
1684 vc_client_not_use_callback(g_vc);
1686 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1688 vc_cmd_list_destroy(vc_cmd_list, true);
1690 /* Release result */
1691 if (NULL != temp_text) free(temp_text);
1696 void __vc_cb_result(void)
1698 ecore_timer_add(0, __vc_notify_result, NULL);
1703 int vc_get_result(vc_result_cb callback, void* user_data)
1705 if (0 != __vc_get_feature_enabled()) {
1706 return VC_ERROR_NOT_SUPPORTED;
1708 if (0 != __vc_check_privilege()) {
1709 return VC_ERROR_PERMISSION_DENIED;
1712 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1715 if (0 != vc_client_get_client_state(g_vc, &state)) {
1716 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1717 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1718 return VC_ERROR_INVALID_STATE;
1722 if (state != VC_STATE_READY) {
1723 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1724 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1725 return VC_ERROR_INVALID_STATE;
1728 if (NULL == callback) {
1729 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1730 return VC_ERROR_INVALID_PARAMETER;
1733 char* temp_text = NULL;
1735 vc_cmd_list_h vc_cmd_list = NULL;
1737 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1738 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1739 return VC_ERROR_INVALID_PARAMETER;
1742 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1743 if (0 != ret || NULL == temp_text) {
1744 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1748 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1750 vc_cmd_print_list(vc_cmd_list);
1752 vc_client_use_callback(g_vc);
1753 callback(event, vc_cmd_list, temp_text, user_data);
1754 vc_client_not_use_callback(g_vc);
1756 vc_cmd_list_destroy(vc_cmd_list, true);
1758 /* Release result */
1759 if (NULL != temp_text) {
1764 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1766 return VC_ERROR_NONE;
1769 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1771 if (0 != __vc_get_feature_enabled()) {
1772 return VC_ERROR_NOT_SUPPORTED;
1774 if (0 != __vc_check_privilege()) {
1775 return VC_ERROR_PERMISSION_DENIED;
1778 if (NULL == callback)
1779 return VC_ERROR_INVALID_PARAMETER;
1782 if (0 != vc_client_get_client_state(g_vc, &state)) {
1783 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1784 return VC_ERROR_INVALID_STATE;
1788 if (state != VC_STATE_INITIALIZED) {
1789 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1790 return VC_ERROR_INVALID_STATE;
1793 vc_client_set_result_cb(g_vc, callback, user_data);
1798 int vc_unset_result_cb(void)
1800 if (0 != __vc_get_feature_enabled()) {
1801 return VC_ERROR_NOT_SUPPORTED;
1803 if (0 != __vc_check_privilege()) {
1804 return VC_ERROR_PERMISSION_DENIED;
1808 if (0 != vc_client_get_client_state(g_vc, &state)) {
1809 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1810 return VC_ERROR_INVALID_STATE;
1814 if (state != VC_STATE_INITIALIZED) {
1815 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1816 return VC_ERROR_INVALID_STATE;
1819 vc_client_set_result_cb(g_vc, NULL, NULL);
1824 int __vc_cb_service_state(int state)
1826 vc_service_state_e current_state = (vc_service_state_e)state;
1827 vc_service_state_e before_state;
1828 vc_client_get_service_state(g_vc, &before_state);
1830 if (current_state == before_state) {
1834 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1835 before_state, current_state);
1837 /* Save service state */
1838 vc_client_set_service_state(g_vc, current_state);
1840 vc_service_state_changed_cb callback = NULL;
1841 void* service_user_data;
1842 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1844 if (NULL != callback) {
1845 vc_client_use_callback(g_vc);
1846 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1847 vc_client_not_use_callback(g_vc);
1848 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1850 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1856 int __vc_cb_manager_pid(int manager_pid)
1858 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1860 /* Save service state */
1861 vc_client_set_mgr_pid(g_vc, manager_pid);
1866 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1868 if (0 != __vc_get_feature_enabled()) {
1869 return VC_ERROR_NOT_SUPPORTED;
1871 if (0 != __vc_check_privilege()) {
1872 return VC_ERROR_PERMISSION_DENIED;
1875 if (NULL == callback)
1876 return VC_ERROR_INVALID_PARAMETER;
1879 if (0 != vc_client_get_client_state(g_vc, &state)) {
1880 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1881 return VC_ERROR_INVALID_STATE;
1885 if (state != VC_STATE_INITIALIZED) {
1886 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1887 return VC_ERROR_INVALID_STATE;
1890 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1895 int vc_unset_service_state_changed_cb(void)
1897 if (0 != __vc_get_feature_enabled()) {
1898 return VC_ERROR_NOT_SUPPORTED;
1900 if (0 != __vc_check_privilege()) {
1901 return VC_ERROR_PERMISSION_DENIED;
1905 if (0 != vc_client_get_client_state(g_vc, &state)) {
1906 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1907 return VC_ERROR_INVALID_STATE;
1911 if (state != VC_STATE_INITIALIZED) {
1912 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1913 return VC_ERROR_INVALID_STATE;
1916 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1921 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1923 if (0 != __vc_get_feature_enabled()) {
1924 return VC_ERROR_NOT_SUPPORTED;
1926 if (0 != __vc_check_privilege()) {
1927 return VC_ERROR_PERMISSION_DENIED;
1930 if (callback == NULL)
1931 return VC_ERROR_INVALID_PARAMETER;
1934 if (0 != vc_client_get_client_state(g_vc, &state)) {
1935 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1936 return VC_ERROR_INVALID_STATE;
1940 if (state != VC_STATE_INITIALIZED) {
1941 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1942 return VC_ERROR_INVALID_STATE;
1945 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1950 int vc_unset_state_changed_cb(void)
1952 if (0 != __vc_get_feature_enabled()) {
1953 return VC_ERROR_NOT_SUPPORTED;
1955 if (0 != __vc_check_privilege()) {
1956 return VC_ERROR_PERMISSION_DENIED;
1960 if (0 != vc_client_get_client_state(g_vc, &state)) {
1961 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1962 return VC_ERROR_INVALID_STATE;
1966 if (state != VC_STATE_INITIALIZED) {
1967 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1968 return VC_ERROR_INVALID_STATE;
1971 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1976 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1978 if (0 != __vc_get_feature_enabled()) {
1979 return VC_ERROR_NOT_SUPPORTED;
1981 if (0 != __vc_check_privilege()) {
1982 return VC_ERROR_PERMISSION_DENIED;
1985 if (NULL == callback)
1986 return VC_ERROR_INVALID_PARAMETER;
1989 if (0 != vc_client_get_client_state(g_vc, &state)) {
1990 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1991 return VC_ERROR_INVALID_STATE;
1995 if (state != VC_STATE_INITIALIZED) {
1996 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1997 return VC_ERROR_INVALID_STATE;
2000 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2005 int vc_unset_current_language_changed_cb(void)
2007 if (0 != __vc_get_feature_enabled()) {
2008 return VC_ERROR_NOT_SUPPORTED;
2010 if (0 != __vc_check_privilege()) {
2011 return VC_ERROR_PERMISSION_DENIED;
2015 if (0 != vc_client_get_client_state(g_vc, &state)) {
2016 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2017 return VC_ERROR_INVALID_STATE;
2021 if (state != VC_STATE_INITIALIZED) {
2022 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2023 return VC_ERROR_INVALID_STATE;
2026 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2031 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2033 if (0 != __vc_get_feature_enabled()) {
2034 return VC_ERROR_NOT_SUPPORTED;
2036 if (0 != __vc_check_privilege()) {
2037 return VC_ERROR_PERMISSION_DENIED;
2040 if (NULL == callback)
2041 return VC_ERROR_INVALID_PARAMETER;
2044 if (0 != vc_client_get_client_state(g_vc, &state)) {
2045 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2046 return VC_ERROR_INVALID_STATE;
2050 if (state != VC_STATE_INITIALIZED) {
2051 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
2052 return VC_ERROR_INVALID_STATE;
2055 vc_client_set_error_cb(g_vc, callback, user_data);
2060 int vc_unset_error_cb(void)
2062 if (0 != __vc_get_feature_enabled()) {
2063 return VC_ERROR_NOT_SUPPORTED;
2065 if (0 != __vc_check_privilege()) {
2066 return VC_ERROR_PERMISSION_DENIED;
2070 if (0 != vc_client_get_client_state(g_vc, &state)) {
2071 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2072 return VC_ERROR_INVALID_STATE;
2076 if (state != VC_STATE_INITIALIZED) {
2077 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2078 return VC_ERROR_INVALID_STATE;
2081 vc_client_set_error_cb(g_vc, NULL, NULL);
2086 int vc_set_invocation_name(const char* name)
2088 if (0 != __vc_get_feature_enabled()) {
2089 return VC_ERROR_NOT_SUPPORTED;
2091 if (0 != __vc_check_privilege()) {
2092 return VC_ERROR_PERMISSION_DENIED;
2096 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2098 int ret = vc_client_get_client_state(g_vc, &state);
2100 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2101 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2106 if (state != VC_STATE_READY) {
2107 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2108 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2109 return VC_ERROR_INVALID_STATE;
2112 ret = vc_client_set_invocation_name(g_vc, name);
2114 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2119 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2123 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2124 if (0 != __vc_get_feature_enabled()) {
2125 return VC_ERROR_NOT_SUPPORTED;
2127 if (0 != __vc_check_privilege()) {
2128 return VC_ERROR_PERMISSION_DENIED;
2131 if (0 != vc_client_get_client_state(g_vc, &state)) {
2132 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2133 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2134 return VC_ERROR_INVALID_STATE;
2138 if (state != VC_STATE_READY) {
2139 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2140 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2141 return VC_ERROR_INVALID_STATE;
2144 /* Check service state */
2145 vc_service_state_e service_state = -1;
2146 vc_client_get_service_state(g_vc, &service_state);
2147 if (service_state != VC_SERVICE_STATE_READY) {
2148 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2149 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2150 return VC_ERROR_INVALID_STATE;
2153 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);
2154 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2156 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2157 return VC_ERROR_OPERATION_FAILED;
2160 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2162 return VC_ERROR_NONE;
2166 int vc_auth_enable(void)
2170 if (0 != vc_client_get_client_state(g_vc, &state)) {
2171 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2172 return VC_ERROR_INVALID_STATE;
2175 if (VC_STATE_READY != state) {
2176 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2177 return VC_ERROR_INVALID_STATE;
2180 /* check already authority */
2181 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2182 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2183 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2184 return VC_ERROR_INVALID_STATE;
2187 if (VC_AUTH_STATE_NONE != auth_state) {
2188 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2189 return VC_ERROR_INVALID_STATE;
2192 /* request authority */
2194 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2195 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2196 return VC_ERROR_OPERATION_FAILED;
2199 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2200 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2201 return VC_ERROR_OPERATION_FAILED;
2204 /* set authority into handle */
2205 bool is_foreground = false;
2206 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2207 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2208 return VC_ERROR_OPERATION_FAILED;
2211 if (is_foreground) {
2212 auth_state = VC_AUTH_STATE_VALID;
2214 auth_state = VC_AUTH_STATE_INVALID;
2217 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2218 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2219 return VC_ERROR_OPERATION_FAILED;
2222 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2224 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2226 return VC_ERROR_NONE;
2229 int vc_auth_disable(void)
2233 if (0 != vc_client_get_client_state(g_vc, &state)) {
2234 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2235 return VC_ERROR_INVALID_STATE;
2238 if (VC_STATE_READY != state) {
2239 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2240 return VC_ERROR_INVALID_STATE;
2243 /* check autority */
2244 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2245 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2246 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2247 return VC_ERROR_INVALID_STATE;
2250 if (VC_AUTH_STATE_NONE == auth_state) {
2251 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2252 return VC_ERROR_INVALID_STATE;
2255 if (0 != vc_auth_unset_state_changed_cb()) {
2256 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2259 /* request return authority by dbus */
2261 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2262 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2263 return VC_ERROR_OPERATION_FAILED;
2266 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2267 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2268 return VC_ERROR_OPERATION_FAILED;
2271 /* unset authority from handle */
2272 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2274 return VC_ERROR_OPERATION_FAILED;
2277 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2279 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2281 return VC_ERROR_NONE;
2284 int vc_auth_get_state(vc_auth_state_e* state)
2287 vc_state_e vc_state;
2288 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2289 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2290 return VC_ERROR_INVALID_STATE;
2293 if (VC_STATE_READY != vc_state) {
2294 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2295 return VC_ERROR_INVALID_STATE;
2299 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2300 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2301 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2302 return VC_ERROR_INVALID_STATE;
2307 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2309 return VC_ERROR_NONE;
2312 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2314 /* check parameter */
2315 if (NULL == callback) {
2316 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2317 return VC_ERROR_INVALID_PARAMETER;
2321 vc_auth_state_e auth_state;
2322 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2323 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2324 return VC_ERROR_INVALID_STATE;
2327 if (VC_AUTH_STATE_NONE == auth_state) {
2328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2329 return VC_ERROR_INVALID_STATE;
2332 /* set cb into handle */
2333 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2335 return VC_ERROR_OPERATION_FAILED;
2338 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2340 return VC_ERROR_NONE;
2343 int vc_auth_unset_state_changed_cb(void)
2346 vc_auth_state_e auth_state;
2347 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2348 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2349 return VC_ERROR_INVALID_STATE;
2352 if (VC_AUTH_STATE_NONE == auth_state) {
2353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2354 return VC_ERROR_INVALID_STATE;
2357 /* unset cb from handle */
2358 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2359 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2360 return VC_ERROR_OPERATION_FAILED;
2363 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2365 return VC_ERROR_NONE;
2368 int vc_auth_start(void)
2370 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2373 if (0 != vc_client_get_client_state(g_vc, &state)) {
2374 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2375 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2376 return VC_ERROR_INVALID_STATE;
2380 if (state != VC_STATE_READY) {
2381 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2382 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2383 return VC_ERROR_INVALID_STATE;
2386 /* Check service state */
2387 vc_service_state_e service_state = -1;
2388 vc_client_get_service_state(g_vc, &service_state);
2389 if (service_state != VC_SERVICE_STATE_READY) {
2390 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2391 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2392 return VC_ERROR_INVALID_STATE;
2395 /* Check authority */
2396 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2397 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2398 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2399 return VC_ERROR_OPERATION_FAILED;
2402 if (VC_AUTH_STATE_VALID != auth_state) {
2403 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2404 return VC_ERROR_OPERATION_FAILED;
2409 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2410 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2411 return VC_ERROR_OPERATION_FAILED;
2420 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2422 if (VC_ERROR_TIMED_OUT != ret) {
2423 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2426 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2429 if (VC_RETRY_COUNT == count) {
2430 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2435 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2439 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2444 int vc_auth_stop(void)
2446 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2449 if (0 != vc_client_get_client_state(g_vc, &state)) {
2450 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2451 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2452 return VC_ERROR_INVALID_STATE;
2456 if (state != VC_STATE_READY) {
2457 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2458 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2459 return VC_ERROR_INVALID_STATE;
2462 /* Check service state */
2463 vc_service_state_e service_state = -1;
2464 vc_client_get_service_state(g_vc, &service_state);
2465 if (service_state != VC_SERVICE_STATE_RECORDING) {
2466 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2467 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2468 return VC_ERROR_INVALID_STATE;
2471 /* Check authority */
2472 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2473 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2474 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2475 return VC_ERROR_OPERATION_FAILED;
2478 if (VC_AUTH_STATE_VALID != auth_state) {
2479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2480 return VC_ERROR_OPERATION_FAILED;
2485 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2486 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2487 return VC_ERROR_OPERATION_FAILED;
2494 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2496 if (VC_ERROR_TIMED_OUT != ret) {
2497 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2500 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2503 if (VC_RETRY_COUNT == count) {
2504 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2509 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2513 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2518 int vc_auth_cancel(void)
2520 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2523 if (0 != vc_client_get_client_state(g_vc, &state)) {
2524 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2525 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2526 return VC_ERROR_INVALID_STATE;
2530 if (state != VC_STATE_READY) {
2531 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2532 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2533 return VC_ERROR_INVALID_STATE;
2536 /* Check service state */
2537 vc_service_state_e service_state = -1;
2538 vc_client_get_service_state(g_vc, &service_state);
2539 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2540 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2541 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2542 return VC_ERROR_INVALID_STATE;
2545 /* Check authority */
2546 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2547 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2548 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2549 return VC_ERROR_OPERATION_FAILED;
2552 if (VC_AUTH_STATE_VALID != auth_state) {
2553 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2554 return VC_ERROR_OPERATION_FAILED;
2559 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2560 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2561 return VC_ERROR_OPERATION_FAILED;
2567 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2569 if (VC_ERROR_TIMED_OUT != ret) {
2570 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2573 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2576 if (VC_RETRY_COUNT == count) {
2577 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2582 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2586 SLOG(LOG_DEBUG, TAG_VCC, "@@@");