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);
430 g_connect_timer = NULL;
433 vc_config_mgr_unset_lang_cb(g_vc->handle);
434 vc_config_mgr_finalize(g_vc->handle);
436 /* Free client resources */
437 vc_client_destroy(g_vc);
444 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
445 int ret = vc_db_finalize();
447 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to finalize DB, ret(%d)", ret);
450 if (0 != vc_dbus_close_connection()) {
451 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
454 SLOG(LOG_DEBUG, TAG_VCC, "=====");
455 SLOG(LOG_DEBUG, TAG_VCC, " ");
457 return VC_ERROR_NONE;
460 static Eina_Bool __vc_connect_daemon(void *data)
463 if (0 != vc_dbus_request_hello()) {
467 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
469 /* request initialization */
472 int service_state = 0;
474 g_connect_timer = NULL;
476 ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
478 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret);
480 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
481 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
482 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
484 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
485 ecore_timer_add(0, __vc_notify_error, g_vc);
487 SLOG(LOG_DEBUG, TAG_VCC, "=====");
488 SLOG(LOG_DEBUG, TAG_VCC, " ");
491 } else if (0 != ret) {
492 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
494 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
495 ecore_timer_add(0, __vc_notify_error, g_vc);
497 SLOG(LOG_DEBUG, TAG_VCC, "=====");
498 SLOG(LOG_DEBUG, TAG_VCC, " ");
501 /* Success to connect */
504 /* Set service state */
505 vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
507 g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
508 g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
510 char appid[255] = {'\0',};
511 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
513 int status = aul_app_get_status(appid);
514 if (STATUS_FOCUS == status) {
515 SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
516 ret = vc_dbus_set_foreground(getpid(), true);
518 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
521 ret = vc_client_set_is_foreground(g_vc, true);
523 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
526 /* set authority valid */
527 vc_auth_state_e state = VC_AUTH_STATE_NONE;
528 if (0 != vc_client_get_auth_state(g_vc, &state)) {
529 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
531 if (VC_AUTH_STATE_INVALID == state) {
532 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
534 /* notify auth changed cb */
535 ecore_idler_add(__notify_auth_changed_cb, NULL);
539 vc_client_set_client_state(g_vc, VC_STATE_READY);
540 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
542 vc_client_set_mgr_pid(g_vc, mgr_pid);
544 SLOG(LOG_DEBUG, TAG_VCC, "=====");
545 SLOG(LOG_DEBUG, TAG_VCC, " ");
552 if (0 != __vc_get_feature_enabled()) {
553 return VC_ERROR_NOT_SUPPORTED;
555 if (0 != __vc_check_privilege()) {
556 return VC_ERROR_PERMISSION_DENIED;
559 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
562 if (0 != vc_client_get_client_state(g_vc, &state)) {
563 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
564 SLOG(LOG_DEBUG, TAG_VCC, "=====");
565 SLOG(LOG_DEBUG, TAG_VCC, " ");
566 return VC_ERROR_INVALID_STATE;
570 if (state != VC_STATE_INITIALIZED) {
571 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
572 SLOG(LOG_DEBUG, TAG_VCC, "=====");
573 SLOG(LOG_DEBUG, TAG_VCC, " ");
574 return VC_ERROR_INVALID_STATE;
577 g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
579 SLOG(LOG_DEBUG, TAG_VCC, "=====");
580 SLOG(LOG_DEBUG, TAG_VCC, " ");
582 return VC_ERROR_NONE;
585 int vc_unprepare(void)
587 if (0 != __vc_get_feature_enabled()) {
588 return VC_ERROR_NOT_SUPPORTED;
590 if (0 != __vc_check_privilege()) {
591 return VC_ERROR_PERMISSION_DENIED;
594 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
597 if (0 != vc_client_get_client_state(g_vc, &state)) {
598 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
599 SLOG(LOG_DEBUG, TAG_VCC, "=====");
600 SLOG(LOG_DEBUG, TAG_VCC, " ");
601 return VC_ERROR_INVALID_STATE;
605 if (state != VC_STATE_READY) {
606 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
607 SLOG(LOG_DEBUG, TAG_VCC, "=====");
608 SLOG(LOG_DEBUG, TAG_VCC, " ");
609 return VC_ERROR_INVALID_STATE;
612 __vc_internal_unprepare();
614 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
615 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
617 SLOG(LOG_DEBUG, TAG_VCC, "=====");
618 SLOG(LOG_DEBUG, TAG_VCC, " ");
620 return VC_ERROR_NONE;
623 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
625 if (0 != __vc_get_feature_enabled()) {
626 return VC_ERROR_NOT_SUPPORTED;
628 if (0 != __vc_check_privilege()) {
629 return VC_ERROR_PERMISSION_DENIED;
632 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
634 if (NULL == callback) {
635 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
636 SLOG(LOG_DEBUG, TAG_VCC, "=====");
637 SLOG(LOG_DEBUG, TAG_VCC, " ");
638 return VC_ERROR_INVALID_PARAMETER;
642 if (0 != vc_client_get_client_state(g_vc, &state)) {
643 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
644 SLOG(LOG_DEBUG, TAG_VCC, "=====");
645 SLOG(LOG_DEBUG, TAG_VCC, " ");
646 return VC_ERROR_INVALID_STATE;
650 ret = vc_config_mgr_get_language_list(callback, user_data);
652 ret = vc_config_convert_error_code((vc_config_error_e)ret);
653 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
656 SLOG(LOG_DEBUG, TAG_VCC, "=====");
657 SLOG(LOG_DEBUG, TAG_VCC, " ");
659 return VC_ERROR_NONE;
663 int vc_get_current_language(char** language)
665 if (0 != __vc_get_feature_enabled()) {
666 return VC_ERROR_NOT_SUPPORTED;
668 if (0 != __vc_check_privilege()) {
669 return VC_ERROR_PERMISSION_DENIED;
672 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
674 if (NULL == language) {
675 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
676 SLOG(LOG_DEBUG, TAG_VCC, "=====");
677 SLOG(LOG_DEBUG, TAG_VCC, " ");
678 return VC_ERROR_INVALID_PARAMETER;
682 if (0 != vc_client_get_client_state(g_vc, &state)) {
683 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
684 SLOG(LOG_DEBUG, TAG_VCC, "=====");
685 SLOG(LOG_DEBUG, TAG_VCC, " ");
686 return VC_ERROR_INVALID_STATE;
690 ret = vc_config_mgr_get_default_language(language);
692 ret = vc_config_convert_error_code((vc_config_error_e)ret);
693 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
696 SLOG(LOG_DEBUG, TAG_VCC, "=====");
697 SLOG(LOG_DEBUG, TAG_VCC, " ");
702 int vc_get_state(vc_state_e* state)
704 if (0 != __vc_get_feature_enabled()) {
705 return VC_ERROR_NOT_SUPPORTED;
707 if (0 != __vc_check_privilege()) {
708 return VC_ERROR_PERMISSION_DENIED;
711 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
714 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
715 return VC_ERROR_INVALID_PARAMETER;
719 if (0 != vc_client_get_client_state(g_vc, &temp)) {
720 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
721 SLOG(LOG_DEBUG, TAG_VCC, "=====");
722 SLOG(LOG_DEBUG, TAG_VCC, " ");
723 return VC_ERROR_INVALID_STATE;
729 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
730 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
731 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
732 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
735 SLOG(LOG_DEBUG, TAG_VCC, "=====");
736 SLOG(LOG_DEBUG, TAG_VCC, " ");
738 return VC_ERROR_NONE;
741 int vc_get_service_state(vc_service_state_e* state)
743 if (0 != __vc_get_feature_enabled()) {
744 return VC_ERROR_NOT_SUPPORTED;
746 if (0 != __vc_check_privilege()) {
747 return VC_ERROR_PERMISSION_DENIED;
750 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
753 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
754 return VC_ERROR_INVALID_PARAMETER;
758 if (0 != vc_client_get_client_state(g_vc, &temp)) {
759 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
760 SLOG(LOG_DEBUG, TAG_VCC, "=====");
761 SLOG(LOG_DEBUG, TAG_VCC, " ");
762 return VC_ERROR_INVALID_STATE;
765 if (VC_STATE_READY != temp) {
766 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
767 SLOG(LOG_DEBUG, TAG_VCC, "=====");
768 SLOG(LOG_DEBUG, TAG_VCC, " ");
769 return VC_ERROR_INVALID_STATE;
772 /* get service state */
773 vc_service_state_e service_state;
774 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
775 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
776 return VC_ERROR_OPERATION_FAILED;
779 *state = service_state;
782 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
783 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
784 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
785 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
786 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
789 SLOG(LOG_DEBUG, TAG_VCC, "=====");
790 SLOG(LOG_DEBUG, TAG_VCC, " ");
792 return VC_ERROR_NONE;
795 int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
797 if (0 != __vc_get_feature_enabled()) {
798 return VC_ERROR_NOT_SUPPORTED;
800 if (0 != __vc_check_privilege()) {
801 return VC_ERROR_PERMISSION_DENIED;
804 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get system command list");
806 if (NULL == vc_sys_cmd_list) {
807 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
808 return VC_ERROR_INVALID_PARAMETER;
812 if (0 != vc_client_get_client_state(g_vc, &state)) {
813 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
814 SLOG(LOG_DEBUG, TAG_VCC, "=====");
815 SLOG(LOG_DEBUG, TAG_VCC, " ");
816 return VC_ERROR_INVALID_STATE;
820 if (state != VC_STATE_READY) {
821 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
822 SLOG(LOG_DEBUG, TAG_VCC, "=====");
823 SLOG(LOG_DEBUG, TAG_VCC, " ");
824 return VC_ERROR_INVALID_STATE;
827 /* Check service state */
828 vc_service_state_e service_state = -1;
829 vc_client_get_service_state(g_vc, &service_state);
830 if (service_state != VC_SERVICE_STATE_READY) {
831 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
832 SLOG(LOG_DEBUG, TAG_VCC, "=====");
833 SLOG(LOG_DEBUG, TAG_VCC, " ");
834 return VC_ERROR_INVALID_STATE;
837 bool is_sys_cmd_valid = false;
842 ret = vc_dbus_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
844 if (VC_ERROR_TIMED_OUT != ret) {
845 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to ask system command is : %s", __vc_get_error_code(ret));
848 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to ask system command is : %s", __vc_get_error_code(ret));
851 if (VC_RETRY_COUNT == count) {
852 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
860 ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
862 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid");
863 return VC_ERROR_OPERATION_FAILED;
866 vc_cmd_list_s* list = NULL;
867 list = (vc_cmd_list_s*)(*vc_sys_cmd_list);
868 if (true == is_sys_cmd_valid) {
869 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, &(list->list));
871 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
874 ret = vc_cmd_parser_get_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM_BACKGROUND, &(list->list));
876 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get parsing commands");
879 *vc_sys_cmd_list = (vc_cmd_list_h)list;
881 SLOG(LOG_WARN, TAG_VCC, "[WARNING] No system commands");
882 *vc_sys_cmd_list = NULL;
883 return VC_ERROR_NONE;
886 SLOG(LOG_DEBUG, TAG_VCC, "=====");
887 SLOG(LOG_DEBUG, TAG_VCC, " ");
893 * @brief Checks whether the command format is supported.
894 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
896 * @param[in] format The command format
897 * @param[out] support The result status @c true = supported, @c false = not supported
899 * @return 0 on success, otherwise a negative error value
900 * @retval #VC_ERROR_NONE Successful
901 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
902 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
903 * @retval #VC_ERROR_INVALID_STATE Invalid state
905 * @pre The state should be #VC_STATE_READY.
907 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
909 if (0 != __vc_get_feature_enabled()) {
910 return VC_ERROR_NOT_SUPPORTED;
912 if (0 != __vc_check_privilege()) {
913 return VC_ERROR_PERMISSION_DENIED;
916 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
919 if (0 != vc_client_get_client_state(g_vc, &state)) {
920 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
921 SLOG(LOG_DEBUG, TAG_VCC, "=====");
922 SLOG(LOG_DEBUG, TAG_VCC, " ");
923 return VC_ERROR_INVALID_STATE;
927 bool non_fixed_support = false;
928 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
929 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
933 case VC_CMD_FORMAT_FIXED: *support = true; break;
934 case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
935 case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
936 case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
937 case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
938 default: *support = false; break;
941 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
943 SLOG(LOG_DEBUG, TAG_VCC, "=====");
944 SLOG(LOG_DEBUG, TAG_VCC, " ");
946 return VC_ERROR_NONE;
949 static int __vc_get_invocation_name(char** invocation_name)
951 int ret = vc_client_get_invocation_name(g_vc, invocation_name);
953 SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name");
957 if (NULL == *invocation_name) {
958 char* temp_label = NULL;
962 ret = app_manager_get_app_id(getpid(), &appid);
963 if (0 != ret || NULL == appid) {
964 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get appid, ret(%d)", ret);
969 return VC_ERROR_OPERATION_FAILED;
972 ret = vc_get_current_language(&lang);
973 if (0 != ret || NULL == lang) {
974 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current laguage, ret(%d)", ret);
981 return VC_ERROR_OPERATION_FAILED;
984 ret = app_info_get_localed_label(appid, lang, &temp_label);
985 if (0 != ret || NULL == temp_label) {
986 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get localed label, ret(%d) appid(%s) lang(%s)", ret, appid, lang);
991 if (NULL != temp_label) {
995 return VC_ERROR_OPERATION_FAILED;
998 *invocation_name = strdup(temp_label);
999 if (NULL == *invocation_name) {
1000 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory");
1001 return VC_ERROR_OUT_OF_MEMORY;
1012 SLOG(LOG_DEBUG, TAG_VCC, "Get invocation name(%s)", *invocation_name);
1013 return VC_ERROR_NONE;
1016 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
1018 if (0 != __vc_get_feature_enabled()) {
1019 return VC_ERROR_NOT_SUPPORTED;
1021 if (0 != __vc_check_privilege()) {
1022 return VC_ERROR_PERMISSION_DENIED;
1025 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
1027 if (NULL == vc_cmd_list) {
1028 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
1029 return VC_ERROR_INVALID_PARAMETER;
1033 if (0 != vc_client_get_client_state(g_vc, &state)) {
1034 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1035 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1036 SLOG(LOG_DEBUG, TAG_VCC, " ");
1037 return VC_ERROR_INVALID_STATE;
1041 if (state != VC_STATE_READY) {
1042 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1043 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1044 SLOG(LOG_DEBUG, TAG_VCC, " ");
1045 return VC_ERROR_INVALID_STATE;
1049 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1050 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1051 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1052 SLOG(LOG_DEBUG, TAG_VCC, " ");
1053 return VC_ERROR_INVALID_PARAMETER;
1056 vc_cmd_list_s* list = NULL;
1057 list = (vc_cmd_list_s*)vc_cmd_list;
1060 char* invocation_name = NULL;
1061 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1062 ret = __vc_get_invocation_name(&invocation_name);
1063 if (0 != ret || NULL == invocation_name) {
1064 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1069 ret = vc_cmd_parser_delete_file(getpid(), type);
1071 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1073 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1075 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1079 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1081 if (VC_ERROR_TIMED_OUT != ret) {
1082 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1085 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1088 if (VC_RETRY_COUNT == count) {
1089 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1097 if (NULL != invocation_name) {
1098 free(invocation_name);
1099 invocation_name = NULL;
1102 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1103 SLOG(LOG_DEBUG, TAG_VCC, " ");
1108 int vc_unset_command_list(int type)
1110 if (0 != __vc_get_feature_enabled()) {
1111 return VC_ERROR_NOT_SUPPORTED;
1113 if (0 != __vc_check_privilege()) {
1114 return VC_ERROR_PERMISSION_DENIED;
1117 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1120 if (0 != vc_client_get_client_state(g_vc, &state)) {
1121 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1122 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1123 SLOG(LOG_DEBUG, TAG_VCC, " ");
1124 return VC_ERROR_INVALID_STATE;
1128 if (state != VC_STATE_READY) {
1129 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1130 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1131 SLOG(LOG_DEBUG, TAG_VCC, " ");
1132 return VC_ERROR_INVALID_STATE;
1138 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1140 if (VC_ERROR_TIMED_OUT != ret) {
1141 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1144 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1147 if (VC_RETRY_COUNT == count) {
1148 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1155 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1157 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1158 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1161 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1162 SLOG(LOG_DEBUG, TAG_VCC, " ");
1167 int vc_set_command_list_from_file(const char* file_path, int type)
1169 if (0 != __vc_get_feature_enabled()) {
1170 return VC_ERROR_NOT_SUPPORTED;
1172 if (0 != __vc_check_privilege()) {
1173 return VC_ERROR_PERMISSION_DENIED;
1176 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list from file");
1179 if (0 != vc_client_get_client_state(g_vc, &state)) {
1180 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1181 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1182 SLOG(LOG_DEBUG, TAG_VCC, " ");
1183 return VC_ERROR_INVALID_STATE;
1187 if (state != VC_STATE_READY) {
1188 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1189 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1190 SLOG(LOG_DEBUG, TAG_VCC, " ");
1191 return VC_ERROR_INVALID_STATE;
1195 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1196 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1197 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1198 SLOG(LOG_DEBUG, TAG_VCC, " ");
1199 return VC_ERROR_INVALID_PARAMETER;
1203 char* invocation_name = NULL;
1204 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1205 ret = __vc_get_invocation_name(&invocation_name);
1206 if (0 != ret || NULL == invocation_name) {
1207 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1212 ret = vc_cmd_parser_delete_file(getpid(), type);
1214 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1216 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1218 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1222 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1224 if (VC_ERROR_TIMED_OUT != ret) {
1225 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1228 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1231 if (VC_RETRY_COUNT == count) {
1232 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1240 if (NULL != invocation_name) {
1241 free(invocation_name);
1242 invocation_name = NULL;
1245 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1246 SLOG(LOG_DEBUG, TAG_VCC, " ");
1251 int vc_get_exclusive_command_option(bool* value)
1253 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1256 if (0 != vc_client_get_client_state(g_vc, &state)) {
1257 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1258 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1259 SLOG(LOG_DEBUG, TAG_VCC, " ");
1260 return VC_ERROR_INVALID_STATE;
1264 if (state != VC_STATE_READY) {
1265 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1266 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1267 SLOG(LOG_DEBUG, TAG_VCC, " ");
1268 return VC_ERROR_INVALID_STATE;
1271 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1274 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1275 SLOG(LOG_DEBUG, TAG_VCC, " ");
1279 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 SLOG(LOG_DEBUG, TAG_VCC, " ");
1301 return VC_ERROR_INVALID_STATE;
1305 if (state != VC_STATE_READY) {
1306 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1307 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1308 SLOG(LOG_DEBUG, TAG_VCC, " ");
1309 return VC_ERROR_INVALID_STATE;
1312 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1314 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1315 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1316 SLOG(LOG_DEBUG, TAG_VCC, " ");
1322 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1324 if (VC_ERROR_TIMED_OUT != ret) {
1325 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1328 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1331 if (VC_RETRY_COUNT == count) {
1332 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1339 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1340 SLOG(LOG_DEBUG, TAG_VCC, " ");
1347 int vc_request_start(bool stop_by_silence)
1349 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1352 if (0 != vc_client_get_client_state(g_vc, &state)) {
1353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1354 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1355 SLOG(LOG_DEBUG, TAG_VCC, " ");
1356 return VC_ERROR_INVALID_STATE;
1360 if (state != VC_STATE_READY) {
1361 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1362 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1363 SLOG(LOG_DEBUG, TAG_VCC, " ");
1364 return VC_ERROR_INVALID_STATE;
1367 /* Check service state */
1368 vc_service_state_e service_state = -1;
1369 vc_client_get_service_state(g_vc, &service_state);
1370 if (service_state != VC_SERVICE_STATE_READY) {
1371 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1372 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1373 SLOG(LOG_DEBUG, TAG_VCC, " ");
1374 return VC_ERROR_INVALID_STATE;
1384 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1386 if (VC_ERROR_TIMED_OUT != ret) {
1387 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1390 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1393 if (VC_RETRY_COUNT == count) {
1394 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1399 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1403 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1404 SLOG(LOG_DEBUG, TAG_VCC, " ");
1409 int vc_request_stop(void)
1411 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1414 if (0 != vc_client_get_client_state(g_vc, &state)) {
1415 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1416 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1417 SLOG(LOG_DEBUG, TAG_VCC, " ");
1418 return VC_ERROR_INVALID_STATE;
1422 if (state != VC_STATE_READY) {
1423 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1424 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1425 SLOG(LOG_DEBUG, TAG_VCC, " ");
1426 return VC_ERROR_INVALID_STATE;
1429 /* Check service state */
1430 vc_service_state_e service_state = -1;
1431 vc_client_get_service_state(g_vc, &service_state);
1432 if (service_state != VC_SERVICE_STATE_RECORDING) {
1433 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1434 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1435 SLOG(LOG_DEBUG, TAG_VCC, " ");
1436 return VC_ERROR_INVALID_STATE;
1443 ret = vc_dbus_request_stop(g_vc->handle);
1445 if (VC_ERROR_TIMED_OUT != ret) {
1446 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1449 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1452 if (VC_RETRY_COUNT == count) {
1453 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1458 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1462 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1463 SLOG(LOG_DEBUG, TAG_VCC, " ");
1468 int vc_request_cancel(void)
1470 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1473 if (0 != vc_client_get_client_state(g_vc, &state)) {
1474 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1475 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1476 SLOG(LOG_DEBUG, TAG_VCC, " ");
1477 return VC_ERROR_INVALID_STATE;
1481 if (state != VC_STATE_READY) {
1482 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1483 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1484 SLOG(LOG_DEBUG, TAG_VCC, " ");
1485 return VC_ERROR_INVALID_STATE;
1488 /* Check service state */
1489 vc_service_state_e service_state = -1;
1490 vc_client_get_service_state(g_vc, &service_state);
1491 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1492 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1493 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1494 SLOG(LOG_DEBUG, TAG_VCC, " ");
1495 return VC_ERROR_INVALID_STATE;
1501 ret = vc_dbus_request_cancel(g_vc->handle);
1503 if (VC_ERROR_TIMED_OUT != ret) {
1504 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1507 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1510 if (VC_RETRY_COUNT == count) {
1511 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1516 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1520 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1521 SLOG(LOG_DEBUG, TAG_VCC, " ");
1527 Eina_Bool __vc_notify_error(void *data)
1529 vc_h vc = (vc_h)data;
1531 vc_error_cb callback = NULL;
1535 vc_client_get_error_cb(vc, &callback, &user_data);
1536 vc_client_get_error(vc, &reason);
1538 if (NULL != callback) {
1539 vc_client_use_callback(vc);
1540 callback(reason, user_data);
1541 vc_client_not_use_callback(vc);
1542 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1544 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1550 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1553 if (0 != vc_client_get_client_state(g_vc, &state)) {
1554 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1559 if (state != VC_STATE_READY) {
1560 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1564 if (VC_ERROR_SERVICE_RESET == reason) {
1565 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1567 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1568 __vc_notify_state_changed(g_vc);
1570 if (0 != vc_prepare()) {
1571 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1575 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1577 vc_client_set_error(g_vc, reason);
1578 ecore_timer_add(0, __vc_notify_error, g_vc);
1583 Eina_Bool __vc_notify_state_changed(void *data)
1585 vc_h vc = (vc_h)data;
1587 vc_state_changed_cb changed_callback = NULL;
1590 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1592 vc_state_e current_state;
1593 vc_state_e before_state;
1595 vc_client_get_before_state(vc, ¤t_state, &before_state);
1597 if (NULL != changed_callback) {
1598 vc_client_use_callback(vc);
1599 changed_callback(before_state, current_state, user_data);
1600 vc_client_not_use_callback(vc);
1601 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1603 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1609 static Eina_Bool __vc_notify_result(void *data)
1613 vc_cmd_list_h vc_cmd_list = NULL;
1615 vc_result_cb callback = NULL;
1616 void* user_data = NULL;
1618 vc_client_get_result_cb(g_vc, &callback, &user_data);
1620 if (NULL == callback) {
1621 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1625 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1626 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1630 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1632 SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1634 vc_cmd_print_list(vc_cmd_list);
1636 vc_client_use_callback(g_vc);
1637 callback(event, vc_cmd_list, temp_text, user_data);
1638 vc_client_not_use_callback(g_vc);
1640 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1642 vc_cmd_list_destroy(vc_cmd_list, true);
1644 /* Release result */
1645 if (NULL != temp_text) free(temp_text);
1650 void __vc_cb_result(void)
1652 ecore_timer_add(0, __vc_notify_result, NULL);
1657 int vc_get_result(vc_result_cb callback, void* user_data)
1659 if (0 != __vc_get_feature_enabled()) {
1660 return VC_ERROR_NOT_SUPPORTED;
1662 if (0 != __vc_check_privilege()) {
1663 return VC_ERROR_PERMISSION_DENIED;
1666 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get result");
1668 if (NULL == callback) {
1669 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1670 return VC_ERROR_INVALID_PARAMETER;
1673 char* temp_text = NULL;
1675 vc_cmd_list_h vc_cmd_list = NULL;
1677 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1678 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1679 return VC_ERROR_INVALID_PARAMETER;
1682 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1683 if (0 != ret || NULL == temp_text) {
1684 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1688 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1690 vc_cmd_print_list(vc_cmd_list);
1692 vc_client_use_callback(g_vc);
1693 callback(event, vc_cmd_list, temp_text, user_data);
1694 vc_client_not_use_callback(g_vc);
1696 vc_cmd_list_destroy(vc_cmd_list, true);
1698 /* Release result */
1699 if (NULL != temp_text) {
1704 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1705 SLOG(LOG_DEBUG, TAG_VCC, " ");
1707 return VC_ERROR_NONE;
1710 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1712 if (0 != __vc_get_feature_enabled()) {
1713 return VC_ERROR_NOT_SUPPORTED;
1715 if (0 != __vc_check_privilege()) {
1716 return VC_ERROR_PERMISSION_DENIED;
1719 if (NULL == callback)
1720 return VC_ERROR_INVALID_PARAMETER;
1723 if (0 != vc_client_get_client_state(g_vc, &state)) {
1724 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1725 return VC_ERROR_INVALID_STATE;
1729 if (state != VC_STATE_INITIALIZED) {
1730 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1731 return VC_ERROR_INVALID_STATE;
1734 vc_client_set_result_cb(g_vc, callback, user_data);
1739 int vc_unset_result_cb(void)
1741 if (0 != __vc_get_feature_enabled()) {
1742 return VC_ERROR_NOT_SUPPORTED;
1744 if (0 != __vc_check_privilege()) {
1745 return VC_ERROR_PERMISSION_DENIED;
1749 if (0 != vc_client_get_client_state(g_vc, &state)) {
1750 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1751 return VC_ERROR_INVALID_STATE;
1755 if (state != VC_STATE_INITIALIZED) {
1756 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1757 return VC_ERROR_INVALID_STATE;
1760 vc_client_set_result_cb(g_vc, NULL, NULL);
1765 int __vc_cb_service_state(int state)
1767 vc_service_state_e current_state = (vc_service_state_e)state;
1768 vc_service_state_e before_state;
1769 vc_client_get_service_state(g_vc, &before_state);
1771 if (current_state == before_state) {
1775 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1776 before_state, current_state);
1778 /* Save service state */
1779 vc_client_set_service_state(g_vc, current_state);
1781 vc_service_state_changed_cb callback = NULL;
1782 void* service_user_data;
1783 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1785 if (NULL != callback) {
1786 vc_client_use_callback(g_vc);
1787 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1788 vc_client_not_use_callback(g_vc);
1789 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1791 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1797 int __vc_cb_manager_pid(int manager_pid)
1799 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1801 /* Save service state */
1802 vc_client_set_mgr_pid(g_vc, manager_pid);
1807 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1809 if (0 != __vc_get_feature_enabled()) {
1810 return VC_ERROR_NOT_SUPPORTED;
1812 if (0 != __vc_check_privilege()) {
1813 return VC_ERROR_PERMISSION_DENIED;
1816 if (NULL == callback)
1817 return VC_ERROR_INVALID_PARAMETER;
1820 if (0 != vc_client_get_client_state(g_vc, &state)) {
1821 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1822 return VC_ERROR_INVALID_STATE;
1826 if (state != VC_STATE_INITIALIZED) {
1827 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1828 return VC_ERROR_INVALID_STATE;
1831 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1836 int vc_unset_service_state_changed_cb(void)
1838 if (0 != __vc_get_feature_enabled()) {
1839 return VC_ERROR_NOT_SUPPORTED;
1841 if (0 != __vc_check_privilege()) {
1842 return VC_ERROR_PERMISSION_DENIED;
1846 if (0 != vc_client_get_client_state(g_vc, &state)) {
1847 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1848 return VC_ERROR_INVALID_STATE;
1852 if (state != VC_STATE_INITIALIZED) {
1853 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1854 return VC_ERROR_INVALID_STATE;
1857 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1862 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1864 if (0 != __vc_get_feature_enabled()) {
1865 return VC_ERROR_NOT_SUPPORTED;
1867 if (0 != __vc_check_privilege()) {
1868 return VC_ERROR_PERMISSION_DENIED;
1871 if (callback == NULL)
1872 return VC_ERROR_INVALID_PARAMETER;
1875 if (0 != vc_client_get_client_state(g_vc, &state)) {
1876 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1877 return VC_ERROR_INVALID_STATE;
1881 if (state != VC_STATE_INITIALIZED) {
1882 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1883 return VC_ERROR_INVALID_STATE;
1886 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1891 int vc_unset_state_changed_cb(void)
1893 if (0 != __vc_get_feature_enabled()) {
1894 return VC_ERROR_NOT_SUPPORTED;
1896 if (0 != __vc_check_privilege()) {
1897 return VC_ERROR_PERMISSION_DENIED;
1901 if (0 != vc_client_get_client_state(g_vc, &state)) {
1902 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1903 return VC_ERROR_INVALID_STATE;
1907 if (state != VC_STATE_INITIALIZED) {
1908 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1909 return VC_ERROR_INVALID_STATE;
1912 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1917 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1919 if (0 != __vc_get_feature_enabled()) {
1920 return VC_ERROR_NOT_SUPPORTED;
1922 if (0 != __vc_check_privilege()) {
1923 return VC_ERROR_PERMISSION_DENIED;
1926 if (NULL == callback)
1927 return VC_ERROR_INVALID_PARAMETER;
1930 if (0 != vc_client_get_client_state(g_vc, &state)) {
1931 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1932 return VC_ERROR_INVALID_STATE;
1936 if (state != VC_STATE_INITIALIZED) {
1937 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1938 return VC_ERROR_INVALID_STATE;
1941 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1946 int vc_unset_current_language_changed_cb(void)
1948 if (0 != __vc_get_feature_enabled()) {
1949 return VC_ERROR_NOT_SUPPORTED;
1951 if (0 != __vc_check_privilege()) {
1952 return VC_ERROR_PERMISSION_DENIED;
1956 if (0 != vc_client_get_client_state(g_vc, &state)) {
1957 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1958 return VC_ERROR_INVALID_STATE;
1962 if (state != VC_STATE_INITIALIZED) {
1963 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1964 return VC_ERROR_INVALID_STATE;
1967 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1972 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1974 if (0 != __vc_get_feature_enabled()) {
1975 return VC_ERROR_NOT_SUPPORTED;
1977 if (0 != __vc_check_privilege()) {
1978 return VC_ERROR_PERMISSION_DENIED;
1981 if (NULL == callback)
1982 return VC_ERROR_INVALID_PARAMETER;
1985 if (0 != vc_client_get_client_state(g_vc, &state)) {
1986 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1987 return VC_ERROR_INVALID_STATE;
1991 if (state != VC_STATE_INITIALIZED) {
1992 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1993 return VC_ERROR_INVALID_STATE;
1996 vc_client_set_error_cb(g_vc, callback, user_data);
2001 int vc_unset_error_cb(void)
2003 if (0 != __vc_get_feature_enabled()) {
2004 return VC_ERROR_NOT_SUPPORTED;
2006 if (0 != __vc_check_privilege()) {
2007 return VC_ERROR_PERMISSION_DENIED;
2011 if (0 != vc_client_get_client_state(g_vc, &state)) {
2012 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2013 return VC_ERROR_INVALID_STATE;
2017 if (state != VC_STATE_INITIALIZED) {
2018 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2019 return VC_ERROR_INVALID_STATE;
2022 vc_client_set_error_cb(g_vc, NULL, NULL);
2027 int vc_set_invocation_name(const char* name)
2029 if (0 != __vc_get_feature_enabled()) {
2030 return VC_ERROR_NOT_SUPPORTED;
2032 if (0 != __vc_check_privilege()) {
2033 return VC_ERROR_PERMISSION_DENIED;
2037 SLOG(LOG_DEBUG, TAG_VCC, "===== Set invocation name");
2039 int ret = vc_client_get_client_state(g_vc, &state);
2041 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2042 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2043 SLOG(LOG_DEBUG, TAG_VCC, " ");
2048 if (state != VC_STATE_READY) {
2049 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2050 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2051 SLOG(LOG_DEBUG, TAG_VCC, " ");
2052 return VC_ERROR_INVALID_STATE;
2055 ret = vc_client_set_invocation_name(g_vc, name);
2057 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2062 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2066 SLOG(LOG_DEBUG, TAG_VCC, "===== Request dialog");
2067 if (0 != __vc_get_feature_enabled()) {
2068 return VC_ERROR_NOT_SUPPORTED;
2070 if (0 != __vc_check_privilege()) {
2071 return VC_ERROR_PERMISSION_DENIED;
2074 if (0 != vc_client_get_client_state(g_vc, &state)) {
2075 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2076 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2077 SLOG(LOG_DEBUG, TAG_VCC, " ");
2078 return VC_ERROR_INVALID_STATE;
2082 if (state != VC_STATE_READY) {
2083 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2084 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2085 SLOG(LOG_DEBUG, TAG_VCC, " ");
2086 return VC_ERROR_INVALID_STATE;
2089 /* Check service state */
2090 vc_service_state_e service_state = -1;
2091 vc_client_get_service_state(g_vc, &service_state);
2092 if (service_state != VC_SERVICE_STATE_READY) {
2093 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2094 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2095 SLOG(LOG_DEBUG, TAG_VCC, " ");
2096 return VC_ERROR_INVALID_STATE;
2099 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);
2100 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2102 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2103 return VC_ERROR_OPERATION_FAILED;
2106 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2107 SLOG(LOG_DEBUG, TAG_VCC, " ");
2109 return VC_ERROR_NONE;
2113 int vc_auth_enable(void)
2117 if (0 != vc_client_get_client_state(g_vc, &state)) {
2118 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2119 return VC_ERROR_INVALID_STATE;
2122 if (VC_STATE_READY != state) {
2123 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2124 return VC_ERROR_INVALID_STATE;
2127 /* check already authority */
2128 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2129 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2130 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2131 return VC_ERROR_INVALID_STATE;
2134 if (VC_AUTH_STATE_NONE != auth_state) {
2135 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2136 return VC_ERROR_INVALID_STATE;
2139 /* request authority */
2141 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2142 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2143 return VC_ERROR_OPERATION_FAILED;
2146 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2148 return VC_ERROR_OPERATION_FAILED;
2151 /* set authority into handle */
2152 bool is_foreground = false;
2153 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2154 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2155 return VC_ERROR_OPERATION_FAILED;
2158 if (is_foreground) {
2159 auth_state = VC_AUTH_STATE_VALID;
2161 auth_state = VC_AUTH_STATE_INVALID;
2164 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2165 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2166 return VC_ERROR_OPERATION_FAILED;
2169 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2171 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2173 return VC_ERROR_NONE;
2176 int vc_auth_disable(void)
2180 if (0 != vc_client_get_client_state(g_vc, &state)) {
2181 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2182 return VC_ERROR_INVALID_STATE;
2185 if (VC_STATE_READY != state) {
2186 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2187 return VC_ERROR_INVALID_STATE;
2190 /* check autority */
2191 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2192 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2193 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2194 return VC_ERROR_INVALID_STATE;
2197 if (VC_AUTH_STATE_NONE == auth_state) {
2198 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2199 return VC_ERROR_INVALID_STATE;
2202 if (0 != vc_auth_unset_state_changed_cb()) {
2203 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2206 /* request return authority by dbus */
2208 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2209 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2210 return VC_ERROR_OPERATION_FAILED;
2213 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2214 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2215 return VC_ERROR_OPERATION_FAILED;
2218 /* unset authority from handle */
2219 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2220 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2221 return VC_ERROR_OPERATION_FAILED;
2224 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2226 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2228 return VC_ERROR_NONE;
2231 int vc_auth_get_state(vc_auth_state_e* state)
2234 vc_state_e vc_state;
2235 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2236 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2237 return VC_ERROR_INVALID_STATE;
2240 if (VC_STATE_READY != vc_state) {
2241 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2242 return VC_ERROR_INVALID_STATE;
2246 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2247 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2248 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2249 return VC_ERROR_INVALID_STATE;
2254 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2256 return VC_ERROR_NONE;
2259 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2261 /* check parameter */
2262 if (NULL == callback) {
2263 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2264 return VC_ERROR_INVALID_PARAMETER;
2268 vc_auth_state_e auth_state;
2269 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2270 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2271 return VC_ERROR_INVALID_STATE;
2274 if (VC_AUTH_STATE_NONE == auth_state) {
2275 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2276 return VC_ERROR_INVALID_STATE;
2279 /* set cb into handle */
2280 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2281 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2282 return VC_ERROR_OPERATION_FAILED;
2285 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2287 return VC_ERROR_NONE;
2290 int vc_auth_unset_state_changed_cb(void)
2293 vc_auth_state_e auth_state;
2294 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2295 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2296 return VC_ERROR_INVALID_STATE;
2299 if (VC_AUTH_STATE_NONE == auth_state) {
2300 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2301 return VC_ERROR_INVALID_STATE;
2304 /* unset cb from handle */
2305 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2306 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2307 return VC_ERROR_OPERATION_FAILED;
2310 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2312 return VC_ERROR_NONE;
2315 int vc_auth_start(void)
2317 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
2320 if (0 != vc_client_get_client_state(g_vc, &state)) {
2321 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2322 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2323 SLOG(LOG_DEBUG, TAG_VCC, " ");
2324 return VC_ERROR_INVALID_STATE;
2328 if (state != VC_STATE_READY) {
2329 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2330 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2331 SLOG(LOG_DEBUG, TAG_VCC, " ");
2332 return VC_ERROR_INVALID_STATE;
2335 /* Check service state */
2336 vc_service_state_e service_state = -1;
2337 vc_client_get_service_state(g_vc, &service_state);
2338 if (service_state != VC_SERVICE_STATE_READY) {
2339 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2340 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2341 SLOG(LOG_DEBUG, TAG_VCC, " ");
2342 return VC_ERROR_INVALID_STATE;
2345 /* Check authority */
2346 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2347 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2348 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2349 return VC_ERROR_OPERATION_FAILED;
2352 if (VC_AUTH_STATE_VALID != auth_state) {
2353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2354 return VC_ERROR_OPERATION_FAILED;
2359 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2361 return VC_ERROR_OPERATION_FAILED;
2370 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2372 if (VC_ERROR_TIMED_OUT != ret) {
2373 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2376 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2379 if (VC_RETRY_COUNT == count) {
2380 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2385 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2389 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2390 SLOG(LOG_DEBUG, TAG_VCC, " ");
2395 int vc_auth_stop(void)
2397 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
2400 if (0 != vc_client_get_client_state(g_vc, &state)) {
2401 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2402 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2403 SLOG(LOG_DEBUG, TAG_VCC, " ");
2404 return VC_ERROR_INVALID_STATE;
2408 if (state != VC_STATE_READY) {
2409 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2410 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2411 SLOG(LOG_DEBUG, TAG_VCC, " ");
2412 return VC_ERROR_INVALID_STATE;
2415 /* Check service state */
2416 vc_service_state_e service_state = -1;
2417 vc_client_get_service_state(g_vc, &service_state);
2418 if (service_state != VC_SERVICE_STATE_RECORDING) {
2419 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2420 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2421 SLOG(LOG_DEBUG, TAG_VCC, " ");
2422 return VC_ERROR_INVALID_STATE;
2425 /* Check authority */
2426 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2427 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2428 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2429 return VC_ERROR_OPERATION_FAILED;
2432 if (VC_AUTH_STATE_VALID != auth_state) {
2433 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2434 return VC_ERROR_OPERATION_FAILED;
2439 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2440 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2441 return VC_ERROR_OPERATION_FAILED;
2448 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2450 if (VC_ERROR_TIMED_OUT != ret) {
2451 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2454 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2457 if (VC_RETRY_COUNT == count) {
2458 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2463 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2467 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2468 SLOG(LOG_DEBUG, TAG_VCC, " ");
2473 int vc_auth_cancel(void)
2475 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2478 if (0 != vc_client_get_client_state(g_vc, &state)) {
2479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2480 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2481 SLOG(LOG_DEBUG, TAG_VCC, " ");
2482 return VC_ERROR_INVALID_STATE;
2486 if (state != VC_STATE_READY) {
2487 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2488 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2489 SLOG(LOG_DEBUG, TAG_VCC, " ");
2490 return VC_ERROR_INVALID_STATE;
2493 /* Check service state */
2494 vc_service_state_e service_state = -1;
2495 vc_client_get_service_state(g_vc, &service_state);
2496 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2497 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2498 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2499 SLOG(LOG_DEBUG, TAG_VCC, " ");
2500 return VC_ERROR_INVALID_STATE;
2503 /* Check authority */
2504 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2505 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2506 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2507 return VC_ERROR_OPERATION_FAILED;
2510 if (VC_AUTH_STATE_VALID != auth_state) {
2511 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2512 return VC_ERROR_OPERATION_FAILED;
2517 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2518 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2519 return VC_ERROR_OPERATION_FAILED;
2525 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2527 if (VC_ERROR_TIMED_OUT != ret) {
2528 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2531 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2534 if (VC_RETRY_COUNT == count) {
2535 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2540 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2544 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2545 SLOG(LOG_DEBUG, TAG_VCC, " ");