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, "=====");
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_ERROR, TAG_VCC, "[ERROR] Already initialized");
315 return VC_ERROR_INVALID_STATE;
318 if (0 < vc_client_get_count()) {
319 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
320 return VC_ERROR_INVALID_STATE;
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, "=====");
360 SLOG(LOG_DEBUG, TAG_VCC, " ");
362 return VC_ERROR_NONE;
365 static void __vc_internal_unprepare(void)
367 /* return authority */
368 vc_auth_state_e state = VC_AUTH_STATE_NONE;
369 if (0 != vc_client_get_auth_state(g_vc, &state)) {
370 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
373 if (VC_AUTH_STATE_NONE != state) {
374 if (0 != vc_auth_disable()) {
375 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
379 int ret = vc_dbus_request_finalize(g_vc->handle);
381 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
384 if (NULL != g_focus_in_handler) {
385 ecore_event_handler_del(g_focus_in_handler);
386 g_focus_in_handler = NULL;
388 if (NULL != g_focus_out_handler) {
389 ecore_event_handler_del(g_focus_out_handler);
390 g_focus_out_handler = NULL;
393 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
395 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
400 int vc_deinitialize(void)
402 if (0 != __vc_get_feature_enabled()) {
403 return VC_ERROR_NOT_SUPPORTED;
405 if (0 != __vc_check_privilege()) {
406 return VC_ERROR_PERMISSION_DENIED;
409 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
411 if (false == vc_client_is_valid(g_vc)) {
412 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
413 SLOG(LOG_DEBUG, TAG_VCC, "=====");
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);
432 vc_config_mgr_unset_lang_cb(g_vc->handle);
433 vc_config_mgr_finalize(g_vc->handle);
435 /* Free client resources */
436 vc_client_destroy(g_vc);
443 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
444 int ret = vc_db_finalize();
446 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret);
449 if (0 != vc_dbus_close_connection()) {
450 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
453 SLOG(LOG_DEBUG, TAG_VCC, "=====");
454 SLOG(LOG_DEBUG, TAG_VCC, " ");
456 return VC_ERROR_NONE;
459 static Eina_Bool __vc_connect_daemon(void *data)
462 if (0 != vc_dbus_request_hello()) {
466 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
468 /* request initialization */
471 int service_state = 0;
473 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
475 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
477 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
478 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
481 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
482 ecore_timer_add(0, __vc_notify_error, g_vc);
484 SLOG(LOG_DEBUG, TAG_VCC, "=====");
485 SLOG(LOG_DEBUG, TAG_VCC, " ");
488 } else if (0 != ret) {
489 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
491 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
492 ecore_timer_add(0, __vc_notify_error, g_vc);
494 SLOG(LOG_DEBUG, TAG_VCC, "=====");
495 SLOG(LOG_DEBUG, TAG_VCC, " ");
498 /* Success to connect */
501 /* Set service state */
502 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
504 g_connect_timer = NULL;
506 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
507 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
509 char appid[255] = {'\0',};
510 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
512 int status = aul_app_get_status(appid);
513 if (STATUS_FOCUS == status) {
514 SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
515 ret = vc_dbus_set_foreground(getpid(), true);
517 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
520 ret = vc_client_set_is_foreground(g_vc, true);
522 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
525 /* set authority valid */
526 vc_auth_state_e state = VC_AUTH_STATE_NONE;
527 if (0 != vc_client_get_auth_state(g_vc, &state)) {
528 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
530 if (VC_AUTH_STATE_INVALID == state) {
531 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
533 /* notify auth changed cb */
534 ecore_idler_add(__notify_auth_changed_cb, NULL);
538 vc_client_set_client_state(g_vc, VC_STATE_READY);
539 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
541 vc_client_set_mgr_pid(g_vc, mgr_pid);
543 SLOG(LOG_DEBUG, TAG_VCC, "=====");
544 SLOG(LOG_DEBUG, TAG_VCC, " ");
551 if (0 != __vc_get_feature_enabled()) {
552 return VC_ERROR_NOT_SUPPORTED;
554 if (0 != __vc_check_privilege()) {
555 return VC_ERROR_PERMISSION_DENIED;
558 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
561 if (0 != vc_client_get_client_state(g_vc, &state)) {
562 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
563 SLOG(LOG_DEBUG, TAG_VCC, "=====");
564 SLOG(LOG_DEBUG, TAG_VCC, " ");
565 return VC_ERROR_INVALID_STATE;
569 if (state != VC_STATE_INITIALIZED) {
570 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
571 SLOG(LOG_DEBUG, TAG_VCC, "=====");
572 SLOG(LOG_DEBUG, TAG_VCC, " ");
573 return VC_ERROR_INVALID_STATE;
576 g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
578 SLOG(LOG_DEBUG, TAG_VCC, "=====");
579 SLOG(LOG_DEBUG, TAG_VCC, " ");
581 return VC_ERROR_NONE;
584 int vc_unprepare(void)
586 if (0 != __vc_get_feature_enabled()) {
587 return VC_ERROR_NOT_SUPPORTED;
589 if (0 != __vc_check_privilege()) {
590 return VC_ERROR_PERMISSION_DENIED;
593 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
596 if (0 != vc_client_get_client_state(g_vc, &state)) {
597 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
598 SLOG(LOG_DEBUG, TAG_VCC, "=====");
599 SLOG(LOG_DEBUG, TAG_VCC, " ");
600 return VC_ERROR_INVALID_STATE;
604 if (state != VC_STATE_READY) {
605 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
606 SLOG(LOG_DEBUG, TAG_VCC, "=====");
607 SLOG(LOG_DEBUG, TAG_VCC, " ");
608 return VC_ERROR_INVALID_STATE;
611 __vc_internal_unprepare();
613 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
614 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
616 SLOG(LOG_DEBUG, TAG_VCC, "=====");
617 SLOG(LOG_DEBUG, TAG_VCC, " ");
619 return VC_ERROR_NONE;
622 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
624 if (0 != __vc_get_feature_enabled()) {
625 return VC_ERROR_NOT_SUPPORTED;
627 if (0 != __vc_check_privilege()) {
628 return VC_ERROR_PERMISSION_DENIED;
631 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
633 if (NULL == callback) {
634 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
635 SLOG(LOG_DEBUG, TAG_VCC, "=====");
636 SLOG(LOG_DEBUG, TAG_VCC, " ");
637 return VC_ERROR_INVALID_PARAMETER;
641 if (0 != vc_client_get_client_state(g_vc, &state)) {
642 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
643 SLOG(LOG_DEBUG, TAG_VCC, "=====");
644 SLOG(LOG_DEBUG, TAG_VCC, " ");
645 return VC_ERROR_INVALID_STATE;
649 ret = vc_config_mgr_get_language_list(callback, user_data);
651 ret = vc_config_convert_error_code((vc_config_error_e)ret);
652 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
655 SLOG(LOG_DEBUG, TAG_VCC, "=====");
656 SLOG(LOG_DEBUG, TAG_VCC, " ");
658 return VC_ERROR_NONE;
662 int vc_get_current_language(char** language)
664 if (0 != __vc_get_feature_enabled()) {
665 return VC_ERROR_NOT_SUPPORTED;
667 if (0 != __vc_check_privilege()) {
668 return VC_ERROR_PERMISSION_DENIED;
671 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
673 if (NULL == language) {
674 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
675 SLOG(LOG_DEBUG, TAG_VCC, "=====");
676 SLOG(LOG_DEBUG, TAG_VCC, " ");
677 return VC_ERROR_INVALID_PARAMETER;
681 if (0 != vc_client_get_client_state(g_vc, &state)) {
682 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
683 SLOG(LOG_DEBUG, TAG_VCC, "=====");
684 SLOG(LOG_DEBUG, TAG_VCC, " ");
685 return VC_ERROR_INVALID_STATE;
689 ret = vc_config_mgr_get_default_language(language);
691 ret = vc_config_convert_error_code((vc_config_error_e)ret);
692 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
695 SLOG(LOG_DEBUG, TAG_VCC, "=====");
696 SLOG(LOG_DEBUG, TAG_VCC, " ");
701 int vc_get_state(vc_state_e* state)
703 if (0 != __vc_get_feature_enabled()) {
704 return VC_ERROR_NOT_SUPPORTED;
706 if (0 != __vc_check_privilege()) {
707 return VC_ERROR_PERMISSION_DENIED;
710 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
713 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
714 return VC_ERROR_INVALID_PARAMETER;
718 if (0 != vc_client_get_client_state(g_vc, &temp)) {
719 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
720 SLOG(LOG_DEBUG, TAG_VCC, "=====");
721 SLOG(LOG_DEBUG, TAG_VCC, " ");
722 return VC_ERROR_INVALID_STATE;
728 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
729 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
730 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
731 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
734 SLOG(LOG_DEBUG, TAG_VCC, "=====");
735 SLOG(LOG_DEBUG, TAG_VCC, " ");
737 return VC_ERROR_NONE;
740 int vc_get_service_state(vc_service_state_e* state)
742 if (0 != __vc_get_feature_enabled()) {
743 return VC_ERROR_NOT_SUPPORTED;
745 if (0 != __vc_check_privilege()) {
746 return VC_ERROR_PERMISSION_DENIED;
749 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
752 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
753 return VC_ERROR_INVALID_PARAMETER;
757 if (0 != vc_client_get_client_state(g_vc, &temp)) {
758 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
759 SLOG(LOG_DEBUG, TAG_VCC, "=====");
760 SLOG(LOG_DEBUG, TAG_VCC, " ");
761 return VC_ERROR_INVALID_STATE;
764 if (VC_STATE_READY != temp) {
765 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
766 SLOG(LOG_DEBUG, TAG_VCC, "=====");
767 SLOG(LOG_DEBUG, TAG_VCC, " ");
768 return VC_ERROR_INVALID_STATE;
771 /* get service state */
772 vc_service_state_e service_state;
773 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
774 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
775 return VC_ERROR_OPERATION_FAILED;
778 *state = service_state;
781 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
782 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
783 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
784 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
785 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
788 SLOG(LOG_DEBUG, TAG_VCC, "=====");
789 SLOG(LOG_DEBUG, TAG_VCC, " ");
791 return VC_ERROR_NONE;
794 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
796 if (0 != __vc_get_feature_enabled()) {
797 return VC_ERROR_NOT_SUPPORTED;
799 if (0 != __vc_check_privilege()) {
800 return VC_ERROR_PERMISSION_DENIED;
803 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get system command list");
805 if (NULL == vc_sys_cmd_list) {
806 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
807 return VC_ERROR_INVALID_PARAMETER;
811 if (0 != vc_client_get_client_state(g_vc, &state)) {
812 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
813 SLOG(LOG_DEBUG, TAG_VCC, "=====");
814 SLOG(LOG_DEBUG, TAG_VCC, " ");
815 return VC_ERROR_INVALID_STATE;
819 if (state != VC_STATE_READY) {
820 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
821 SLOG(LOG_DEBUG, TAG_VCC, "=====");
822 SLOG(LOG_DEBUG, TAG_VCC, " ");
823 return VC_ERROR_INVALID_STATE;
826 /* Check service state */
827 vc_service_state_e service_state = -1;
828 vc_client_get_service_state(g_vc, &service_state);
829 if (service_state != VC_SERVICE_STATE_READY) {
830 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
831 SLOG(LOG_DEBUG, TAG_VCC, "=====");
832 SLOG(LOG_DEBUG, TAG_VCC, " ");
833 return VC_ERROR_INVALID_STATE;
836 bool is_sys_cmd_valid = false;
841 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
843 if (VC_ERROR_TIMED_OUT != ret) {
844 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
847 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
850 if (VC_RETRY_COUNT == count) {
851 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
859 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
861 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
862 return VC_ERROR_OPERATION_FAILED;
865 vc_cmd_list_s* list = NULL;
866 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
867 if (true == is_sys_cmd_valid) {
868 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
870 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
873 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
875 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
878 *vc_sys_cmd_list = (vc_cmd_list_h)list;
880 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
881 *vc_sys_cmd_list = NULL;
882 return VC_ERROR_NONE;
885 SLOG(LOG_DEBUG, TAG_VCC, "=====");
886 SLOG(LOG_DEBUG, TAG_VCC, " ");
892 * @brief Checks whether the command format is supported.
893 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
895 * @param[in] format The command format
896 * @param[out] support The result status @c true = supported, @c false = not supported
898 * @return 0 on success, otherwise a negative error value
899 * @retval #VC_ERROR_NONE Successful
900 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
901 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
902 * @retval #VC_ERROR_INVALID_STATE Invalid state
904 * @pre The state should be #VC_STATE_READY.
906 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
908 if (0 != __vc_get_feature_enabled()) {
909 return VC_ERROR_NOT_SUPPORTED;
911 if (0 != __vc_check_privilege()) {
912 return VC_ERROR_PERMISSION_DENIED;
915 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
918 if (0 != vc_client_get_client_state(g_vc, &state)) {
919 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
920 SLOG(LOG_DEBUG, TAG_VCC, "=====");
921 SLOG(LOG_DEBUG, TAG_VCC, " ");
922 return VC_ERROR_INVALID_STATE;
926 bool non_fixed_support = false;
927 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
928 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
932 case VC_CMD_FORMAT_FIXED: *support = true; break;
933 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
934 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
935 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
936 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
937 default: *support = false; break;
940 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
942 SLOG(LOG_DEBUG, TAG_VCC, "=====");
943 SLOG(LOG_DEBUG, TAG_VCC, " ");
945 return VC_ERROR_NONE;
948 static int __vc_get_invocation_name(char** invocation_name)
950 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
952 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
956 if (NULL == *invocation_name) {
957 char* temp_label = NULL;
961 ret = app_manager_get_app_id(getpid(), &appid);
962 if (0 != ret || NULL == appid) {
963 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
968 return VC_ERROR_OPERATION_FAILED;
971 ret = vc_get_current_language(&lang);
972 if (0 != ret || NULL == lang) {
973 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
980 return VC_ERROR_OPERATION_FAILED;
983 ret = app_info_get_localed_label(appid, lang, &temp_label);
984 if (0 != ret || NULL == temp_label) {
985 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
990 if (NULL != temp_label) {
994 return VC_ERROR_OPERATION_FAILED;
997 *invocation_name = strdup(temp_label);
998 if (NULL == *invocation_name) {
999 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1000 return VC_ERROR_OUT_OF_MEMORY;
1011 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1012 return VC_ERROR_NONE;
1015 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1017 if (0 != __vc_get_feature_enabled()) {
1018 return VC_ERROR_NOT_SUPPORTED;
1020 if (0 != __vc_check_privilege()) {
1021 return VC_ERROR_PERMISSION_DENIED;
1024 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
1026 if (NULL == vc_cmd_list) {
1027 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1028 return VC_ERROR_INVALID_PARAMETER;
1032 if (0 != vc_client_get_client_state(g_vc, &state)) {
1033 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1034 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1035 SLOG(LOG_DEBUG, TAG_VCC, " ");
1036 return VC_ERROR_INVALID_STATE;
1040 if (state != VC_STATE_READY) {
1041 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1042 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1043 SLOG(LOG_DEBUG, TAG_VCC, " ");
1044 return VC_ERROR_INVALID_STATE;
1048 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1049 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1050 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1051 SLOG(LOG_DEBUG, TAG_VCC, " ");
1052 return VC_ERROR_INVALID_PARAMETER;
1055 vc_cmd_list_s* list = NULL;
1056 list = (vc_cmd_list_s*)vc_cmd_list;
1059 char* invocation_name = NULL;
1060 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1061 ret = __vc_get_invocation_name(&invocation_name);
1062 if (0 != ret || NULL == invocation_name) {
1063 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1068 ret = vc_cmd_parser_delete_file(getpid(), type);
1070 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1072 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1074 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1078 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1080 if (VC_ERROR_TIMED_OUT != ret) {
1081 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1084 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1087 if (VC_RETRY_COUNT == count) {
1088 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1096 if (NULL != invocation_name) {
1097 free(invocation_name);
1098 invocation_name = NULL;
1101 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1102 SLOG(LOG_DEBUG, TAG_VCC, " ");
1107 int vc_unset_command_list(int type)
1109 if (0 != __vc_get_feature_enabled()) {
1110 return VC_ERROR_NOT_SUPPORTED;
1112 if (0 != __vc_check_privilege()) {
1113 return VC_ERROR_PERMISSION_DENIED;
1116 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1119 if (0 != vc_client_get_client_state(g_vc, &state)) {
1120 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1121 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1122 SLOG(LOG_DEBUG, TAG_VCC, " ");
1123 return VC_ERROR_INVALID_STATE;
1127 if (state != VC_STATE_READY) {
1128 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1129 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1130 SLOG(LOG_DEBUG, TAG_VCC, " ");
1131 return VC_ERROR_INVALID_STATE;
1137 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1139 if (VC_ERROR_TIMED_OUT != ret) {
1140 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1143 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1146 if (VC_RETRY_COUNT == count) {
1147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1154 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1156 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1157 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1160 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1161 SLOG(LOG_DEBUG, TAG_VCC, " ");
1166 int vc_set_command_list_from_file(const char* file_path, int type)
1168 if (0 != __vc_get_feature_enabled()) {
1169 return VC_ERROR_NOT_SUPPORTED;
1171 if (0 != __vc_check_privilege()) {
1172 return VC_ERROR_PERMISSION_DENIED;
1175 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list from file");
1178 if (0 != vc_client_get_client_state(g_vc, &state)) {
1179 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1180 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1181 SLOG(LOG_DEBUG, TAG_VCC, " ");
1182 return VC_ERROR_INVALID_STATE;
1186 if (state != VC_STATE_READY) {
1187 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1188 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1189 SLOG(LOG_DEBUG, TAG_VCC, " ");
1190 return VC_ERROR_INVALID_STATE;
1194 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1195 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1196 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1197 SLOG(LOG_DEBUG, TAG_VCC, " ");
1198 return VC_ERROR_INVALID_PARAMETER;
1202 char* invocation_name = NULL;
1203 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1204 ret = __vc_get_invocation_name(&invocation_name);
1205 if (0 != ret || NULL == invocation_name) {
1206 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1211 ret = vc_cmd_parser_delete_file(getpid(), type);
1213 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1215 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1217 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1221 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1223 if (VC_ERROR_TIMED_OUT != ret) {
1224 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1227 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1230 if (VC_RETRY_COUNT == count) {
1231 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1239 if (NULL != invocation_name) {
1240 free(invocation_name);
1241 invocation_name = NULL;
1244 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1245 SLOG(LOG_DEBUG, TAG_VCC, " ");
1250 int vc_get_exclusive_command_option(bool* value)
1252 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1255 if (0 != vc_client_get_client_state(g_vc, &state)) {
1256 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1257 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1258 SLOG(LOG_DEBUG, TAG_VCC, " ");
1259 return VC_ERROR_INVALID_STATE;
1263 if (state != VC_STATE_READY) {
1264 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1265 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1266 SLOG(LOG_DEBUG, TAG_VCC, " ");
1267 return VC_ERROR_INVALID_STATE;
1270 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1272 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1273 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1274 SLOG(LOG_DEBUG, TAG_VCC, " ");
1278 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1279 SLOG(LOG_DEBUG, TAG_VCC, " ");
1284 int vc_set_exclusive_command_option(bool value)
1286 if (0 != __vc_get_feature_enabled()) {
1287 return VC_ERROR_NOT_SUPPORTED;
1289 if (0 != __vc_check_privilege()) {
1290 return VC_ERROR_PERMISSION_DENIED;
1293 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
1296 if (0 != vc_client_get_client_state(g_vc, &state)) {
1297 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1298 SLOG(LOG_DEBUG, TAG_VCC, "=====");
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 SLOG(LOG_DEBUG, TAG_VCC, " ");
1308 return VC_ERROR_INVALID_STATE;
1311 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1313 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1314 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1315 SLOG(LOG_DEBUG, TAG_VCC, " ");
1321 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1323 if (VC_ERROR_TIMED_OUT != ret) {
1324 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1327 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1330 if (VC_RETRY_COUNT == count) {
1331 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1338 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1339 SLOG(LOG_DEBUG, TAG_VCC, " ");
1346 int vc_request_start(bool stop_by_silence)
1348 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1351 if (0 != vc_client_get_client_state(g_vc, &state)) {
1352 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1353 SLOG(LOG_DEBUG, TAG_VCC, "=====");
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: client state is not 'READY'");
1361 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1362 SLOG(LOG_DEBUG, TAG_VCC, " ");
1363 return VC_ERROR_INVALID_STATE;
1366 /* Check service state */
1367 vc_service_state_e service_state = -1;
1368 vc_client_get_service_state(g_vc, &service_state);
1369 if (service_state != VC_SERVICE_STATE_READY) {
1370 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1371 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1372 SLOG(LOG_DEBUG, TAG_VCC, " ");
1373 return VC_ERROR_INVALID_STATE;
1383 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1385 if (VC_ERROR_TIMED_OUT != ret) {
1386 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1389 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1392 if (VC_RETRY_COUNT == count) {
1393 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1398 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1402 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1403 SLOG(LOG_DEBUG, TAG_VCC, " ");
1408 int vc_request_stop(void)
1410 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1413 if (0 != vc_client_get_client_state(g_vc, &state)) {
1414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1415 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1416 SLOG(LOG_DEBUG, TAG_VCC, " ");
1417 return VC_ERROR_INVALID_STATE;
1421 if (state != VC_STATE_READY) {
1422 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1423 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1424 SLOG(LOG_DEBUG, TAG_VCC, " ");
1425 return VC_ERROR_INVALID_STATE;
1428 /* Check service state */
1429 vc_service_state_e service_state = -1;
1430 vc_client_get_service_state(g_vc, &service_state);
1431 if (service_state != VC_SERVICE_STATE_RECORDING) {
1432 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1433 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1434 SLOG(LOG_DEBUG, TAG_VCC, " ");
1435 return VC_ERROR_INVALID_STATE;
1442 ret = vc_dbus_request_stop(g_vc->handle);
1444 if (VC_ERROR_TIMED_OUT != ret) {
1445 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1448 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1451 if (VC_RETRY_COUNT == count) {
1452 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1457 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1461 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1462 SLOG(LOG_DEBUG, TAG_VCC, " ");
1467 int vc_request_cancel(void)
1469 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1472 if (0 != vc_client_get_client_state(g_vc, &state)) {
1473 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1474 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1475 SLOG(LOG_DEBUG, TAG_VCC, " ");
1476 return VC_ERROR_INVALID_STATE;
1480 if (state != VC_STATE_READY) {
1481 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1482 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1483 SLOG(LOG_DEBUG, TAG_VCC, " ");
1484 return VC_ERROR_INVALID_STATE;
1487 /* Check service state */
1488 vc_service_state_e service_state = -1;
1489 vc_client_get_service_state(g_vc, &service_state);
1490 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1491 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1492 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1493 SLOG(LOG_DEBUG, TAG_VCC, " ");
1494 return VC_ERROR_INVALID_STATE;
1500 ret = vc_dbus_request_cancel(g_vc->handle);
1502 if (VC_ERROR_TIMED_OUT != ret) {
1503 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1506 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1509 if (VC_RETRY_COUNT == count) {
1510 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1515 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1519 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1520 SLOG(LOG_DEBUG, TAG_VCC, " ");
1526 Eina_Bool __vc_notify_error(void *data)
1528 vc_h vc = (vc_h)data;
1530 vc_error_cb callback = NULL;
1534 vc_client_get_error_cb(vc, &callback, &user_data);
1535 vc_client_get_error(vc, &reason);
1537 if (NULL != callback) {
1538 vc_client_use_callback(vc);
1539 callback(reason, user_data);
1540 vc_client_not_use_callback(vc);
1541 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1543 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1549 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1552 if (0 != vc_client_get_client_state(g_vc, &state)) {
1553 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1558 if (state != VC_STATE_READY) {
1559 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1563 if (VC_ERROR_SERVICE_RESET == reason) {
1564 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1566 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1567 __vc_notify_state_changed(g_vc);
1569 if (0 != vc_prepare()) {
1570 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1574 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1576 vc_client_set_error(g_vc, reason);
1577 ecore_timer_add(0, __vc_notify_error, g_vc);
1582 Eina_Bool __vc_notify_state_changed(void *data)
1584 vc_h vc = (vc_h)data;
1586 vc_state_changed_cb changed_callback = NULL;
1589 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1591 vc_state_e current_state;
1592 vc_state_e before_state;
1594 vc_client_get_before_state(vc, ¤t_state, &before_state);
1596 if (NULL != changed_callback) {
1597 vc_client_use_callback(vc);
1598 changed_callback(before_state, current_state, user_data);
1599 vc_client_not_use_callback(vc);
1600 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1602 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1608 static Eina_Bool __vc_notify_result(void *data)
1612 vc_cmd_list_h vc_cmd_list = NULL;
1614 vc_result_cb callback = NULL;
1615 void* user_data = NULL;
1617 vc_client_get_result_cb(g_vc, &callback, &user_data);
1619 if (NULL == callback) {
1620 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1624 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1625 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1629 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1631 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1633 vc_cmd_print_list(vc_cmd_list);
1635 vc_client_use_callback(g_vc);
1636 callback(event, vc_cmd_list, temp_text, user_data);
1637 vc_client_not_use_callback(g_vc);
1639 SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1641 vc_cmd_list_destroy(vc_cmd_list, true);
1643 /* Release result */
1644 if (NULL != temp_text) free(temp_text);
1649 void __vc_cb_result(void)
1651 ecore_timer_add(0, __vc_notify_result, NULL);
1656 int vc_get_result(vc_result_cb callback, void* user_data)
1658 if (0 != __vc_get_feature_enabled()) {
1659 return VC_ERROR_NOT_SUPPORTED;
1661 if (0 != __vc_check_privilege()) {
1662 return VC_ERROR_PERMISSION_DENIED;
1665 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get result");
1667 if (NULL == callback) {
1668 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1669 return VC_ERROR_INVALID_PARAMETER;
1672 char* temp_text = NULL;
1674 vc_cmd_list_h vc_cmd_list = NULL;
1676 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1677 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1678 return VC_ERROR_INVALID_PARAMETER;
1681 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1682 if (0 != ret || NULL == temp_text) {
1683 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1687 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1689 vc_cmd_print_list(vc_cmd_list);
1691 vc_client_use_callback(g_vc);
1692 callback(event, vc_cmd_list, temp_text, user_data);
1693 vc_client_not_use_callback(g_vc);
1695 vc_cmd_list_destroy(vc_cmd_list, true);
1697 /* Release result */
1698 if (NULL != temp_text) {
1703 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1704 SLOG(LOG_DEBUG, TAG_VCC, " ");
1706 return VC_ERROR_NONE;
1709 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1711 if (0 != __vc_get_feature_enabled()) {
1712 return VC_ERROR_NOT_SUPPORTED;
1714 if (0 != __vc_check_privilege()) {
1715 return VC_ERROR_PERMISSION_DENIED;
1718 if (NULL == callback)
1719 return VC_ERROR_INVALID_PARAMETER;
1722 if (0 != vc_client_get_client_state(g_vc, &state)) {
1723 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1724 return VC_ERROR_INVALID_STATE;
1728 if (state != VC_STATE_INITIALIZED) {
1729 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1730 return VC_ERROR_INVALID_STATE;
1733 vc_client_set_result_cb(g_vc, callback, user_data);
1738 int vc_unset_result_cb(void)
1740 if (0 != __vc_get_feature_enabled()) {
1741 return VC_ERROR_NOT_SUPPORTED;
1743 if (0 != __vc_check_privilege()) {
1744 return VC_ERROR_PERMISSION_DENIED;
1748 if (0 != vc_client_get_client_state(g_vc, &state)) {
1749 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1750 return VC_ERROR_INVALID_STATE;
1754 if (state != VC_STATE_INITIALIZED) {
1755 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1756 return VC_ERROR_INVALID_STATE;
1759 vc_client_set_result_cb(g_vc, NULL, NULL);
1764 int __vc_cb_service_state(int state)
1766 vc_service_state_e current_state = (vc_service_state_e)state;
1767 vc_service_state_e before_state;
1768 vc_client_get_service_state(g_vc, &before_state);
1770 if (current_state == before_state) {
1774 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1775 before_state, current_state);
1777 /* Save service state */
1778 vc_client_set_service_state(g_vc, current_state);
1780 vc_service_state_changed_cb callback = NULL;
1781 void* service_user_data;
1782 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1784 if (NULL != callback) {
1785 vc_client_use_callback(g_vc);
1786 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1787 vc_client_not_use_callback(g_vc);
1788 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1790 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1796 int __vc_cb_manager_pid(int manager_pid)
1798 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1800 /* Save service state */
1801 vc_client_set_mgr_pid(g_vc, manager_pid);
1806 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1808 if (0 != __vc_get_feature_enabled()) {
1809 return VC_ERROR_NOT_SUPPORTED;
1811 if (0 != __vc_check_privilege()) {
1812 return VC_ERROR_PERMISSION_DENIED;
1815 if (NULL == callback)
1816 return VC_ERROR_INVALID_PARAMETER;
1819 if (0 != vc_client_get_client_state(g_vc, &state)) {
1820 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1821 return VC_ERROR_INVALID_STATE;
1825 if (state != VC_STATE_INITIALIZED) {
1826 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1827 return VC_ERROR_INVALID_STATE;
1830 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1835 int vc_unset_service_state_changed_cb(void)
1837 if (0 != __vc_get_feature_enabled()) {
1838 return VC_ERROR_NOT_SUPPORTED;
1840 if (0 != __vc_check_privilege()) {
1841 return VC_ERROR_PERMISSION_DENIED;
1845 if (0 != vc_client_get_client_state(g_vc, &state)) {
1846 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1847 return VC_ERROR_INVALID_STATE;
1851 if (state != VC_STATE_INITIALIZED) {
1852 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1853 return VC_ERROR_INVALID_STATE;
1856 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1861 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1863 if (0 != __vc_get_feature_enabled()) {
1864 return VC_ERROR_NOT_SUPPORTED;
1866 if (0 != __vc_check_privilege()) {
1867 return VC_ERROR_PERMISSION_DENIED;
1870 if (callback == NULL)
1871 return VC_ERROR_INVALID_PARAMETER;
1874 if (0 != vc_client_get_client_state(g_vc, &state)) {
1875 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1876 return VC_ERROR_INVALID_STATE;
1880 if (state != VC_STATE_INITIALIZED) {
1881 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1882 return VC_ERROR_INVALID_STATE;
1885 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1890 int vc_unset_state_changed_cb(void)
1892 if (0 != __vc_get_feature_enabled()) {
1893 return VC_ERROR_NOT_SUPPORTED;
1895 if (0 != __vc_check_privilege()) {
1896 return VC_ERROR_PERMISSION_DENIED;
1900 if (0 != vc_client_get_client_state(g_vc, &state)) {
1901 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1902 return VC_ERROR_INVALID_STATE;
1906 if (state != VC_STATE_INITIALIZED) {
1907 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1908 return VC_ERROR_INVALID_STATE;
1911 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1916 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1918 if (0 != __vc_get_feature_enabled()) {
1919 return VC_ERROR_NOT_SUPPORTED;
1921 if (0 != __vc_check_privilege()) {
1922 return VC_ERROR_PERMISSION_DENIED;
1925 if (NULL == callback)
1926 return VC_ERROR_INVALID_PARAMETER;
1929 if (0 != vc_client_get_client_state(g_vc, &state)) {
1930 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1931 return VC_ERROR_INVALID_STATE;
1935 if (state != VC_STATE_INITIALIZED) {
1936 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1937 return VC_ERROR_INVALID_STATE;
1940 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1945 int vc_unset_current_language_changed_cb(void)
1947 if (0 != __vc_get_feature_enabled()) {
1948 return VC_ERROR_NOT_SUPPORTED;
1950 if (0 != __vc_check_privilege()) {
1951 return VC_ERROR_PERMISSION_DENIED;
1955 if (0 != vc_client_get_client_state(g_vc, &state)) {
1956 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1957 return VC_ERROR_INVALID_STATE;
1961 if (state != VC_STATE_INITIALIZED) {
1962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1963 return VC_ERROR_INVALID_STATE;
1966 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1971 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1973 if (0 != __vc_get_feature_enabled()) {
1974 return VC_ERROR_NOT_SUPPORTED;
1976 if (0 != __vc_check_privilege()) {
1977 return VC_ERROR_PERMISSION_DENIED;
1980 if (NULL == callback)
1981 return VC_ERROR_INVALID_PARAMETER;
1984 if (0 != vc_client_get_client_state(g_vc, &state)) {
1985 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1986 return VC_ERROR_INVALID_STATE;
1990 if (state != VC_STATE_INITIALIZED) {
1991 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1992 return VC_ERROR_INVALID_STATE;
1995 vc_client_set_error_cb(g_vc, callback, user_data);
2000 int vc_unset_error_cb(void)
2002 if (0 != __vc_get_feature_enabled()) {
2003 return VC_ERROR_NOT_SUPPORTED;
2005 if (0 != __vc_check_privilege()) {
2006 return VC_ERROR_PERMISSION_DENIED;
2010 if (0 != vc_client_get_client_state(g_vc, &state)) {
2011 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2012 return VC_ERROR_INVALID_STATE;
2016 if (state != VC_STATE_INITIALIZED) {
2017 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2018 return VC_ERROR_INVALID_STATE;
2021 vc_client_set_error_cb(g_vc, NULL, NULL);
2026 int vc_set_invocation_name(const char* name)
2028 if (0 != __vc_get_feature_enabled()) {
2029 return VC_ERROR_NOT_SUPPORTED;
2031 if (0 != __vc_check_privilege()) {
2032 return VC_ERROR_PERMISSION_DENIED;
2036 SLOG(LOG_DEBUG, TAG_VCC, "===== Set invocation name");
2038 int ret = vc_client_get_client_state(g_vc, &state);
2040 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2041 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2042 SLOG(LOG_DEBUG, TAG_VCC, " ");
2047 if (state != VC_STATE_READY) {
2048 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2049 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2050 SLOG(LOG_DEBUG, TAG_VCC, " ");
2051 return VC_ERROR_INVALID_STATE;
2054 ret = vc_client_set_invocation_name(g_vc, name);
2056 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2061 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2065 SLOG(LOG_DEBUG, TAG_VCC, "===== Request dialog");
2066 if (0 != __vc_get_feature_enabled()) {
2067 return VC_ERROR_NOT_SUPPORTED;
2069 if (0 != __vc_check_privilege()) {
2070 return VC_ERROR_PERMISSION_DENIED;
2073 if (0 != vc_client_get_client_state(g_vc, &state)) {
2074 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2075 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2076 SLOG(LOG_DEBUG, TAG_VCC, " ");
2077 return VC_ERROR_INVALID_STATE;
2081 if (state != VC_STATE_READY) {
2082 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2083 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2084 SLOG(LOG_DEBUG, TAG_VCC, " ");
2085 return VC_ERROR_INVALID_STATE;
2088 /* Check service state */
2089 vc_service_state_e service_state = -1;
2090 vc_client_get_service_state(g_vc, &service_state);
2091 if (service_state != VC_SERVICE_STATE_READY) {
2092 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2093 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2094 SLOG(LOG_DEBUG, TAG_VCC, " ");
2095 return VC_ERROR_INVALID_STATE;
2098 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);
2099 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2101 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2102 return VC_ERROR_OPERATION_FAILED;
2105 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2106 SLOG(LOG_DEBUG, TAG_VCC, " ");
2108 return VC_ERROR_NONE;
2112 int vc_auth_enable(void)
2116 if (0 != vc_client_get_client_state(g_vc, &state)) {
2117 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2118 return VC_ERROR_INVALID_STATE;
2121 if (VC_STATE_READY != state) {
2122 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2123 return VC_ERROR_INVALID_STATE;
2126 /* check already authority */
2127 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2128 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2129 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2130 return VC_ERROR_INVALID_STATE;
2133 if (VC_AUTH_STATE_NONE != auth_state) {
2134 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2135 return VC_ERROR_INVALID_STATE;
2138 /* request authority */
2140 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2141 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2142 return VC_ERROR_OPERATION_FAILED;
2145 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2147 return VC_ERROR_OPERATION_FAILED;
2150 /* set authority into handle */
2151 bool is_foreground = false;
2152 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2153 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2154 return VC_ERROR_OPERATION_FAILED;
2157 if (is_foreground) {
2158 auth_state = VC_AUTH_STATE_VALID;
2160 auth_state = VC_AUTH_STATE_INVALID;
2163 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2164 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2165 return VC_ERROR_OPERATION_FAILED;
2168 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2170 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2172 return VC_ERROR_NONE;
2175 int vc_auth_disable(void)
2179 if (0 != vc_client_get_client_state(g_vc, &state)) {
2180 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2181 return VC_ERROR_INVALID_STATE;
2184 if (VC_STATE_READY != state) {
2185 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2186 return VC_ERROR_INVALID_STATE;
2189 /* check autority */
2190 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2191 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2192 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2193 return VC_ERROR_INVALID_STATE;
2196 if (VC_AUTH_STATE_NONE == auth_state) {
2197 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2198 return VC_ERROR_INVALID_STATE;
2201 if (0 != vc_auth_unset_state_changed_cb()) {
2202 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2205 /* request return authority by dbus */
2207 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2208 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2209 return VC_ERROR_OPERATION_FAILED;
2212 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2213 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2214 return VC_ERROR_OPERATION_FAILED;
2217 /* unset authority from handle */
2218 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2219 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2220 return VC_ERROR_OPERATION_FAILED;
2223 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2225 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2227 return VC_ERROR_NONE;
2230 int vc_auth_get_state(vc_auth_state_e* state)
2233 vc_state_e vc_state;
2234 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2235 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2236 return VC_ERROR_INVALID_STATE;
2239 if (VC_STATE_READY != vc_state) {
2240 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2241 return VC_ERROR_INVALID_STATE;
2245 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2246 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2247 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2248 return VC_ERROR_INVALID_STATE;
2253 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2255 return VC_ERROR_NONE;
2258 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2260 /* check parameter */
2261 if (NULL == callback) {
2262 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2263 return VC_ERROR_INVALID_PARAMETER;
2267 vc_auth_state_e auth_state;
2268 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2269 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2270 return VC_ERROR_INVALID_STATE;
2273 if (VC_AUTH_STATE_NONE == auth_state) {
2274 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2275 return VC_ERROR_INVALID_STATE;
2278 /* set cb into handle */
2279 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2280 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2281 return VC_ERROR_OPERATION_FAILED;
2284 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2286 return VC_ERROR_NONE;
2289 int vc_auth_unset_state_changed_cb(void)
2292 vc_auth_state_e auth_state;
2293 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2294 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2295 return VC_ERROR_INVALID_STATE;
2298 if (VC_AUTH_STATE_NONE == auth_state) {
2299 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2300 return VC_ERROR_INVALID_STATE;
2303 /* unset cb from handle */
2304 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2305 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2306 return VC_ERROR_OPERATION_FAILED;
2309 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2311 return VC_ERROR_NONE;
2314 int vc_auth_start(void)
2316 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
2319 if (0 != vc_client_get_client_state(g_vc, &state)) {
2320 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2321 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2322 SLOG(LOG_DEBUG, TAG_VCC, " ");
2323 return VC_ERROR_INVALID_STATE;
2327 if (state != VC_STATE_READY) {
2328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2329 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2330 SLOG(LOG_DEBUG, TAG_VCC, " ");
2331 return VC_ERROR_INVALID_STATE;
2334 /* Check service state */
2335 vc_service_state_e service_state = -1;
2336 vc_client_get_service_state(g_vc, &service_state);
2337 if (service_state != VC_SERVICE_STATE_READY) {
2338 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2339 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2340 SLOG(LOG_DEBUG, TAG_VCC, " ");
2341 return VC_ERROR_INVALID_STATE;
2344 /* Check authority */
2345 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2346 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2347 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2348 return VC_ERROR_OPERATION_FAILED;
2351 if (VC_AUTH_STATE_VALID != auth_state) {
2352 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2353 return VC_ERROR_OPERATION_FAILED;
2358 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2359 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2360 return VC_ERROR_OPERATION_FAILED;
2369 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2371 if (VC_ERROR_TIMED_OUT != ret) {
2372 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2375 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2378 if (VC_RETRY_COUNT == count) {
2379 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2384 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2388 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2389 SLOG(LOG_DEBUG, TAG_VCC, " ");
2394 int vc_auth_stop(void)
2396 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
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 SLOG(LOG_DEBUG, TAG_VCC, " ");
2403 return VC_ERROR_INVALID_STATE;
2407 if (state != VC_STATE_READY) {
2408 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2409 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2410 SLOG(LOG_DEBUG, TAG_VCC, " ");
2411 return VC_ERROR_INVALID_STATE;
2414 /* Check service state */
2415 vc_service_state_e service_state = -1;
2416 vc_client_get_service_state(g_vc, &service_state);
2417 if (service_state != VC_SERVICE_STATE_RECORDING) {
2418 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2419 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2420 SLOG(LOG_DEBUG, TAG_VCC, " ");
2421 return VC_ERROR_INVALID_STATE;
2424 /* Check authority */
2425 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2426 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2427 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2428 return VC_ERROR_OPERATION_FAILED;
2431 if (VC_AUTH_STATE_VALID != auth_state) {
2432 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2433 return VC_ERROR_OPERATION_FAILED;
2438 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2439 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2440 return VC_ERROR_OPERATION_FAILED;
2447 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2449 if (VC_ERROR_TIMED_OUT != ret) {
2450 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2453 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2456 if (VC_RETRY_COUNT == count) {
2457 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2462 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2466 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2467 SLOG(LOG_DEBUG, TAG_VCC, " ");
2472 int vc_auth_cancel(void)
2474 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2477 if (0 != vc_client_get_client_state(g_vc, &state)) {
2478 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2479 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2480 SLOG(LOG_DEBUG, TAG_VCC, " ");
2481 return VC_ERROR_INVALID_STATE;
2485 if (state != VC_STATE_READY) {
2486 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2487 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2488 SLOG(LOG_DEBUG, TAG_VCC, " ");
2489 return VC_ERROR_INVALID_STATE;
2492 /* Check service state */
2493 vc_service_state_e service_state = -1;
2494 vc_client_get_service_state(g_vc, &service_state);
2495 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2496 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2497 SLOG(LOG_DEBUG, TAG_VCC, "=====");
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;
2524 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2526 if (VC_ERROR_TIMED_OUT != ret) {
2527 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2530 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2533 if (VC_RETRY_COUNT == count) {
2534 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2539 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2543 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2544 SLOG(LOG_DEBUG, TAG_VCC, " ");