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;
55 static int g_privilege_allowed = -1;
56 static cynara *p_cynara = NULL;
58 Eina_Bool __vc_notify_state_changed(void *data);
59 Eina_Bool __vc_notify_error(void *data);
61 static int __vc_get_feature_enabled()
63 if (0 == g_feature_enabled) {
64 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
65 return VC_ERROR_NOT_SUPPORTED;
66 } else if (-1 == g_feature_enabled) {
67 bool vc_supported = false;
68 bool mic_supported = false;
69 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
70 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
71 if (false == vc_supported || false == mic_supported) {
72 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
73 g_feature_enabled = 0;
74 return VC_ERROR_NOT_SUPPORTED;
77 g_feature_enabled = 1;
79 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
80 return VC_ERROR_NOT_SUPPORTED;
83 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
84 return VC_ERROR_NOT_SUPPORTED;
91 static int __check_privilege_initialize()
93 int ret = cynara_initialize(&p_cynara, NULL);
94 if (CYNARA_API_SUCCESS != ret)
95 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize");
97 return ret == CYNARA_API_SUCCESS;
100 static int __check_privilege(const char* uid, const char * privilege)
103 char label_path[1024] = "/proc/self/attr/current";
104 char smack_label[1024] = {'\0',};
110 fp = fopen(label_path, "r");
112 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
113 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread");
118 pid_t pid = getpid();
119 char *session = cynara_session_from_pid(pid);
120 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
121 SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
125 if (ret != CYNARA_API_ACCESS_ALLOWED)
130 static void __check_privilege_deinitialize()
133 cynara_finish(p_cynara);
137 static int __vc_check_privilege()
141 if (0 == g_privilege_allowed) {
142 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
143 return VC_ERROR_PERMISSION_DENIED;
144 } else if (-1 == g_privilege_allowed) {
145 if (false == __check_privilege_initialize()) {
146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
147 return VC_ERROR_PERMISSION_DENIED;
149 snprintf(uid, 16, "%d", getuid());
150 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
151 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
152 g_privilege_allowed = 0;
153 __check_privilege_deinitialize();
154 return VC_ERROR_PERMISSION_DENIED;
156 __check_privilege_deinitialize();
159 g_privilege_allowed = 1;
160 return VC_ERROR_NONE;
163 static const char* __vc_get_error_code(vc_error_e err)
166 case VC_ERROR_NONE: return "VC_ERROR_NONE";
167 case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY";
168 case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR";
169 case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER";
170 case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT";
171 case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY";
172 case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE";
173 case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE";
174 case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
175 case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
176 default: return "Invalid error code";
181 static int __vc_convert_config_error_code(vc_config_error_e code)
183 if (code == VC_CONFIG_ERROR_NONE) return VC_ERROR_NONE;
184 if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY) return VC_ERROR_OUT_OF_MEMORY;
185 if (code == VC_CONFIG_ERROR_IO_ERROR) return VC_ERROR_IO_ERROR;
186 if (code == VC_CONFIG_ERROR_INVALID_PARAMETER) return VC_ERROR_INVALID_PARAMETER;
187 if (code == VC_CONFIG_ERROR_INVALID_STATE) return VC_ERROR_INVALID_STATE;
188 if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE) return VC_ERROR_INVALID_LANGUAGE;
189 if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND) return VC_ERROR_ENGINE_NOT_FOUND;
190 if (code == VC_CONFIG_ERROR_OPERATION_FAILED) return VC_ERROR_OPERATION_FAILED;
192 return VC_ERROR_NONE;
195 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
197 SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
198 before_lang, current_lang);
200 vc_current_language_changed_cb callback;
201 void* lang_user_data;
202 vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
204 if (NULL != callback) {
205 vc_client_use_callback(g_vc);
206 callback(before_lang, current_lang, lang_user_data);
207 vc_client_not_use_callback(g_vc);
208 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
210 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
216 static Eina_Bool __notify_auth_changed_cb(void *data)
218 vc_auth_state_changed_cb callback = NULL;
221 vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
223 vc_auth_state_e before = -1;
224 vc_auth_state_e current = -1;
226 vc_client_get_before_auth_state(g_vc, &before, ¤t);
228 if (NULL != callback) {
229 vc_client_use_callback(g_vc);
230 callback(before, current, user_data);
231 vc_client_not_use_callback(g_vc);
232 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
234 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
240 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
242 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
245 if (ECORE_WL_EVENT_FOCUS_IN == type) {
246 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
247 ret = vc_dbus_set_foreground(getpid(), true);
249 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
252 ret = vc_client_set_is_foreground(g_vc, true);
254 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
257 /* set authority valid */
258 vc_auth_state_e state = VC_AUTH_STATE_NONE;
259 if (0 != vc_client_get_auth_state(g_vc, &state)) {
260 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
262 if (VC_AUTH_STATE_INVALID == state) {
263 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
265 /* notify auth changed cb */
266 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
268 } else if (ECORE_WL_EVENT_FOCUS_OUT == type) {
269 SLOG(LOG_DEBUG, TAG_VCW, "@@@ Set background");
270 ret = vc_dbus_set_foreground(getpid(), false);
272 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
275 ret = vc_client_set_is_foreground(g_vc, false);
277 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
280 /* set authority valid */
281 vc_auth_state_e state = VC_AUTH_STATE_NONE;
282 if (0 != vc_client_get_auth_state(g_vc, &state)) {
283 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
285 if (VC_AUTH_STATE_VALID == state) {
286 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
288 /* notify authority changed cb */
289 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
292 SLOG(LOG_DEBUG, TAG_VCC, "@@@ type(%d) is NOT valid", type);
295 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
297 return ECORE_CALLBACK_RENEW;
300 int vc_initialize(void)
302 if (0 != __vc_get_feature_enabled()) {
303 return VC_ERROR_NOT_SUPPORTED;
305 if (0 != __vc_check_privilege()) {
306 return VC_ERROR_PERMISSION_DENIED;
309 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Initialize");
312 if (true == vc_client_is_valid(g_vc)) {
313 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
314 return VC_ERROR_NONE;
317 if (0 < vc_client_get_count()) {
318 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
319 return VC_ERROR_NONE;
322 if (0 != vc_dbus_open_connection()) {
323 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
324 return VC_ERROR_OPERATION_FAILED;
327 if (0 != vc_client_create(&g_vc)) {
328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
329 return VC_ERROR_OUT_OF_MEMORY;
332 int ret = vc_config_mgr_initialize(g_vc->handle);
334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
335 __vc_get_error_code(__vc_convert_config_error_code(ret)));
336 vc_client_destroy(g_vc);
337 return __vc_convert_config_error_code(ret);
340 ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
342 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
343 vc_config_mgr_finalize(g_vc->handle);
344 vc_client_destroy(g_vc);
345 return __vc_convert_config_error_code(ret);
348 ret = vc_db_initialize();
350 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize DB : %d", ret);
351 vc_config_mgr_finalize(g_vc->handle);
352 vc_client_destroy(g_vc);
356 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
358 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
360 return VC_ERROR_NONE;
363 static void __vc_internal_unprepare(void)
365 /* return authority */
366 vc_auth_state_e state = VC_AUTH_STATE_NONE;
367 if (0 != vc_client_get_auth_state(g_vc, &state)) {
368 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
371 if (VC_AUTH_STATE_NONE != state) {
372 if (0 != vc_auth_disable()) {
373 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
377 int ret = vc_dbus_request_finalize(g_vc->handle);
379 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
382 if (NULL != g_focus_in_handler) {
383 ecore_event_handler_del(g_focus_in_handler);
384 g_focus_in_handler = NULL;
386 if (NULL != g_focus_out_handler) {
387 ecore_event_handler_del(g_focus_out_handler);
388 g_focus_out_handler = NULL;
391 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
393 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
398 int vc_deinitialize(void)
400 if (0 != __vc_get_feature_enabled()) {
401 return VC_ERROR_NOT_SUPPORTED;
403 if (0 != __vc_check_privilege()) {
404 return VC_ERROR_PERMISSION_DENIED;
407 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Deinitialize");
409 if (false == vc_client_is_valid(g_vc)) {
410 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
411 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
412 return VC_ERROR_INVALID_STATE;
416 vc_client_get_client_state(g_vc, &state);
421 __vc_internal_unprepare();
422 /* no break. need to next step*/
423 case VC_STATE_INITIALIZED:
424 if (NULL != g_connect_timer) {
425 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
426 ecore_timer_del(g_connect_timer);
427 g_connect_timer = NULL;
430 vc_config_mgr_unset_lang_cb(g_vc->handle);
431 vc_config_mgr_finalize(g_vc->handle);
433 /* Free client resources */
434 vc_client_destroy(g_vc);
441 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
442 int ret = vc_db_finalize();
444 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret);
447 if (0 != vc_dbus_close_connection()) {
448 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
451 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
453 return VC_ERROR_NONE;
456 static Eina_Bool __vc_connect_daemon(void *data)
459 if (0 != vc_dbus_request_hello()) {
463 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Connect daemon");
465 /* request initialization */
468 int service_state = 0;
470 g_connect_timer = NULL;
472 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
474 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
476 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
477 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
478 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
480 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
481 ecore_timer_add(0, __vc_notify_error, g_vc);
483 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
486 } else if (0 != ret) {
487 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
489 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
490 ecore_timer_add(0, __vc_notify_error, g_vc);
492 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
495 /* Success to connect */
498 /* Set service state */
499 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
501 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
502 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
504 char appid[255] = {'\0',};
505 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
507 int status = aul_app_get_status(appid);
508 if (STATUS_FOCUS == status) {
509 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
510 ret = vc_dbus_set_foreground(getpid(), true);
512 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
515 ret = vc_client_set_is_foreground(g_vc, true);
517 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
520 /* set authority valid */
521 vc_auth_state_e state = VC_AUTH_STATE_NONE;
522 if (0 != vc_client_get_auth_state(g_vc, &state)) {
523 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
525 if (VC_AUTH_STATE_INVALID == state) {
526 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
528 /* notify auth changed cb */
529 ecore_idler_add(__notify_auth_changed_cb, NULL);
533 vc_client_set_client_state(g_vc, VC_STATE_READY);
534 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
536 vc_client_set_mgr_pid(g_vc, mgr_pid);
538 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
545 if (0 != __vc_get_feature_enabled()) {
546 return VC_ERROR_NOT_SUPPORTED;
548 if (0 != __vc_check_privilege()) {
549 return VC_ERROR_PERMISSION_DENIED;
552 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
555 if (0 != vc_client_get_client_state(g_vc, &state)) {
556 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
557 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
558 return VC_ERROR_INVALID_STATE;
562 if (state != VC_STATE_INITIALIZED) {
563 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
564 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
565 return VC_ERROR_INVALID_STATE;
568 g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
570 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
572 return VC_ERROR_NONE;
575 int vc_prepare_sync(void)
577 if (0 != __vc_get_feature_enabled()) {
578 return VC_ERROR_NOT_SUPPORTED;
580 if (0 != __vc_check_privilege()) {
581 return VC_ERROR_PERMISSION_DENIED;
584 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
587 if (0 != vc_client_get_client_state(g_vc, &state)) {
588 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
589 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
590 return VC_ERROR_INVALID_STATE;
594 if (state != VC_STATE_INITIALIZED) {
595 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
596 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
597 return VC_ERROR_INVALID_STATE;
601 while (EINA_TRUE == __vc_connect_daemon(NULL) && VC_CONNECTION_RETRY_COUNT > cnt) {
605 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
607 if (VC_CONNECTION_RETRY_COUNT == cnt) {
608 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to connect daemon");
609 return VC_ERROR_OPERATION_FAILED;
612 return VC_ERROR_NONE;
615 int vc_unprepare(void)
617 if (0 != __vc_get_feature_enabled()) {
618 return VC_ERROR_NOT_SUPPORTED;
620 if (0 != __vc_check_privilege()) {
621 return VC_ERROR_PERMISSION_DENIED;
624 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
627 if (0 != vc_client_get_client_state(g_vc, &state)) {
628 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
629 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
630 return VC_ERROR_INVALID_STATE;
634 if (state != VC_STATE_READY) {
635 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
636 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
637 return VC_ERROR_INVALID_STATE;
640 __vc_internal_unprepare();
642 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
643 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
645 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
647 return VC_ERROR_NONE;
650 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
652 if (0 != __vc_get_feature_enabled()) {
653 return VC_ERROR_NOT_SUPPORTED;
655 if (0 != __vc_check_privilege()) {
656 return VC_ERROR_PERMISSION_DENIED;
659 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Foreach Supported Language");
661 if (NULL == callback) {
662 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
663 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
664 return VC_ERROR_INVALID_PARAMETER;
668 if (0 != vc_client_get_client_state(g_vc, &state)) {
669 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
670 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
671 return VC_ERROR_INVALID_STATE;
675 ret = vc_config_mgr_get_language_list(callback, user_data);
677 ret = vc_config_convert_error_code((vc_config_error_e)ret);
678 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
681 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
683 return VC_ERROR_NONE;
687 int vc_get_current_language(char** language)
689 if (0 != __vc_get_feature_enabled()) {
690 return VC_ERROR_NOT_SUPPORTED;
692 if (0 != __vc_check_privilege()) {
693 return VC_ERROR_PERMISSION_DENIED;
696 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Current Language");
698 if (NULL == language) {
699 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
700 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
701 return VC_ERROR_INVALID_PARAMETER;
705 if (0 != vc_client_get_client_state(g_vc, &state)) {
706 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
707 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
708 return VC_ERROR_INVALID_STATE;
712 ret = vc_config_mgr_get_default_language(language);
714 ret = vc_config_convert_error_code((vc_config_error_e)ret);
715 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
718 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
723 int vc_get_state(vc_state_e* state)
725 if (0 != __vc_get_feature_enabled()) {
726 return VC_ERROR_NOT_SUPPORTED;
728 if (0 != __vc_check_privilege()) {
729 return VC_ERROR_PERMISSION_DENIED;
732 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get State");
735 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
736 return VC_ERROR_INVALID_PARAMETER;
740 if (0 != vc_client_get_client_state(g_vc, &temp)) {
741 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
742 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
743 return VC_ERROR_INVALID_STATE;
749 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
750 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
751 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
752 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
755 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
757 return VC_ERROR_NONE;
760 int vc_get_service_state(vc_service_state_e* state)
762 if (0 != __vc_get_feature_enabled()) {
763 return VC_ERROR_NOT_SUPPORTED;
765 if (0 != __vc_check_privilege()) {
766 return VC_ERROR_PERMISSION_DENIED;
769 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get Service State");
772 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
773 return VC_ERROR_INVALID_PARAMETER;
777 if (0 != vc_client_get_client_state(g_vc, &temp)) {
778 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
779 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
780 return VC_ERROR_INVALID_STATE;
783 if (VC_STATE_READY != temp) {
784 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
785 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
786 return VC_ERROR_INVALID_STATE;
789 /* get service state */
790 vc_service_state_e service_state;
791 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
792 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
793 return VC_ERROR_OPERATION_FAILED;
796 *state = service_state;
799 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
800 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
801 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
802 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
803 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
806 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
808 return VC_ERROR_NONE;
811 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
813 if (0 != __vc_get_feature_enabled()) {
814 return VC_ERROR_NOT_SUPPORTED;
816 if (0 != __vc_check_privilege()) {
817 return VC_ERROR_PERMISSION_DENIED;
820 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get system command list");
822 if (NULL == vc_sys_cmd_list) {
823 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
824 return VC_ERROR_INVALID_PARAMETER;
828 if (0 != vc_client_get_client_state(g_vc, &state)) {
829 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
830 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
831 return VC_ERROR_INVALID_STATE;
835 if (state != VC_STATE_READY) {
836 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
837 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
838 return VC_ERROR_INVALID_STATE;
841 /* Check service state */
842 vc_service_state_e service_state = -1;
843 vc_client_get_service_state(g_vc, &service_state);
844 if (service_state != VC_SERVICE_STATE_READY) {
845 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
846 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
847 return VC_ERROR_INVALID_STATE;
850 bool is_sys_cmd_valid = false;
855 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
857 if (VC_ERROR_TIMED_OUT != ret) {
858 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
861 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
864 if (VC_RETRY_COUNT == count) {
865 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
873 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
875 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
876 return VC_ERROR_OPERATION_FAILED;
879 vc_cmd_list_s* list = NULL;
880 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
881 if (true == is_sys_cmd_valid) {
882 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
884 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
887 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
889 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
892 *vc_sys_cmd_list = (vc_cmd_list_h)list;
894 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
895 *vc_sys_cmd_list = NULL;
896 return VC_ERROR_NONE;
899 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
905 * @brief Checks whether the command format is supported.
906 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
908 * @param[in] format The command format
909 * @param[out] support The result status @c true = supported, @c false = not supported
911 * @return 0 on success, otherwise a negative error value
912 * @retval #VC_ERROR_NONE Successful
913 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
914 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
915 * @retval #VC_ERROR_INVALID_STATE Invalid state
917 * @pre The state should be #VC_STATE_READY.
919 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
921 if (0 != __vc_get_feature_enabled()) {
922 return VC_ERROR_NOT_SUPPORTED;
924 if (0 != __vc_check_privilege()) {
925 return VC_ERROR_PERMISSION_DENIED;
928 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
931 if (0 != vc_client_get_client_state(g_vc, &state)) {
932 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
933 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
934 return VC_ERROR_INVALID_STATE;
938 bool non_fixed_support = false;
939 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
940 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
944 case VC_CMD_FORMAT_FIXED: *support = true; break;
945 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
946 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
947 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
948 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
949 default: *support = false; break;
952 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
954 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
956 return VC_ERROR_NONE;
959 static int __vc_get_invocation_name(char** invocation_name)
961 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
963 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
967 if (NULL == *invocation_name) {
968 char* temp_label = NULL;
972 ret = app_manager_get_app_id(getpid(), &appid);
973 if (0 != ret || NULL == appid) {
974 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
979 return VC_ERROR_OPERATION_FAILED;
982 ret = vc_get_current_language(&lang);
983 if (0 != ret || NULL == lang) {
984 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
991 return VC_ERROR_OPERATION_FAILED;
994 ret = app_info_get_localed_label(appid, lang, &temp_label);
995 if (0 != ret || NULL == temp_label) {
996 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
1001 if (NULL != temp_label) {
1005 return VC_ERROR_OPERATION_FAILED;
1008 *invocation_name = strdup(temp_label);
1009 if (NULL == *invocation_name) {
1010 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1011 return VC_ERROR_OUT_OF_MEMORY;
1022 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1023 return VC_ERROR_NONE;
1026 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1028 if (0 != __vc_get_feature_enabled()) {
1029 return VC_ERROR_NOT_SUPPORTED;
1031 if (0 != __vc_check_privilege()) {
1032 return VC_ERROR_PERMISSION_DENIED;
1035 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list");
1037 if (NULL == vc_cmd_list) {
1038 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1039 return VC_ERROR_INVALID_PARAMETER;
1043 if (0 != vc_client_get_client_state(g_vc, &state)) {
1044 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1045 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1046 return VC_ERROR_INVALID_STATE;
1050 if (state != VC_STATE_READY) {
1051 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1052 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1053 return VC_ERROR_INVALID_STATE;
1057 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1058 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1059 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1060 return VC_ERROR_INVALID_PARAMETER;
1063 vc_cmd_list_s* list = NULL;
1064 list = (vc_cmd_list_s*)vc_cmd_list;
1066 if (NULL == list->list) {
1067 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list");
1068 return VC_ERROR_INVALID_PARAMETER;
1072 char* invocation_name = NULL;
1073 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1074 ret = __vc_get_invocation_name(&invocation_name);
1075 if (0 != ret || NULL == invocation_name) {
1076 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1081 ret = vc_cmd_parser_delete_file(getpid(), type);
1083 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1085 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1087 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1091 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1093 if (VC_ERROR_TIMED_OUT != ret) {
1094 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1097 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1100 if (VC_RETRY_COUNT == count) {
1101 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1109 if (NULL != invocation_name) {
1110 free(invocation_name);
1111 invocation_name = NULL;
1114 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1119 int vc_unset_command_list(int type)
1121 if (0 != __vc_get_feature_enabled()) {
1122 return VC_ERROR_NOT_SUPPORTED;
1124 if (0 != __vc_check_privilege()) {
1125 return VC_ERROR_PERMISSION_DENIED;
1128 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unset Command list");
1131 if (0 != vc_client_get_client_state(g_vc, &state)) {
1132 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1133 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1134 return VC_ERROR_INVALID_STATE;
1138 if (state != VC_STATE_READY) {
1139 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1140 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1141 return VC_ERROR_INVALID_STATE;
1147 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1149 if (VC_ERROR_TIMED_OUT != ret) {
1150 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1153 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1156 if (VC_RETRY_COUNT == count) {
1157 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1164 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1166 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1167 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1170 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1175 int vc_set_command_list_from_file(const char* file_path, int type)
1177 if (0 != __vc_get_feature_enabled()) {
1178 return VC_ERROR_NOT_SUPPORTED;
1180 if (0 != __vc_check_privilege()) {
1181 return VC_ERROR_PERMISSION_DENIED;
1184 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set Command list from file");
1187 if (0 != vc_client_get_client_state(g_vc, &state)) {
1188 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1189 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1190 return VC_ERROR_INVALID_STATE;
1194 if (state != VC_STATE_READY) {
1195 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1196 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1197 return VC_ERROR_INVALID_STATE;
1201 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1202 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1203 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1204 return VC_ERROR_INVALID_PARAMETER;
1208 char* invocation_name = NULL;
1209 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1210 ret = __vc_get_invocation_name(&invocation_name);
1211 if (0 != ret || NULL == invocation_name) {
1212 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1217 ret = vc_cmd_parser_delete_file(getpid(), type);
1219 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1221 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1223 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1227 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1229 if (VC_ERROR_TIMED_OUT != ret) {
1230 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1233 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1236 if (VC_RETRY_COUNT == count) {
1237 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1245 if (NULL != invocation_name) {
1246 free(invocation_name);
1247 invocation_name = NULL;
1250 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1255 int vc_get_exclusive_command_option(bool* value)
1257 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get exclusive command");
1260 if (0 != vc_client_get_client_state(g_vc, &state)) {
1261 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1262 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1263 return VC_ERROR_INVALID_STATE;
1267 if (state != VC_STATE_READY) {
1268 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1269 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1270 return VC_ERROR_INVALID_STATE;
1273 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1275 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1276 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1280 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1285 int vc_set_exclusive_command_option(bool value)
1287 if (0 != __vc_get_feature_enabled()) {
1288 return VC_ERROR_NOT_SUPPORTED;
1290 if (0 != __vc_check_privilege()) {
1291 return VC_ERROR_PERMISSION_DENIED;
1294 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Set exclusive command");
1297 if (0 != vc_client_get_client_state(g_vc, &state)) {
1298 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1299 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1300 return VC_ERROR_INVALID_STATE;
1304 if (state != VC_STATE_READY) {
1305 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1306 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1307 return VC_ERROR_INVALID_STATE;
1310 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1312 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1313 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1319 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1321 if (VC_ERROR_TIMED_OUT != ret) {
1322 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1325 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1328 if (VC_RETRY_COUNT == count) {
1329 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1336 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1343 int vc_request_start(bool stop_by_silence)
1345 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
1348 if (0 != vc_client_get_client_state(g_vc, &state)) {
1349 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1350 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1351 return VC_ERROR_INVALID_STATE;
1355 if (state != VC_STATE_READY) {
1356 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1357 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1358 return VC_ERROR_INVALID_STATE;
1361 /* Check service state */
1362 vc_service_state_e service_state = -1;
1363 vc_client_get_service_state(g_vc, &service_state);
1364 if (service_state != VC_SERVICE_STATE_READY) {
1365 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1366 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1367 return VC_ERROR_INVALID_STATE;
1377 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1379 if (VC_ERROR_TIMED_OUT != ret) {
1380 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1383 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1386 if (VC_RETRY_COUNT == count) {
1387 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1392 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1396 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1401 int vc_request_stop(void)
1403 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
1406 if (0 != vc_client_get_client_state(g_vc, &state)) {
1407 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1408 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1409 return VC_ERROR_INVALID_STATE;
1413 if (state != VC_STATE_READY) {
1414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1415 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1416 return VC_ERROR_INVALID_STATE;
1419 /* Check service state */
1420 vc_service_state_e service_state = -1;
1421 vc_client_get_service_state(g_vc, &service_state);
1422 if (service_state != VC_SERVICE_STATE_RECORDING) {
1423 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1424 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1425 return VC_ERROR_INVALID_STATE;
1432 ret = vc_dbus_request_stop(g_vc->handle);
1434 if (VC_ERROR_TIMED_OUT != ret) {
1435 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1438 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1441 if (VC_RETRY_COUNT == count) {
1442 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1447 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1451 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1456 int vc_request_cancel(void)
1458 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel Interrupt");
1461 if (0 != vc_client_get_client_state(g_vc, &state)) {
1462 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1463 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1464 return VC_ERROR_INVALID_STATE;
1468 if (state != VC_STATE_READY) {
1469 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1470 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1471 return VC_ERROR_INVALID_STATE;
1474 /* Check service state */
1475 vc_service_state_e service_state = -1;
1476 vc_client_get_service_state(g_vc, &service_state);
1477 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1478 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1479 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1480 return VC_ERROR_INVALID_STATE;
1486 ret = vc_dbus_request_cancel(g_vc->handle);
1488 if (VC_ERROR_TIMED_OUT != ret) {
1489 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1492 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1495 if (VC_RETRY_COUNT == count) {
1496 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1501 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1505 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1511 Eina_Bool __vc_notify_error(void *data)
1513 vc_h vc = (vc_h)data;
1515 vc_error_cb callback = NULL;
1519 vc_client_get_error_cb(vc, &callback, &user_data);
1520 vc_client_get_error(vc, &reason);
1522 if (NULL != callback) {
1523 vc_client_use_callback(vc);
1524 callback(reason, user_data);
1525 vc_client_not_use_callback(vc);
1526 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1528 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1534 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1537 if (0 != vc_client_get_client_state(g_vc, &state)) {
1538 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1543 if (state != VC_STATE_READY) {
1544 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1548 if (VC_ERROR_SERVICE_RESET == reason) {
1549 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1551 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1552 __vc_notify_state_changed(g_vc);
1554 if (0 != vc_prepare()) {
1555 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1559 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1561 vc_client_set_error(g_vc, reason);
1562 ecore_timer_add(0, __vc_notify_error, g_vc);
1567 Eina_Bool __vc_notify_state_changed(void *data)
1569 vc_h vc = (vc_h)data;
1571 vc_state_changed_cb changed_callback = NULL;
1574 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1576 vc_state_e current_state;
1577 vc_state_e before_state;
1579 vc_client_get_before_state(vc, ¤t_state, &before_state);
1581 if (NULL != changed_callback) {
1582 vc_client_use_callback(vc);
1583 changed_callback(before_state, current_state, user_data);
1584 vc_client_not_use_callback(vc);
1585 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1587 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1593 static Eina_Bool __vc_notify_result(void *data)
1597 vc_cmd_list_h vc_cmd_list = NULL;
1599 vc_result_cb callback = NULL;
1600 void* user_data = NULL;
1602 vc_client_get_result_cb(g_vc, &callback, &user_data);
1604 if (NULL == callback) {
1605 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1609 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1610 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1614 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1616 SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1618 vc_cmd_print_list(vc_cmd_list);
1620 vc_client_use_callback(g_vc);
1621 callback(event, vc_cmd_list, temp_text, user_data);
1622 vc_client_not_use_callback(g_vc);
1624 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1626 vc_cmd_list_destroy(vc_cmd_list, true);
1628 /* Release result */
1629 if (NULL != temp_text) free(temp_text);
1634 void __vc_cb_result(void)
1636 ecore_timer_add(0, __vc_notify_result, NULL);
1641 int vc_get_result(vc_result_cb callback, void* user_data)
1643 if (0 != __vc_get_feature_enabled()) {
1644 return VC_ERROR_NOT_SUPPORTED;
1646 if (0 != __vc_check_privilege()) {
1647 return VC_ERROR_PERMISSION_DENIED;
1650 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1652 if (NULL == callback) {
1653 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1654 return VC_ERROR_INVALID_PARAMETER;
1657 char* temp_text = NULL;
1659 vc_cmd_list_h vc_cmd_list = NULL;
1661 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1662 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1663 return VC_ERROR_INVALID_PARAMETER;
1666 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1667 if (0 != ret || NULL == temp_text) {
1668 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1672 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1674 vc_cmd_print_list(vc_cmd_list);
1676 vc_client_use_callback(g_vc);
1677 callback(event, vc_cmd_list, temp_text, user_data);
1678 vc_client_not_use_callback(g_vc);
1680 vc_cmd_list_destroy(vc_cmd_list, true);
1682 /* Release result */
1683 if (NULL != temp_text) {
1688 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1690 return VC_ERROR_NONE;
1693 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1695 if (0 != __vc_get_feature_enabled()) {
1696 return VC_ERROR_NOT_SUPPORTED;
1698 if (0 != __vc_check_privilege()) {
1699 return VC_ERROR_PERMISSION_DENIED;
1702 if (NULL == callback)
1703 return VC_ERROR_INVALID_PARAMETER;
1706 if (0 != vc_client_get_client_state(g_vc, &state)) {
1707 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1708 return VC_ERROR_INVALID_STATE;
1712 if (state != VC_STATE_INITIALIZED) {
1713 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1714 return VC_ERROR_INVALID_STATE;
1717 vc_client_set_result_cb(g_vc, callback, user_data);
1722 int vc_unset_result_cb(void)
1724 if (0 != __vc_get_feature_enabled()) {
1725 return VC_ERROR_NOT_SUPPORTED;
1727 if (0 != __vc_check_privilege()) {
1728 return VC_ERROR_PERMISSION_DENIED;
1732 if (0 != vc_client_get_client_state(g_vc, &state)) {
1733 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1734 return VC_ERROR_INVALID_STATE;
1738 if (state != VC_STATE_INITIALIZED) {
1739 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1740 return VC_ERROR_INVALID_STATE;
1743 vc_client_set_result_cb(g_vc, NULL, NULL);
1748 int __vc_cb_service_state(int state)
1750 vc_service_state_e current_state = (vc_service_state_e)state;
1751 vc_service_state_e before_state;
1752 vc_client_get_service_state(g_vc, &before_state);
1754 if (current_state == before_state) {
1758 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1759 before_state, current_state);
1761 /* Save service state */
1762 vc_client_set_service_state(g_vc, current_state);
1764 vc_service_state_changed_cb callback = NULL;
1765 void* service_user_data;
1766 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1768 if (NULL != callback) {
1769 vc_client_use_callback(g_vc);
1770 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1771 vc_client_not_use_callback(g_vc);
1772 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1774 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1780 int __vc_cb_manager_pid(int manager_pid)
1782 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1784 /* Save service state */
1785 vc_client_set_mgr_pid(g_vc, manager_pid);
1790 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1792 if (0 != __vc_get_feature_enabled()) {
1793 return VC_ERROR_NOT_SUPPORTED;
1795 if (0 != __vc_check_privilege()) {
1796 return VC_ERROR_PERMISSION_DENIED;
1799 if (NULL == callback)
1800 return VC_ERROR_INVALID_PARAMETER;
1803 if (0 != vc_client_get_client_state(g_vc, &state)) {
1804 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1805 return VC_ERROR_INVALID_STATE;
1809 if (state != VC_STATE_INITIALIZED) {
1810 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1811 return VC_ERROR_INVALID_STATE;
1814 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1819 int vc_unset_service_state_changed_cb(void)
1821 if (0 != __vc_get_feature_enabled()) {
1822 return VC_ERROR_NOT_SUPPORTED;
1824 if (0 != __vc_check_privilege()) {
1825 return VC_ERROR_PERMISSION_DENIED;
1829 if (0 != vc_client_get_client_state(g_vc, &state)) {
1830 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1831 return VC_ERROR_INVALID_STATE;
1835 if (state != VC_STATE_INITIALIZED) {
1836 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1837 return VC_ERROR_INVALID_STATE;
1840 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1845 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1847 if (0 != __vc_get_feature_enabled()) {
1848 return VC_ERROR_NOT_SUPPORTED;
1850 if (0 != __vc_check_privilege()) {
1851 return VC_ERROR_PERMISSION_DENIED;
1854 if (callback == NULL)
1855 return VC_ERROR_INVALID_PARAMETER;
1858 if (0 != vc_client_get_client_state(g_vc, &state)) {
1859 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1860 return VC_ERROR_INVALID_STATE;
1864 if (state != VC_STATE_INITIALIZED) {
1865 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1866 return VC_ERROR_INVALID_STATE;
1869 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1874 int vc_unset_state_changed_cb(void)
1876 if (0 != __vc_get_feature_enabled()) {
1877 return VC_ERROR_NOT_SUPPORTED;
1879 if (0 != __vc_check_privilege()) {
1880 return VC_ERROR_PERMISSION_DENIED;
1884 if (0 != vc_client_get_client_state(g_vc, &state)) {
1885 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1886 return VC_ERROR_INVALID_STATE;
1890 if (state != VC_STATE_INITIALIZED) {
1891 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1892 return VC_ERROR_INVALID_STATE;
1895 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1900 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1902 if (0 != __vc_get_feature_enabled()) {
1903 return VC_ERROR_NOT_SUPPORTED;
1905 if (0 != __vc_check_privilege()) {
1906 return VC_ERROR_PERMISSION_DENIED;
1909 if (NULL == callback)
1910 return VC_ERROR_INVALID_PARAMETER;
1913 if (0 != vc_client_get_client_state(g_vc, &state)) {
1914 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1915 return VC_ERROR_INVALID_STATE;
1919 if (state != VC_STATE_INITIALIZED) {
1920 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1921 return VC_ERROR_INVALID_STATE;
1924 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1929 int vc_unset_current_language_changed_cb(void)
1931 if (0 != __vc_get_feature_enabled()) {
1932 return VC_ERROR_NOT_SUPPORTED;
1934 if (0 != __vc_check_privilege()) {
1935 return VC_ERROR_PERMISSION_DENIED;
1939 if (0 != vc_client_get_client_state(g_vc, &state)) {
1940 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1941 return VC_ERROR_INVALID_STATE;
1945 if (state != VC_STATE_INITIALIZED) {
1946 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1947 return VC_ERROR_INVALID_STATE;
1950 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1955 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1957 if (0 != __vc_get_feature_enabled()) {
1958 return VC_ERROR_NOT_SUPPORTED;
1960 if (0 != __vc_check_privilege()) {
1961 return VC_ERROR_PERMISSION_DENIED;
1964 if (NULL == callback)
1965 return VC_ERROR_INVALID_PARAMETER;
1968 if (0 != vc_client_get_client_state(g_vc, &state)) {
1969 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1970 return VC_ERROR_INVALID_STATE;
1974 if (state != VC_STATE_INITIALIZED) {
1975 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1976 return VC_ERROR_INVALID_STATE;
1979 vc_client_set_error_cb(g_vc, callback, user_data);
1984 int vc_unset_error_cb(void)
1986 if (0 != __vc_get_feature_enabled()) {
1987 return VC_ERROR_NOT_SUPPORTED;
1989 if (0 != __vc_check_privilege()) {
1990 return VC_ERROR_PERMISSION_DENIED;
1994 if (0 != vc_client_get_client_state(g_vc, &state)) {
1995 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
1996 return VC_ERROR_INVALID_STATE;
2000 if (state != VC_STATE_INITIALIZED) {
2001 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2002 return VC_ERROR_INVALID_STATE;
2005 vc_client_set_error_cb(g_vc, NULL, NULL);
2010 int vc_set_invocation_name(const char* name)
2012 if (0 != __vc_get_feature_enabled()) {
2013 return VC_ERROR_NOT_SUPPORTED;
2015 if (0 != __vc_check_privilege()) {
2016 return VC_ERROR_PERMISSION_DENIED;
2020 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2022 int ret = vc_client_get_client_state(g_vc, &state);
2024 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2025 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2030 if (state != VC_STATE_READY) {
2031 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2032 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2033 return VC_ERROR_INVALID_STATE;
2036 ret = vc_client_set_invocation_name(g_vc, name);
2038 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2043 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2047 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2048 if (0 != __vc_get_feature_enabled()) {
2049 return VC_ERROR_NOT_SUPPORTED;
2051 if (0 != __vc_check_privilege()) {
2052 return VC_ERROR_PERMISSION_DENIED;
2055 if (0 != vc_client_get_client_state(g_vc, &state)) {
2056 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2057 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2058 return VC_ERROR_INVALID_STATE;
2062 if (state != VC_STATE_READY) {
2063 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2064 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2065 return VC_ERROR_INVALID_STATE;
2068 /* Check service state */
2069 vc_service_state_e service_state = -1;
2070 vc_client_get_service_state(g_vc, &service_state);
2071 if (service_state != VC_SERVICE_STATE_READY) {
2072 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2073 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2074 return VC_ERROR_INVALID_STATE;
2077 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);
2078 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2080 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2081 return VC_ERROR_OPERATION_FAILED;
2084 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2086 return VC_ERROR_NONE;
2090 int vc_auth_enable(void)
2094 if (0 != vc_client_get_client_state(g_vc, &state)) {
2095 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2096 return VC_ERROR_INVALID_STATE;
2099 if (VC_STATE_READY != state) {
2100 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2101 return VC_ERROR_INVALID_STATE;
2104 /* check already authority */
2105 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2106 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2107 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2108 return VC_ERROR_INVALID_STATE;
2111 if (VC_AUTH_STATE_NONE != auth_state) {
2112 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2113 return VC_ERROR_INVALID_STATE;
2116 /* request authority */
2118 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2119 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2120 return VC_ERROR_OPERATION_FAILED;
2123 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2124 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2125 return VC_ERROR_OPERATION_FAILED;
2128 /* set authority into handle */
2129 bool is_foreground = false;
2130 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2131 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2132 return VC_ERROR_OPERATION_FAILED;
2135 if (is_foreground) {
2136 auth_state = VC_AUTH_STATE_VALID;
2138 auth_state = VC_AUTH_STATE_INVALID;
2141 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2142 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2143 return VC_ERROR_OPERATION_FAILED;
2146 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2148 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2150 return VC_ERROR_NONE;
2153 int vc_auth_disable(void)
2157 if (0 != vc_client_get_client_state(g_vc, &state)) {
2158 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2159 return VC_ERROR_INVALID_STATE;
2162 if (VC_STATE_READY != state) {
2163 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2164 return VC_ERROR_INVALID_STATE;
2167 /* check autority */
2168 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2169 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2170 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2171 return VC_ERROR_INVALID_STATE;
2174 if (VC_AUTH_STATE_NONE == auth_state) {
2175 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2176 return VC_ERROR_INVALID_STATE;
2179 if (0 != vc_auth_unset_state_changed_cb()) {
2180 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2183 /* request return authority by dbus */
2185 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2186 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2187 return VC_ERROR_OPERATION_FAILED;
2190 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2191 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2192 return VC_ERROR_OPERATION_FAILED;
2195 /* unset authority from handle */
2196 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2197 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2198 return VC_ERROR_OPERATION_FAILED;
2201 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2203 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2205 return VC_ERROR_NONE;
2208 int vc_auth_get_state(vc_auth_state_e* state)
2211 vc_state_e vc_state;
2212 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2213 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2214 return VC_ERROR_INVALID_STATE;
2217 if (VC_STATE_READY != vc_state) {
2218 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2219 return VC_ERROR_INVALID_STATE;
2223 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2224 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2225 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2226 return VC_ERROR_INVALID_STATE;
2231 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2233 return VC_ERROR_NONE;
2236 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2238 /* check parameter */
2239 if (NULL == callback) {
2240 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2241 return VC_ERROR_INVALID_PARAMETER;
2245 vc_auth_state_e auth_state;
2246 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2247 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2248 return VC_ERROR_INVALID_STATE;
2251 if (VC_AUTH_STATE_NONE == auth_state) {
2252 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2253 return VC_ERROR_INVALID_STATE;
2256 /* set cb into handle */
2257 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2258 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2259 return VC_ERROR_OPERATION_FAILED;
2262 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2264 return VC_ERROR_NONE;
2267 int vc_auth_unset_state_changed_cb(void)
2270 vc_auth_state_e auth_state;
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] Auto is not enabled");
2278 return VC_ERROR_INVALID_STATE;
2281 /* unset cb from handle */
2282 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2283 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2284 return VC_ERROR_OPERATION_FAILED;
2287 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2289 return VC_ERROR_NONE;
2292 int vc_auth_start(void)
2294 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2297 if (0 != vc_client_get_client_state(g_vc, &state)) {
2298 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2299 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2300 return VC_ERROR_INVALID_STATE;
2304 if (state != VC_STATE_READY) {
2305 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2306 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2307 return VC_ERROR_INVALID_STATE;
2310 /* Check service state */
2311 vc_service_state_e service_state = -1;
2312 vc_client_get_service_state(g_vc, &service_state);
2313 if (service_state != VC_SERVICE_STATE_READY) {
2314 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2315 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2316 return VC_ERROR_INVALID_STATE;
2319 /* Check authority */
2320 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2321 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2322 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2323 return VC_ERROR_OPERATION_FAILED;
2326 if (VC_AUTH_STATE_VALID != auth_state) {
2327 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2328 return VC_ERROR_OPERATION_FAILED;
2333 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2335 return VC_ERROR_OPERATION_FAILED;
2344 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2346 if (VC_ERROR_TIMED_OUT != ret) {
2347 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2350 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2353 if (VC_RETRY_COUNT == count) {
2354 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2359 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2363 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2368 int vc_auth_stop(void)
2370 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
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_RECORDING) {
2390 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
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;
2418 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2420 if (VC_ERROR_TIMED_OUT != ret) {
2421 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2424 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2427 if (VC_RETRY_COUNT == count) {
2428 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2433 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2437 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2442 int vc_auth_cancel(void)
2444 SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2447 if (0 != vc_client_get_client_state(g_vc, &state)) {
2448 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2449 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2450 return VC_ERROR_INVALID_STATE;
2454 if (state != VC_STATE_READY) {
2455 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2456 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2457 return VC_ERROR_INVALID_STATE;
2460 /* Check service state */
2461 vc_service_state_e service_state = -1;
2462 vc_client_get_service_state(g_vc, &service_state);
2463 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2464 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2465 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2466 return VC_ERROR_INVALID_STATE;
2469 /* Check authority */
2470 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2471 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2472 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2473 return VC_ERROR_OPERATION_FAILED;
2476 if (VC_AUTH_STATE_VALID != auth_state) {
2477 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2478 return VC_ERROR_OPERATION_FAILED;
2483 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2484 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2485 return VC_ERROR_OPERATION_FAILED;
2491 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2493 if (VC_ERROR_TIMED_OUT != ret) {
2494 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2497 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2500 if (VC_RETRY_COUNT == count) {
2501 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2506 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2510 SLOG(LOG_DEBUG, TAG_VCC, "@@@");