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;
569 if (retry_count == 10) {
570 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!");
574 ret = vc_dbus_request_hello();
576 SLOG(LOG_DEBUG, TAG_VCC, "Success to request hello. retry count(%d)", retry_count);
586 if (retry_count == 10) {
587 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon !!");
590 ret = __vc_connect_daemon(NULL);
600 static void __end_prepare_thread(void *data, Ecore_Thread *thread)
602 SLOG(LOG_DEBUG, TAG_VCC, "@@@ End prepare thread");
607 if (0 != __vc_get_feature_enabled()) {
608 return VC_ERROR_NOT_SUPPORTED;
610 if (0 != __vc_check_privilege()) {
611 return VC_ERROR_PERMISSION_DENIED;
614 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
617 if (0 != vc_client_get_client_state(g_vc, &state)) {
618 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
619 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
620 return VC_ERROR_INVALID_STATE;
624 if (state != VC_STATE_INITIALIZED) {
625 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
626 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
627 return VC_ERROR_INVALID_STATE;
630 ecore_thread_run(__start_prepare_thread, __end_prepare_thread, NULL, NULL);
632 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
634 return VC_ERROR_NONE;
637 int vc_prepare_sync(void)
639 if (0 != __vc_get_feature_enabled()) {
640 return VC_ERROR_NOT_SUPPORTED;
642 if (0 != __vc_check_privilege()) {
643 return VC_ERROR_PERMISSION_DENIED;
646 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
649 if (0 != vc_client_get_client_state(g_vc, &state)) {
650 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
651 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
652 return VC_ERROR_INVALID_STATE;
656 if (state != VC_STATE_INITIALIZED) {
657 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'INITIALIZED'");
658 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
659 return VC_ERROR_INVALID_STATE;
663 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
667 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
669 if (VC_CONNECTION_RETRY_COUNT == cnt) {
670 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
671 return VC_ERROR_OPERATION_FAILED;
674 return VC_ERROR_NONE;
677 int vc_unprepare(void)
679 if (0 != __vc_get_feature_enabled()) {
680 return VC_ERROR_NOT_SUPPORTED;
682 if (0 != __vc_check_privilege()) {
683 return VC_ERROR_PERMISSION_DENIED;
686 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
689 if (0 != vc_client_get_client_state(g_vc, &state)) {
690 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
691 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
692 return VC_ERROR_INVALID_STATE;
696 if (state != VC_STATE_READY) {
697 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
698 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
699 return VC_ERROR_INVALID_STATE;
702 __vc_internal_unprepare();
704 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
705 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
707 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
709 return VC_ERROR_NONE;
712 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
714 if (0 != __vc_get_feature_enabled()) {
715 return VC_ERROR_NOT_SUPPORTED;
717 if (0 != __vc_check_privilege()) {
718 return VC_ERROR_PERMISSION_DENIED;
721 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
723 if (NULL == callback) {
724 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
725 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
726 return VC_ERROR_INVALID_PARAMETER;
730 if (0 != vc_client_get_client_state(g_vc, &state)) {
731 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
732 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
733 return VC_ERROR_INVALID_STATE;
737 ret = vc_config_mgr_get_language_list(callback, user_data);
739 ret = vc_config_convert_error_code((vc_config_error_e)ret);
740 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
743 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
745 return VC_ERROR_NONE;
749 int vc_get_current_language(char** language)
751 if (0 != __vc_get_feature_enabled()) {
752 return VC_ERROR_NOT_SUPPORTED;
754 if (0 != __vc_check_privilege()) {
755 return VC_ERROR_PERMISSION_DENIED;
758 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
760 if (NULL == language) {
761 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
762 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
763 return VC_ERROR_INVALID_PARAMETER;
767 if (0 != vc_client_get_client_state(g_vc, &state)) {
768 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
769 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
770 return VC_ERROR_INVALID_STATE;
774 ret = vc_config_mgr_get_default_language(language);
776 ret = vc_config_convert_error_code((vc_config_error_e)ret);
777 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
780 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
785 int vc_get_state(vc_state_e* state)
787 if (0 != __vc_get_feature_enabled()) {
788 return VC_ERROR_NOT_SUPPORTED;
790 if (0 != __vc_check_privilege()) {
791 return VC_ERROR_PERMISSION_DENIED;
794 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
797 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
798 return VC_ERROR_INVALID_PARAMETER;
802 if (0 != vc_client_get_client_state(g_vc, &temp)) {
803 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
804 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
805 return VC_ERROR_INVALID_STATE;
811 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
812 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
813 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
814 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
817 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
819 return VC_ERROR_NONE;
822 int vc_get_service_state(vc_service_state_e* state)
824 if (0 != __vc_get_feature_enabled()) {
825 return VC_ERROR_NOT_SUPPORTED;
827 if (0 != __vc_check_privilege()) {
828 return VC_ERROR_PERMISSION_DENIED;
831 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
834 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
835 return VC_ERROR_INVALID_PARAMETER;
839 if (0 != vc_client_get_client_state(g_vc, &temp)) {
840 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
841 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
842 return VC_ERROR_INVALID_STATE;
845 if (VC_STATE_READY != temp) {
846 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
847 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
848 return VC_ERROR_INVALID_STATE;
851 /* get service state */
852 vc_service_state_e service_state;
853 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
854 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
855 return VC_ERROR_OPERATION_FAILED;
858 *state = service_state;
861 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
862 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
863 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
864 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
865 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
868 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
870 return VC_ERROR_NONE;
873 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
875 if (0 != __vc_get_feature_enabled()) {
876 return VC_ERROR_NOT_SUPPORTED;
878 if (0 != __vc_check_privilege()) {
879 return VC_ERROR_PERMISSION_DENIED;
882 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
884 if (NULL == vc_sys_cmd_list) {
885 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
886 return VC_ERROR_INVALID_PARAMETER;
890 if (0 != vc_client_get_client_state(g_vc, &state)) {
891 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
892 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
893 return VC_ERROR_INVALID_STATE;
897 if (state != VC_STATE_READY) {
898 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
899 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
900 return VC_ERROR_INVALID_STATE;
903 /* Check service state */
904 vc_service_state_e service_state = -1;
905 vc_client_get_service_state(g_vc, &service_state);
906 if (service_state != VC_SERVICE_STATE_READY) {
907 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
908 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
909 return VC_ERROR_INVALID_STATE;
912 bool is_sys_cmd_valid = false;
915 bool is_prepared = false;
917 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
919 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
920 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
921 if (0 == vc_prepare_sync()) {
923 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
925 } else if (VC_ERROR_TIMED_OUT != ret) {
926 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
929 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
932 if (VC_RETRY_COUNT == count) {
933 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
941 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
943 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
944 return VC_ERROR_OPERATION_FAILED;
947 vc_cmd_list_s* list = NULL;
948 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
949 if (true == is_sys_cmd_valid) {
950 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
952 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
955 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
957 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
960 *vc_sys_cmd_list = (vc_cmd_list_h)list;
962 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
963 *vc_sys_cmd_list = NULL;
964 return VC_ERROR_NONE;
967 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
973 * @brief Checks whether the command format is supported.
974 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
976 * @param[in] format The command format
977 * @param[out] support The result status @c true = supported, @c false = not supported
979 * @return 0 on success, otherwise a negative error value
980 * @retval #VC_ERROR_NONE Successful
981 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
982 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
983 * @retval #VC_ERROR_INVALID_STATE Invalid state
985 * @pre The state should be #VC_STATE_READY.
987 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
989 if (0 != __vc_get_feature_enabled()) {
990 return VC_ERROR_NOT_SUPPORTED;
992 if (0 != __vc_check_privilege()) {
993 return VC_ERROR_PERMISSION_DENIED;
996 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
999 if (0 != vc_client_get_client_state(g_vc, &state)) {
1000 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1001 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1002 return VC_ERROR_INVALID_STATE;
1006 bool non_fixed_support = false;
1007 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
1008 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
1012 case VC_CMD_FORMAT_FIXED: *support = true; break;
1013 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
1014 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
1015 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
1016 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
1017 default: *support = false; break;
1020 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
1022 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1024 return VC_ERROR_NONE;
1027 static int __vc_get_invocation_name(char** invocation_name)
1029 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
1031 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
1035 if (NULL == *invocation_name) {
1036 char* temp_label = NULL;
1040 ret = app_manager_get_app_id(getpid(), &appid);
1041 if (0 != ret || NULL == appid) {
1042 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
1043 if (NULL != appid) {
1047 return VC_ERROR_OPERATION_FAILED;
1050 ret = vc_get_current_language(&lang);
1051 if (0 != ret || NULL == lang) {
1052 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
1059 return VC_ERROR_OPERATION_FAILED;
1062 ret = app_info_get_localed_label(appid, lang, &temp_label);
1063 if (0 != ret || NULL == temp_label) {
1064 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
1069 if (NULL != temp_label) {
1073 return VC_ERROR_OPERATION_FAILED;
1076 *invocation_name = strdup(temp_label);
1077 if (NULL == *invocation_name) {
1078 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1079 return VC_ERROR_OUT_OF_MEMORY;
1090 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1091 return VC_ERROR_NONE;
1094 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1096 if (0 != __vc_get_feature_enabled()) {
1097 return VC_ERROR_NOT_SUPPORTED;
1099 if (0 != __vc_check_privilege()) {
1100 return VC_ERROR_PERMISSION_DENIED;
1103 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1105 if (NULL == vc_cmd_list) {
1106 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1107 return VC_ERROR_INVALID_PARAMETER;
1111 if (0 != vc_client_get_client_state(g_vc, &state)) {
1112 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1113 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1114 return VC_ERROR_INVALID_STATE;
1118 if (state != VC_STATE_READY) {
1119 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1120 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1121 return VC_ERROR_INVALID_STATE;
1125 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1126 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1127 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1128 return VC_ERROR_INVALID_PARAMETER;
1131 vc_cmd_list_s* list = NULL;
1132 list = (vc_cmd_list_s*)vc_cmd_list;
1134 if (NULL == list->list) {
1135 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list");
1136 return VC_ERROR_INVALID_PARAMETER;
1140 char* invocation_name = NULL;
1141 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1142 ret = __vc_get_invocation_name(&invocation_name);
1143 if (0 != ret || NULL == invocation_name) {
1144 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1149 ret = vc_cmd_parser_delete_file(getpid(), type);
1151 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1153 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1155 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1158 bool is_prepared = false;
1160 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1162 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1163 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1164 if (0 == vc_prepare_sync()) {
1166 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1168 } else if (VC_ERROR_TIMED_OUT != ret) {
1169 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1172 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1175 if (VC_RETRY_COUNT == count) {
1176 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1184 if (NULL != invocation_name) {
1185 free(invocation_name);
1186 invocation_name = NULL;
1189 if (VC_COMMAND_TYPE_BACKGROUND == type)
1192 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1197 int vc_unset_command_list(int type)
1199 if (0 != __vc_get_feature_enabled()) {
1200 return VC_ERROR_NOT_SUPPORTED;
1202 if (0 != __vc_check_privilege()) {
1203 return VC_ERROR_PERMISSION_DENIED;
1206 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1209 if (0 != vc_client_get_client_state(g_vc, &state)) {
1210 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1211 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1212 return VC_ERROR_INVALID_STATE;
1216 if (state != VC_STATE_READY) {
1217 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1218 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1219 return VC_ERROR_INVALID_STATE;
1224 bool is_prepared = false;
1226 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1228 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1229 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1230 if (0 == vc_prepare_sync()) {
1232 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1234 } else if (VC_ERROR_TIMED_OUT != ret) {
1235 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1238 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1241 if (VC_RETRY_COUNT == count) {
1242 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1249 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1251 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1252 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1255 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1260 int vc_set_command_list_from_file(const char* file_path, int type)
1262 if (0 != __vc_get_feature_enabled()) {
1263 return VC_ERROR_NOT_SUPPORTED;
1265 if (0 != __vc_check_privilege()) {
1266 return VC_ERROR_PERMISSION_DENIED;
1269 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1272 if (0 != vc_client_get_client_state(g_vc, &state)) {
1273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1274 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1275 return VC_ERROR_INVALID_STATE;
1279 if (state != VC_STATE_READY) {
1280 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1281 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1282 return VC_ERROR_INVALID_STATE;
1286 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1287 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1288 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1289 return VC_ERROR_INVALID_PARAMETER;
1293 char* invocation_name = NULL;
1294 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1295 ret = __vc_get_invocation_name(&invocation_name);
1296 if (0 != ret || NULL == invocation_name) {
1297 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1302 ret = vc_cmd_parser_delete_file(getpid(), type);
1304 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1306 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1308 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1311 bool is_prepared = false;
1313 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1315 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1316 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1317 if (0 == vc_prepare_sync()) {
1319 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
1321 } else if (VC_ERROR_TIMED_OUT != ret) {
1322 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1325 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1328 if (VC_RETRY_COUNT == count) {
1329 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1337 if (NULL != invocation_name) {
1338 free(invocation_name);
1339 invocation_name = NULL;
1342 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1347 int vc_get_exclusive_command_option(bool* value)
1349 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1352 if (0 != vc_client_get_client_state(g_vc, &state)) {
1353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1354 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1355 return VC_ERROR_INVALID_STATE;
1359 if (state != VC_STATE_READY) {
1360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1361 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1362 return VC_ERROR_INVALID_STATE;
1365 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1367 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1368 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1372 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1377 int vc_set_exclusive_command_option(bool value)
1379 if (0 != __vc_get_feature_enabled()) {
1380 return VC_ERROR_NOT_SUPPORTED;
1382 if (0 != __vc_check_privilege()) {
1383 return VC_ERROR_PERMISSION_DENIED;
1386 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1389 if (0 != vc_client_get_client_state(g_vc, &state)) {
1390 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1391 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1392 return VC_ERROR_INVALID_STATE;
1396 if (state != VC_STATE_READY) {
1397 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1398 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1399 return VC_ERROR_INVALID_STATE;
1402 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1404 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1405 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1411 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1413 if (VC_ERROR_TIMED_OUT != ret) {
1414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1417 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1420 if (VC_RETRY_COUNT == count) {
1421 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1428 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1435 int vc_request_start(bool stop_by_silence)
1437 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1440 if (0 != vc_client_get_client_state(g_vc, &state)) {
1441 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1442 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1443 return VC_ERROR_INVALID_STATE;
1447 if (state != VC_STATE_READY) {
1448 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1449 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1450 return VC_ERROR_INVALID_STATE;
1453 /* Check service state */
1454 vc_service_state_e service_state = -1;
1455 vc_client_get_service_state(g_vc, &service_state);
1456 if (service_state != VC_SERVICE_STATE_READY) {
1457 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1458 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1459 return VC_ERROR_INVALID_STATE;
1469 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1471 if (VC_ERROR_TIMED_OUT != ret) {
1472 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1475 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1478 if (VC_RETRY_COUNT == count) {
1479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1484 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1488 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1493 int vc_request_stop(void)
1495 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1498 if (0 != vc_client_get_client_state(g_vc, &state)) {
1499 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1500 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1501 return VC_ERROR_INVALID_STATE;
1505 if (state != VC_STATE_READY) {
1506 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1507 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1508 return VC_ERROR_INVALID_STATE;
1511 /* Check service state */
1512 vc_service_state_e service_state = -1;
1513 vc_client_get_service_state(g_vc, &service_state);
1514 if (service_state != VC_SERVICE_STATE_RECORDING) {
1515 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1516 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1517 return VC_ERROR_INVALID_STATE;
1524 ret = vc_dbus_request_stop(g_vc->handle);
1526 if (VC_ERROR_TIMED_OUT != ret) {
1527 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1530 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1533 if (VC_RETRY_COUNT == count) {
1534 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1539 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1543 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1548 int vc_request_cancel(void)
1550 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1553 if (0 != vc_client_get_client_state(g_vc, &state)) {
1554 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1555 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1556 return VC_ERROR_INVALID_STATE;
1560 if (state != VC_STATE_READY) {
1561 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1562 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1563 return VC_ERROR_INVALID_STATE;
1566 /* Check service state */
1567 vc_service_state_e service_state = -1;
1568 vc_client_get_service_state(g_vc, &service_state);
1569 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1570 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1571 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1572 return VC_ERROR_INVALID_STATE;
1578 ret = vc_dbus_request_cancel(g_vc->handle);
1580 if (VC_ERROR_TIMED_OUT != ret) {
1581 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1584 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1587 if (VC_RETRY_COUNT == count) {
1588 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1593 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1597 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1603 static void __vc_notify_error(void *data)
1605 vc_h vc = (vc_h)data;
1607 vc_error_cb callback = NULL;
1611 vc_client_get_error_cb(vc, &callback, &user_data);
1612 vc_client_get_error(vc, &reason);
1614 if (NULL != callback) {
1615 vc_client_use_callback(vc);
1616 callback(reason, user_data);
1617 vc_client_not_use_callback(vc);
1618 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1620 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1624 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1627 if (0 != vc_client_get_client_state(g_vc, &state)) {
1628 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1633 if (state != VC_STATE_READY) {
1634 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1638 if (VC_ERROR_SERVICE_RESET == reason) {
1639 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1641 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1642 ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
1644 if (0 != vc_prepare()) {
1645 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1649 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1651 vc_client_set_error(g_vc, reason);
1652 ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
1657 static void __vc_notify_state_changed(void *data)
1659 vc_h vc = (vc_h)data;
1661 vc_state_changed_cb changed_callback = NULL;
1664 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1666 vc_state_e current_state;
1667 vc_state_e before_state;
1669 vc_client_get_before_state(vc, ¤t_state, &before_state);
1671 if (NULL != changed_callback) {
1672 vc_client_use_callback(vc);
1673 changed_callback(before_state, current_state, user_data);
1674 vc_client_not_use_callback(vc);
1675 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1677 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1681 static Eina_Bool __vc_notify_result(void *data)
1685 vc_cmd_list_h vc_cmd_list = NULL;
1687 vc_result_cb callback = NULL;
1688 void* user_data = NULL;
1690 vc_client_get_result_cb(g_vc, &callback, &user_data);
1692 if (NULL == callback) {
1693 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1697 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1698 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1702 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1704 SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1706 vc_cmd_print_list(vc_cmd_list);
1708 vc_client_use_callback(g_vc);
1709 callback(event, vc_cmd_list, temp_text, user_data);
1710 vc_client_not_use_callback(g_vc);
1712 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1714 vc_cmd_list_destroy(vc_cmd_list, true);
1716 /* Release result */
1717 if (NULL != temp_text) free(temp_text);
1722 void __vc_cb_result(void)
1724 ecore_timer_add(0, __vc_notify_result, NULL);
1729 int vc_get_result(vc_result_cb callback, void* user_data)
1731 if (0 != __vc_get_feature_enabled()) {
1732 return VC_ERROR_NOT_SUPPORTED;
1734 if (0 != __vc_check_privilege()) {
1735 return VC_ERROR_PERMISSION_DENIED;
1738 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1741 if (0 != vc_client_get_client_state(g_vc, &state)) {
1742 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1743 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1744 return VC_ERROR_INVALID_STATE;
1748 if (state != VC_STATE_READY) {
1749 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1750 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1751 return VC_ERROR_INVALID_STATE;
1754 if (NULL == callback) {
1755 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1756 return VC_ERROR_INVALID_PARAMETER;
1759 char* temp_text = NULL;
1761 vc_cmd_list_h vc_cmd_list = NULL;
1763 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1764 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1765 return VC_ERROR_INVALID_PARAMETER;
1768 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1769 if (0 != ret || NULL == temp_text) {
1770 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1774 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1776 vc_cmd_print_list(vc_cmd_list);
1778 vc_client_use_callback(g_vc);
1779 callback(event, vc_cmd_list, temp_text, user_data);
1780 vc_client_not_use_callback(g_vc);
1782 vc_cmd_list_destroy(vc_cmd_list, true);
1784 /* Release result */
1785 if (NULL != temp_text) {
1790 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1792 return VC_ERROR_NONE;
1795 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1797 if (0 != __vc_get_feature_enabled()) {
1798 return VC_ERROR_NOT_SUPPORTED;
1800 if (0 != __vc_check_privilege()) {
1801 return VC_ERROR_PERMISSION_DENIED;
1804 if (NULL == callback)
1805 return VC_ERROR_INVALID_PARAMETER;
1808 if (0 != vc_client_get_client_state(g_vc, &state)) {
1809 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set 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] Set result callback : Current state is not 'Initialized'");
1816 return VC_ERROR_INVALID_STATE;
1819 vc_client_set_result_cb(g_vc, callback, user_data);
1824 int vc_unset_result_cb(void)
1826 if (0 != __vc_get_feature_enabled()) {
1827 return VC_ERROR_NOT_SUPPORTED;
1829 if (0 != __vc_check_privilege()) {
1830 return VC_ERROR_PERMISSION_DENIED;
1834 if (0 != vc_client_get_client_state(g_vc, &state)) {
1835 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1836 return VC_ERROR_INVALID_STATE;
1840 if (state != VC_STATE_INITIALIZED) {
1841 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1842 return VC_ERROR_INVALID_STATE;
1845 vc_client_set_result_cb(g_vc, NULL, NULL);
1850 int __vc_cb_service_state(int state)
1852 vc_service_state_e current_state = (vc_service_state_e)state;
1853 vc_service_state_e before_state;
1854 vc_client_get_service_state(g_vc, &before_state);
1856 if (current_state == before_state) {
1860 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1861 before_state, current_state);
1863 /* Save service state */
1864 vc_client_set_service_state(g_vc, current_state);
1866 vc_service_state_changed_cb callback = NULL;
1867 void* service_user_data;
1868 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1870 if (NULL != callback) {
1871 vc_client_use_callback(g_vc);
1872 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1873 vc_client_not_use_callback(g_vc);
1874 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1876 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1882 int __vc_cb_manager_pid(int manager_pid)
1884 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1886 /* Save service state */
1887 vc_client_set_mgr_pid(g_vc, manager_pid);
1892 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1894 if (0 != __vc_get_feature_enabled()) {
1895 return VC_ERROR_NOT_SUPPORTED;
1897 if (0 != __vc_check_privilege()) {
1898 return VC_ERROR_PERMISSION_DENIED;
1901 if (NULL == callback)
1902 return VC_ERROR_INVALID_PARAMETER;
1905 if (0 != vc_client_get_client_state(g_vc, &state)) {
1906 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set 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] Set result callback : Current state is not 'Initialized'");
1913 return VC_ERROR_INVALID_STATE;
1916 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1921 int vc_unset_service_state_changed_cb(void)
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;
1931 if (0 != vc_client_get_client_state(g_vc, &state)) {
1932 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1933 return VC_ERROR_INVALID_STATE;
1937 if (state != VC_STATE_INITIALIZED) {
1938 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1939 return VC_ERROR_INVALID_STATE;
1942 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1947 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1949 if (0 != __vc_get_feature_enabled()) {
1950 return VC_ERROR_NOT_SUPPORTED;
1952 if (0 != __vc_check_privilege()) {
1953 return VC_ERROR_PERMISSION_DENIED;
1956 if (callback == NULL)
1957 return VC_ERROR_INVALID_PARAMETER;
1960 if (0 != vc_client_get_client_state(g_vc, &state)) {
1961 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set 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] Set state changed callback : Current state is not 'Initialized'");
1968 return VC_ERROR_INVALID_STATE;
1971 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1976 int vc_unset_state_changed_cb(void)
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;
1986 if (0 != vc_client_get_client_state(g_vc, &state)) {
1987 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1988 return VC_ERROR_INVALID_STATE;
1992 if (state != VC_STATE_INITIALIZED) {
1993 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1994 return VC_ERROR_INVALID_STATE;
1997 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
2002 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2004 if (0 != __vc_get_feature_enabled()) {
2005 return VC_ERROR_NOT_SUPPORTED;
2007 if (0 != __vc_check_privilege()) {
2008 return VC_ERROR_PERMISSION_DENIED;
2011 if (NULL == callback)
2012 return VC_ERROR_INVALID_PARAMETER;
2015 if (0 != vc_client_get_client_state(g_vc, &state)) {
2016 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set 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] Set current language changed : Current state is not 'Initialized'");
2023 return VC_ERROR_INVALID_STATE;
2026 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2031 int vc_unset_current_language_changed_cb(void)
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;
2041 if (0 != vc_client_get_client_state(g_vc, &state)) {
2042 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2043 return VC_ERROR_INVALID_STATE;
2047 if (state != VC_STATE_INITIALIZED) {
2048 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2049 return VC_ERROR_INVALID_STATE;
2052 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2057 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2059 if (0 != __vc_get_feature_enabled()) {
2060 return VC_ERROR_NOT_SUPPORTED;
2062 if (0 != __vc_check_privilege()) {
2063 return VC_ERROR_PERMISSION_DENIED;
2066 if (NULL == callback)
2067 return VC_ERROR_INVALID_PARAMETER;
2070 if (0 != vc_client_get_client_state(g_vc, &state)) {
2071 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set 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] Set error callback : Current state is not 'Initialized'");
2078 return VC_ERROR_INVALID_STATE;
2081 vc_client_set_error_cb(g_vc, callback, user_data);
2086 int vc_unset_error_cb(void)
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 if (0 != vc_client_get_client_state(g_vc, &state)) {
2097 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2098 return VC_ERROR_INVALID_STATE;
2102 if (state != VC_STATE_INITIALIZED) {
2103 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2104 return VC_ERROR_INVALID_STATE;
2107 vc_client_set_error_cb(g_vc, NULL, NULL);
2112 int vc_set_invocation_name(const char* name)
2114 if (0 != __vc_get_feature_enabled()) {
2115 return VC_ERROR_NOT_SUPPORTED;
2117 if (0 != __vc_check_privilege()) {
2118 return VC_ERROR_PERMISSION_DENIED;
2122 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2124 int ret = vc_client_get_client_state(g_vc, &state);
2126 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2127 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2132 if (state != VC_STATE_READY) {
2133 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2134 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2135 return VC_ERROR_INVALID_STATE;
2138 ret = vc_client_set_invocation_name(g_vc, name);
2140 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2145 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2149 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2150 if (0 != __vc_get_feature_enabled()) {
2151 return VC_ERROR_NOT_SUPPORTED;
2153 if (0 != __vc_check_privilege()) {
2154 return VC_ERROR_PERMISSION_DENIED;
2157 if (0 != vc_client_get_client_state(g_vc, &state)) {
2158 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2159 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2160 return VC_ERROR_INVALID_STATE;
2164 if (state != VC_STATE_READY) {
2165 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2166 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2167 return VC_ERROR_INVALID_STATE;
2170 /* Check service state */
2171 vc_service_state_e service_state = -1;
2172 vc_client_get_service_state(g_vc, &service_state);
2173 if (service_state != VC_SERVICE_STATE_READY) {
2174 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2175 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2176 return VC_ERROR_INVALID_STATE;
2179 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);
2180 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2182 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2183 return VC_ERROR_OPERATION_FAILED;
2186 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2188 return VC_ERROR_NONE;
2192 int vc_auth_enable(void)
2196 if (0 != vc_client_get_client_state(g_vc, &state)) {
2197 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2198 return VC_ERROR_INVALID_STATE;
2201 if (VC_STATE_READY != state) {
2202 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2203 return VC_ERROR_INVALID_STATE;
2206 /* check already authority */
2207 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2208 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2209 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2210 return VC_ERROR_INVALID_STATE;
2213 if (VC_AUTH_STATE_NONE != auth_state) {
2214 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2215 return VC_ERROR_INVALID_STATE;
2218 /* request authority */
2220 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2221 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2222 return VC_ERROR_OPERATION_FAILED;
2225 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2226 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2227 return VC_ERROR_OPERATION_FAILED;
2230 /* set authority into handle */
2231 bool is_foreground = false;
2232 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2233 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2234 return VC_ERROR_OPERATION_FAILED;
2237 if (is_foreground) {
2238 auth_state = VC_AUTH_STATE_VALID;
2240 auth_state = VC_AUTH_STATE_INVALID;
2243 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2244 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2245 return VC_ERROR_OPERATION_FAILED;
2248 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2250 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2252 return VC_ERROR_NONE;
2255 int vc_auth_disable(void)
2259 if (0 != vc_client_get_client_state(g_vc, &state)) {
2260 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2261 return VC_ERROR_INVALID_STATE;
2264 if (VC_STATE_READY != state) {
2265 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2266 return VC_ERROR_INVALID_STATE;
2269 /* check autority */
2270 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2271 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2272 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2273 return VC_ERROR_INVALID_STATE;
2276 if (VC_AUTH_STATE_NONE == auth_state) {
2277 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2278 return VC_ERROR_INVALID_STATE;
2281 if (0 != vc_auth_unset_state_changed_cb()) {
2282 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2285 /* request return authority by dbus */
2287 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2288 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2289 return VC_ERROR_OPERATION_FAILED;
2292 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2293 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2294 return VC_ERROR_OPERATION_FAILED;
2297 /* unset authority from handle */
2298 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2299 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2300 return VC_ERROR_OPERATION_FAILED;
2303 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2305 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2307 return VC_ERROR_NONE;
2310 int vc_auth_get_state(vc_auth_state_e* state)
2313 vc_state_e vc_state;
2314 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2315 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2316 return VC_ERROR_INVALID_STATE;
2319 if (VC_STATE_READY != vc_state) {
2320 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2321 return VC_ERROR_INVALID_STATE;
2325 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2326 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2327 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2328 return VC_ERROR_INVALID_STATE;
2333 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2335 return VC_ERROR_NONE;
2338 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2340 /* check parameter */
2341 if (NULL == callback) {
2342 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2343 return VC_ERROR_INVALID_PARAMETER;
2347 vc_auth_state_e auth_state;
2348 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2349 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2350 return VC_ERROR_INVALID_STATE;
2353 if (VC_AUTH_STATE_NONE == auth_state) {
2354 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2355 return VC_ERROR_INVALID_STATE;
2358 /* set cb into handle */
2359 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2361 return VC_ERROR_OPERATION_FAILED;
2364 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2366 return VC_ERROR_NONE;
2369 int vc_auth_unset_state_changed_cb(void)
2372 vc_auth_state_e auth_state;
2373 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2374 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2375 return VC_ERROR_INVALID_STATE;
2378 if (VC_AUTH_STATE_NONE == auth_state) {
2379 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2380 return VC_ERROR_INVALID_STATE;
2383 /* unset cb from handle */
2384 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2385 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2386 return VC_ERROR_OPERATION_FAILED;
2389 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2391 return VC_ERROR_NONE;
2394 int vc_auth_start(void)
2396 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2399 if (0 != vc_client_get_client_state(g_vc, &state)) {
2400 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2401 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2402 return VC_ERROR_INVALID_STATE;
2406 if (state != VC_STATE_READY) {
2407 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2408 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2409 return VC_ERROR_INVALID_STATE;
2412 /* Check service state */
2413 vc_service_state_e service_state = -1;
2414 vc_client_get_service_state(g_vc, &service_state);
2415 if (service_state != VC_SERVICE_STATE_READY) {
2416 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2417 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2418 return VC_ERROR_INVALID_STATE;
2421 /* Check authority */
2422 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2423 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2424 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2425 return VC_ERROR_OPERATION_FAILED;
2428 if (VC_AUTH_STATE_VALID != auth_state) {
2429 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2430 return VC_ERROR_OPERATION_FAILED;
2435 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2436 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2437 return VC_ERROR_OPERATION_FAILED;
2442 bool is_prepared = false;
2445 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2447 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2448 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2449 if (0 == vc_prepare_sync()) {
2451 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2453 } else if (VC_ERROR_TIMED_OUT != ret) {
2454 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2457 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2460 if (VC_RETRY_COUNT == count) {
2461 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2466 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2470 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2475 int vc_auth_stop(void)
2477 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2480 if (0 != vc_client_get_client_state(g_vc, &state)) {
2481 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2482 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2483 return VC_ERROR_INVALID_STATE;
2487 if (state != VC_STATE_READY) {
2488 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2489 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2490 return VC_ERROR_INVALID_STATE;
2493 /* Check service state */
2494 vc_service_state_e service_state = -1;
2495 vc_client_get_service_state(g_vc, &service_state);
2496 if (service_state != VC_SERVICE_STATE_RECORDING) {
2497 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2498 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
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] Fail to get auth state");
2506 return VC_ERROR_OPERATION_FAILED;
2509 if (VC_AUTH_STATE_VALID != auth_state) {
2510 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2511 return VC_ERROR_OPERATION_FAILED;
2516 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2517 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2518 return VC_ERROR_OPERATION_FAILED;
2523 bool is_prepared = false;
2526 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2528 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2529 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2530 if (0 == vc_prepare_sync()) {
2532 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2534 } else if (VC_ERROR_TIMED_OUT != ret) {
2535 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2538 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2541 if (VC_RETRY_COUNT == count) {
2542 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2547 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2551 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2556 int vc_auth_cancel(void)
2558 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2561 if (0 != vc_client_get_client_state(g_vc, &state)) {
2562 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2563 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2564 return VC_ERROR_INVALID_STATE;
2568 if (state != VC_STATE_READY) {
2569 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2570 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2571 return VC_ERROR_INVALID_STATE;
2574 /* Check service state */
2575 vc_service_state_e service_state = -1;
2576 vc_client_get_service_state(g_vc, &service_state);
2577 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2578 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2579 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2580 return VC_ERROR_INVALID_STATE;
2583 /* Check authority */
2584 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2585 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2586 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2587 return VC_ERROR_OPERATION_FAILED;
2590 if (VC_AUTH_STATE_VALID != auth_state) {
2591 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2592 return VC_ERROR_OPERATION_FAILED;
2597 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2598 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2599 return VC_ERROR_OPERATION_FAILED;
2604 bool is_prepared = false;
2606 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2608 if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2609 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2610 if (0 == vc_prepare_sync()) {
2612 SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2614 } else if (VC_ERROR_TIMED_OUT != ret) {
2615 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2618 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2621 if (VC_RETRY_COUNT == count) {
2622 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2627 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2631 SLOG(LOG_DEBUG, TAG_VCC, "@@@");