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;
1059 if (NULL == list->list) {
1060 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command list");
1061 return VC_ERROR_INVALID_PARAMETER;
1065 char* invocation_name = NULL;
1066 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1067 ret = __vc_get_invocation_name(&invocation_name);
1068 if (0 != ret || NULL == invocation_name) {
1069 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1074 ret = vc_cmd_parser_delete_file(getpid(), type);
1076 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1078 ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1080 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1084 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1086 if (VC_ERROR_TIMED_OUT != ret) {
1087 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1090 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1093 if (VC_RETRY_COUNT == count) {
1094 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1102 if (NULL != invocation_name) {
1103 free(invocation_name);
1104 invocation_name = NULL;
1107 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1108 SLOG(LOG_DEBUG, TAG_VCC, " ");
1113 int vc_unset_command_list(int type)
1115 if (0 != __vc_get_feature_enabled()) {
1116 return VC_ERROR_NOT_SUPPORTED;
1118 if (0 != __vc_check_privilege()) {
1119 return VC_ERROR_PERMISSION_DENIED;
1122 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1125 if (0 != vc_client_get_client_state(g_vc, &state)) {
1126 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1127 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1128 SLOG(LOG_DEBUG, TAG_VCC, " ");
1129 return VC_ERROR_INVALID_STATE;
1133 if (state != VC_STATE_READY) {
1134 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1135 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1136 SLOG(LOG_DEBUG, TAG_VCC, " ");
1137 return VC_ERROR_INVALID_STATE;
1143 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1145 if (VC_ERROR_TIMED_OUT != ret) {
1146 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1149 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1152 if (VC_RETRY_COUNT == count) {
1153 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1160 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1162 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1163 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1166 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1167 SLOG(LOG_DEBUG, TAG_VCC, " ");
1172 int vc_set_command_list_from_file(const char* file_path, int type)
1174 if (0 != __vc_get_feature_enabled()) {
1175 return VC_ERROR_NOT_SUPPORTED;
1177 if (0 != __vc_check_privilege()) {
1178 return VC_ERROR_PERMISSION_DENIED;
1181 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list from file");
1184 if (0 != vc_client_get_client_state(g_vc, &state)) {
1185 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1186 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1187 SLOG(LOG_DEBUG, TAG_VCC, " ");
1188 return VC_ERROR_INVALID_STATE;
1192 if (state != VC_STATE_READY) {
1193 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1194 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1195 SLOG(LOG_DEBUG, TAG_VCC, " ");
1196 return VC_ERROR_INVALID_STATE;
1200 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1201 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1202 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1203 SLOG(LOG_DEBUG, TAG_VCC, " ");
1204 return VC_ERROR_INVALID_PARAMETER;
1208 char* invocation_name = NULL;
1209 if (VC_COMMAND_TYPE_BACKGROUND == type) {
1210 ret = __vc_get_invocation_name(&invocation_name);
1211 if (0 != ret || NULL == invocation_name) {
1212 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1217 ret = vc_cmd_parser_delete_file(getpid(), type);
1219 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1221 ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1223 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1227 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1229 if (VC_ERROR_TIMED_OUT != ret) {
1230 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1233 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1236 if (VC_RETRY_COUNT == count) {
1237 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1245 if (NULL != invocation_name) {
1246 free(invocation_name);
1247 invocation_name = NULL;
1250 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1251 SLOG(LOG_DEBUG, TAG_VCC, " ");
1256 int vc_get_exclusive_command_option(bool* value)
1258 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1261 if (0 != vc_client_get_client_state(g_vc, &state)) {
1262 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1263 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1264 SLOG(LOG_DEBUG, TAG_VCC, " ");
1265 return VC_ERROR_INVALID_STATE;
1269 if (state != VC_STATE_READY) {
1270 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1271 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1272 SLOG(LOG_DEBUG, TAG_VCC, " ");
1273 return VC_ERROR_INVALID_STATE;
1276 int ret = vc_client_get_exclusive_cmd(g_vc, value);
1278 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1279 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1280 SLOG(LOG_DEBUG, TAG_VCC, " ");
1284 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1285 SLOG(LOG_DEBUG, TAG_VCC, " ");
1290 int vc_set_exclusive_command_option(bool value)
1292 if (0 != __vc_get_feature_enabled()) {
1293 return VC_ERROR_NOT_SUPPORTED;
1295 if (0 != __vc_check_privilege()) {
1296 return VC_ERROR_PERMISSION_DENIED;
1299 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
1302 if (0 != vc_client_get_client_state(g_vc, &state)) {
1303 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1304 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1305 SLOG(LOG_DEBUG, TAG_VCC, " ");
1306 return VC_ERROR_INVALID_STATE;
1310 if (state != VC_STATE_READY) {
1311 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1312 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1313 SLOG(LOG_DEBUG, TAG_VCC, " ");
1314 return VC_ERROR_INVALID_STATE;
1317 int ret = vc_client_set_exclusive_cmd(g_vc, value);
1319 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1320 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1321 SLOG(LOG_DEBUG, TAG_VCC, " ");
1327 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1329 if (VC_ERROR_TIMED_OUT != ret) {
1330 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1333 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1336 if (VC_RETRY_COUNT == count) {
1337 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1344 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1345 SLOG(LOG_DEBUG, TAG_VCC, " ");
1352 int vc_request_start(bool stop_by_silence)
1354 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1357 if (0 != vc_client_get_client_state(g_vc, &state)) {
1358 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1359 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1360 SLOG(LOG_DEBUG, TAG_VCC, " ");
1361 return VC_ERROR_INVALID_STATE;
1365 if (state != VC_STATE_READY) {
1366 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1367 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1368 SLOG(LOG_DEBUG, TAG_VCC, " ");
1369 return VC_ERROR_INVALID_STATE;
1372 /* Check service state */
1373 vc_service_state_e service_state = -1;
1374 vc_client_get_service_state(g_vc, &service_state);
1375 if (service_state != VC_SERVICE_STATE_READY) {
1376 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1377 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1378 SLOG(LOG_DEBUG, TAG_VCC, " ");
1379 return VC_ERROR_INVALID_STATE;
1389 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1391 if (VC_ERROR_TIMED_OUT != ret) {
1392 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1395 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1398 if (VC_RETRY_COUNT == count) {
1399 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1404 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1408 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1409 SLOG(LOG_DEBUG, TAG_VCC, " ");
1414 int vc_request_stop(void)
1416 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1419 if (0 != vc_client_get_client_state(g_vc, &state)) {
1420 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1421 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1422 SLOG(LOG_DEBUG, TAG_VCC, " ");
1423 return VC_ERROR_INVALID_STATE;
1427 if (state != VC_STATE_READY) {
1428 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1429 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1430 SLOG(LOG_DEBUG, TAG_VCC, " ");
1431 return VC_ERROR_INVALID_STATE;
1434 /* Check service state */
1435 vc_service_state_e service_state = -1;
1436 vc_client_get_service_state(g_vc, &service_state);
1437 if (service_state != VC_SERVICE_STATE_RECORDING) {
1438 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1439 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1440 SLOG(LOG_DEBUG, TAG_VCC, " ");
1441 return VC_ERROR_INVALID_STATE;
1448 ret = vc_dbus_request_stop(g_vc->handle);
1450 if (VC_ERROR_TIMED_OUT != ret) {
1451 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1454 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1457 if (VC_RETRY_COUNT == count) {
1458 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1463 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1467 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1468 SLOG(LOG_DEBUG, TAG_VCC, " ");
1473 int vc_request_cancel(void)
1475 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1478 if (0 != vc_client_get_client_state(g_vc, &state)) {
1479 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1480 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1481 SLOG(LOG_DEBUG, TAG_VCC, " ");
1482 return VC_ERROR_INVALID_STATE;
1486 if (state != VC_STATE_READY) {
1487 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1488 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1489 SLOG(LOG_DEBUG, TAG_VCC, " ");
1490 return VC_ERROR_INVALID_STATE;
1493 /* Check service state */
1494 vc_service_state_e service_state = -1;
1495 vc_client_get_service_state(g_vc, &service_state);
1496 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1497 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1498 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1499 SLOG(LOG_DEBUG, TAG_VCC, " ");
1500 return VC_ERROR_INVALID_STATE;
1506 ret = vc_dbus_request_cancel(g_vc->handle);
1508 if (VC_ERROR_TIMED_OUT != ret) {
1509 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1512 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1515 if (VC_RETRY_COUNT == count) {
1516 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1521 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1525 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1526 SLOG(LOG_DEBUG, TAG_VCC, " ");
1532 Eina_Bool __vc_notify_error(void *data)
1534 vc_h vc = (vc_h)data;
1536 vc_error_cb callback = NULL;
1540 vc_client_get_error_cb(vc, &callback, &user_data);
1541 vc_client_get_error(vc, &reason);
1543 if (NULL != callback) {
1544 vc_client_use_callback(vc);
1545 callback(reason, user_data);
1546 vc_client_not_use_callback(vc);
1547 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1549 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1555 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1558 if (0 != vc_client_get_client_state(g_vc, &state)) {
1559 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1564 if (state != VC_STATE_READY) {
1565 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1569 if (VC_ERROR_SERVICE_RESET == reason) {
1570 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1572 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1573 __vc_notify_state_changed(g_vc);
1575 if (0 != vc_prepare()) {
1576 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1580 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1582 vc_client_set_error(g_vc, reason);
1583 ecore_timer_add(0, __vc_notify_error, g_vc);
1588 Eina_Bool __vc_notify_state_changed(void *data)
1590 vc_h vc = (vc_h)data;
1592 vc_state_changed_cb changed_callback = NULL;
1595 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1597 vc_state_e current_state;
1598 vc_state_e before_state;
1600 vc_client_get_before_state(vc, ¤t_state, &before_state);
1602 if (NULL != changed_callback) {
1603 vc_client_use_callback(vc);
1604 changed_callback(before_state, current_state, user_data);
1605 vc_client_not_use_callback(vc);
1606 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1608 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1614 static Eina_Bool __vc_notify_result(void *data)
1618 vc_cmd_list_h vc_cmd_list = NULL;
1620 vc_result_cb callback = NULL;
1621 void* user_data = NULL;
1623 vc_client_get_result_cb(g_vc, &callback, &user_data);
1625 if (NULL == callback) {
1626 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1630 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1631 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1635 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1637 SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1639 vc_cmd_print_list(vc_cmd_list);
1641 vc_client_use_callback(g_vc);
1642 callback(event, vc_cmd_list, temp_text, user_data);
1643 vc_client_not_use_callback(g_vc);
1645 SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1647 vc_cmd_list_destroy(vc_cmd_list, true);
1649 /* Release result */
1650 if (NULL != temp_text) free(temp_text);
1655 void __vc_cb_result(void)
1657 ecore_timer_add(0, __vc_notify_result, NULL);
1662 int vc_get_result(vc_result_cb callback, void* user_data)
1664 if (0 != __vc_get_feature_enabled()) {
1665 return VC_ERROR_NOT_SUPPORTED;
1667 if (0 != __vc_check_privilege()) {
1668 return VC_ERROR_PERMISSION_DENIED;
1671 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get result");
1673 if (NULL == callback) {
1674 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1675 return VC_ERROR_INVALID_PARAMETER;
1678 char* temp_text = NULL;
1680 vc_cmd_list_h vc_cmd_list = NULL;
1682 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1683 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1684 return VC_ERROR_INVALID_PARAMETER;
1687 int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1688 if (0 != ret || NULL == temp_text) {
1689 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1693 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1695 vc_cmd_print_list(vc_cmd_list);
1697 vc_client_use_callback(g_vc);
1698 callback(event, vc_cmd_list, temp_text, user_data);
1699 vc_client_not_use_callback(g_vc);
1701 vc_cmd_list_destroy(vc_cmd_list, true);
1703 /* Release result */
1704 if (NULL != temp_text) {
1709 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1710 SLOG(LOG_DEBUG, TAG_VCC, " ");
1712 return VC_ERROR_NONE;
1715 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1717 if (0 != __vc_get_feature_enabled()) {
1718 return VC_ERROR_NOT_SUPPORTED;
1720 if (0 != __vc_check_privilege()) {
1721 return VC_ERROR_PERMISSION_DENIED;
1724 if (NULL == callback)
1725 return VC_ERROR_INVALID_PARAMETER;
1728 if (0 != vc_client_get_client_state(g_vc, &state)) {
1729 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1730 return VC_ERROR_INVALID_STATE;
1734 if (state != VC_STATE_INITIALIZED) {
1735 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1736 return VC_ERROR_INVALID_STATE;
1739 vc_client_set_result_cb(g_vc, callback, user_data);
1744 int vc_unset_result_cb(void)
1746 if (0 != __vc_get_feature_enabled()) {
1747 return VC_ERROR_NOT_SUPPORTED;
1749 if (0 != __vc_check_privilege()) {
1750 return VC_ERROR_PERMISSION_DENIED;
1754 if (0 != vc_client_get_client_state(g_vc, &state)) {
1755 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1756 return VC_ERROR_INVALID_STATE;
1760 if (state != VC_STATE_INITIALIZED) {
1761 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1762 return VC_ERROR_INVALID_STATE;
1765 vc_client_set_result_cb(g_vc, NULL, NULL);
1770 int __vc_cb_service_state(int state)
1772 vc_service_state_e current_state = (vc_service_state_e)state;
1773 vc_service_state_e before_state;
1774 vc_client_get_service_state(g_vc, &before_state);
1776 if (current_state == before_state) {
1780 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1781 before_state, current_state);
1783 /* Save service state */
1784 vc_client_set_service_state(g_vc, current_state);
1786 vc_service_state_changed_cb callback = NULL;
1787 void* service_user_data;
1788 vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1790 if (NULL != callback) {
1791 vc_client_use_callback(g_vc);
1792 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1793 vc_client_not_use_callback(g_vc);
1794 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1796 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1802 int __vc_cb_manager_pid(int manager_pid)
1804 SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1806 /* Save service state */
1807 vc_client_set_mgr_pid(g_vc, manager_pid);
1812 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1814 if (0 != __vc_get_feature_enabled()) {
1815 return VC_ERROR_NOT_SUPPORTED;
1817 if (0 != __vc_check_privilege()) {
1818 return VC_ERROR_PERMISSION_DENIED;
1821 if (NULL == callback)
1822 return VC_ERROR_INVALID_PARAMETER;
1825 if (0 != vc_client_get_client_state(g_vc, &state)) {
1826 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1827 return VC_ERROR_INVALID_STATE;
1831 if (state != VC_STATE_INITIALIZED) {
1832 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1833 return VC_ERROR_INVALID_STATE;
1836 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1841 int vc_unset_service_state_changed_cb(void)
1843 if (0 != __vc_get_feature_enabled()) {
1844 return VC_ERROR_NOT_SUPPORTED;
1846 if (0 != __vc_check_privilege()) {
1847 return VC_ERROR_PERMISSION_DENIED;
1851 if (0 != vc_client_get_client_state(g_vc, &state)) {
1852 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1853 return VC_ERROR_INVALID_STATE;
1857 if (state != VC_STATE_INITIALIZED) {
1858 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1859 return VC_ERROR_INVALID_STATE;
1862 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1867 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1869 if (0 != __vc_get_feature_enabled()) {
1870 return VC_ERROR_NOT_SUPPORTED;
1872 if (0 != __vc_check_privilege()) {
1873 return VC_ERROR_PERMISSION_DENIED;
1876 if (callback == NULL)
1877 return VC_ERROR_INVALID_PARAMETER;
1880 if (0 != vc_client_get_client_state(g_vc, &state)) {
1881 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1882 return VC_ERROR_INVALID_STATE;
1886 if (state != VC_STATE_INITIALIZED) {
1887 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1888 return VC_ERROR_INVALID_STATE;
1891 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1896 int vc_unset_state_changed_cb(void)
1898 if (0 != __vc_get_feature_enabled()) {
1899 return VC_ERROR_NOT_SUPPORTED;
1901 if (0 != __vc_check_privilege()) {
1902 return VC_ERROR_PERMISSION_DENIED;
1906 if (0 != vc_client_get_client_state(g_vc, &state)) {
1907 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1908 return VC_ERROR_INVALID_STATE;
1912 if (state != VC_STATE_INITIALIZED) {
1913 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1914 return VC_ERROR_INVALID_STATE;
1917 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1922 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1924 if (0 != __vc_get_feature_enabled()) {
1925 return VC_ERROR_NOT_SUPPORTED;
1927 if (0 != __vc_check_privilege()) {
1928 return VC_ERROR_PERMISSION_DENIED;
1931 if (NULL == callback)
1932 return VC_ERROR_INVALID_PARAMETER;
1935 if (0 != vc_client_get_client_state(g_vc, &state)) {
1936 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1937 return VC_ERROR_INVALID_STATE;
1941 if (state != VC_STATE_INITIALIZED) {
1942 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1943 return VC_ERROR_INVALID_STATE;
1946 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1951 int vc_unset_current_language_changed_cb(void)
1953 if (0 != __vc_get_feature_enabled()) {
1954 return VC_ERROR_NOT_SUPPORTED;
1956 if (0 != __vc_check_privilege()) {
1957 return VC_ERROR_PERMISSION_DENIED;
1961 if (0 != vc_client_get_client_state(g_vc, &state)) {
1962 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1963 return VC_ERROR_INVALID_STATE;
1967 if (state != VC_STATE_INITIALIZED) {
1968 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1969 return VC_ERROR_INVALID_STATE;
1972 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1977 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1979 if (0 != __vc_get_feature_enabled()) {
1980 return VC_ERROR_NOT_SUPPORTED;
1982 if (0 != __vc_check_privilege()) {
1983 return VC_ERROR_PERMISSION_DENIED;
1986 if (NULL == callback)
1987 return VC_ERROR_INVALID_PARAMETER;
1990 if (0 != vc_client_get_client_state(g_vc, &state)) {
1991 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1992 return VC_ERROR_INVALID_STATE;
1996 if (state != VC_STATE_INITIALIZED) {
1997 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1998 return VC_ERROR_INVALID_STATE;
2001 vc_client_set_error_cb(g_vc, callback, user_data);
2006 int vc_unset_error_cb(void)
2008 if (0 != __vc_get_feature_enabled()) {
2009 return VC_ERROR_NOT_SUPPORTED;
2011 if (0 != __vc_check_privilege()) {
2012 return VC_ERROR_PERMISSION_DENIED;
2016 if (0 != vc_client_get_client_state(g_vc, &state)) {
2017 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2018 return VC_ERROR_INVALID_STATE;
2022 if (state != VC_STATE_INITIALIZED) {
2023 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2024 return VC_ERROR_INVALID_STATE;
2027 vc_client_set_error_cb(g_vc, NULL, NULL);
2032 int vc_set_invocation_name(const char* name)
2034 if (0 != __vc_get_feature_enabled()) {
2035 return VC_ERROR_NOT_SUPPORTED;
2037 if (0 != __vc_check_privilege()) {
2038 return VC_ERROR_PERMISSION_DENIED;
2042 SLOG(LOG_DEBUG, TAG_VCC, "===== Set invocation name");
2044 int ret = vc_client_get_client_state(g_vc, &state);
2046 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2047 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2048 SLOG(LOG_DEBUG, TAG_VCC, " ");
2053 if (state != VC_STATE_READY) {
2054 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2055 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2056 SLOG(LOG_DEBUG, TAG_VCC, " ");
2057 return VC_ERROR_INVALID_STATE;
2060 ret = vc_client_set_invocation_name(g_vc, name);
2062 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2067 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2071 SLOG(LOG_DEBUG, TAG_VCC, "===== Request dialog");
2072 if (0 != __vc_get_feature_enabled()) {
2073 return VC_ERROR_NOT_SUPPORTED;
2075 if (0 != __vc_check_privilege()) {
2076 return VC_ERROR_PERMISSION_DENIED;
2079 if (0 != vc_client_get_client_state(g_vc, &state)) {
2080 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2081 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2082 SLOG(LOG_DEBUG, TAG_VCC, " ");
2083 return VC_ERROR_INVALID_STATE;
2087 if (state != VC_STATE_READY) {
2088 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2089 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2090 SLOG(LOG_DEBUG, TAG_VCC, " ");
2091 return VC_ERROR_INVALID_STATE;
2094 /* Check service state */
2095 vc_service_state_e service_state = -1;
2096 vc_client_get_service_state(g_vc, &service_state);
2097 if (service_state != VC_SERVICE_STATE_READY) {
2098 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2099 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2100 SLOG(LOG_DEBUG, TAG_VCC, " ");
2101 return VC_ERROR_INVALID_STATE;
2104 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);
2105 int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2107 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2108 return VC_ERROR_OPERATION_FAILED;
2111 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2112 SLOG(LOG_DEBUG, TAG_VCC, " ");
2114 return VC_ERROR_NONE;
2118 int vc_auth_enable(void)
2122 if (0 != vc_client_get_client_state(g_vc, &state)) {
2123 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2124 return VC_ERROR_INVALID_STATE;
2127 if (VC_STATE_READY != state) {
2128 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2129 return VC_ERROR_INVALID_STATE;
2132 /* check already authority */
2133 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2134 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2135 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2136 return VC_ERROR_INVALID_STATE;
2139 if (VC_AUTH_STATE_NONE != auth_state) {
2140 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2141 return VC_ERROR_INVALID_STATE;
2144 /* request authority */
2146 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2148 return VC_ERROR_OPERATION_FAILED;
2151 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2152 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2153 return VC_ERROR_OPERATION_FAILED;
2156 /* set authority into handle */
2157 bool is_foreground = false;
2158 if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2159 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2160 return VC_ERROR_OPERATION_FAILED;
2163 if (is_foreground) {
2164 auth_state = VC_AUTH_STATE_VALID;
2166 auth_state = VC_AUTH_STATE_INVALID;
2169 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2170 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2171 return VC_ERROR_OPERATION_FAILED;
2174 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2176 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2178 return VC_ERROR_NONE;
2181 int vc_auth_disable(void)
2185 if (0 != vc_client_get_client_state(g_vc, &state)) {
2186 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2187 return VC_ERROR_INVALID_STATE;
2190 if (VC_STATE_READY != state) {
2191 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2192 return VC_ERROR_INVALID_STATE;
2195 /* check autority */
2196 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2197 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2198 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2199 return VC_ERROR_INVALID_STATE;
2202 if (VC_AUTH_STATE_NONE == auth_state) {
2203 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2204 return VC_ERROR_INVALID_STATE;
2207 if (0 != vc_auth_unset_state_changed_cb()) {
2208 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2211 /* request return authority by dbus */
2213 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2214 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2215 return VC_ERROR_OPERATION_FAILED;
2218 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2219 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2220 return VC_ERROR_OPERATION_FAILED;
2223 /* unset authority from handle */
2224 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2225 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2226 return VC_ERROR_OPERATION_FAILED;
2229 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2231 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2233 return VC_ERROR_NONE;
2236 int vc_auth_get_state(vc_auth_state_e* state)
2239 vc_state_e vc_state;
2240 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2241 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2242 return VC_ERROR_INVALID_STATE;
2245 if (VC_STATE_READY != vc_state) {
2246 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2247 return VC_ERROR_INVALID_STATE;
2251 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2252 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2253 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2254 return VC_ERROR_INVALID_STATE;
2259 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2261 return VC_ERROR_NONE;
2264 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2266 /* check parameter */
2267 if (NULL == callback) {
2268 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2269 return VC_ERROR_INVALID_PARAMETER;
2273 vc_auth_state_e auth_state;
2274 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2275 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2276 return VC_ERROR_INVALID_STATE;
2279 if (VC_AUTH_STATE_NONE == auth_state) {
2280 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2281 return VC_ERROR_INVALID_STATE;
2284 /* set cb into handle */
2285 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2286 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2287 return VC_ERROR_OPERATION_FAILED;
2290 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
2292 return VC_ERROR_NONE;
2295 int vc_auth_unset_state_changed_cb(void)
2298 vc_auth_state_e auth_state;
2299 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2300 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2301 return VC_ERROR_INVALID_STATE;
2304 if (VC_AUTH_STATE_NONE == auth_state) {
2305 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2306 return VC_ERROR_INVALID_STATE;
2309 /* unset cb from handle */
2310 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2311 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2312 return VC_ERROR_OPERATION_FAILED;
2315 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2317 return VC_ERROR_NONE;
2320 int vc_auth_start(void)
2322 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
2325 if (0 != vc_client_get_client_state(g_vc, &state)) {
2326 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2327 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2328 SLOG(LOG_DEBUG, TAG_VCC, " ");
2329 return VC_ERROR_INVALID_STATE;
2333 if (state != VC_STATE_READY) {
2334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2335 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2336 SLOG(LOG_DEBUG, TAG_VCC, " ");
2337 return VC_ERROR_INVALID_STATE;
2340 /* Check service state */
2341 vc_service_state_e service_state = -1;
2342 vc_client_get_service_state(g_vc, &service_state);
2343 if (service_state != VC_SERVICE_STATE_READY) {
2344 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2345 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2346 SLOG(LOG_DEBUG, TAG_VCC, " ");
2347 return VC_ERROR_INVALID_STATE;
2350 /* Check authority */
2351 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2352 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2353 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2354 return VC_ERROR_OPERATION_FAILED;
2357 if (VC_AUTH_STATE_VALID != auth_state) {
2358 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2359 return VC_ERROR_OPERATION_FAILED;
2364 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2365 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2366 return VC_ERROR_OPERATION_FAILED;
2375 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2377 if (VC_ERROR_TIMED_OUT != ret) {
2378 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2381 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2384 if (VC_RETRY_COUNT == count) {
2385 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2390 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2394 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2395 SLOG(LOG_DEBUG, TAG_VCC, " ");
2400 int vc_auth_stop(void)
2402 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
2405 if (0 != vc_client_get_client_state(g_vc, &state)) {
2406 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2407 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2408 SLOG(LOG_DEBUG, TAG_VCC, " ");
2409 return VC_ERROR_INVALID_STATE;
2413 if (state != VC_STATE_READY) {
2414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2415 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2416 SLOG(LOG_DEBUG, TAG_VCC, " ");
2417 return VC_ERROR_INVALID_STATE;
2420 /* Check service state */
2421 vc_service_state_e service_state = -1;
2422 vc_client_get_service_state(g_vc, &service_state);
2423 if (service_state != VC_SERVICE_STATE_RECORDING) {
2424 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2425 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2426 SLOG(LOG_DEBUG, TAG_VCC, " ");
2427 return VC_ERROR_INVALID_STATE;
2430 /* Check authority */
2431 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2432 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2433 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2434 return VC_ERROR_OPERATION_FAILED;
2437 if (VC_AUTH_STATE_VALID != auth_state) {
2438 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2439 return VC_ERROR_OPERATION_FAILED;
2444 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2445 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2446 return VC_ERROR_OPERATION_FAILED;
2453 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2455 if (VC_ERROR_TIMED_OUT != ret) {
2456 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2459 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2462 if (VC_RETRY_COUNT == count) {
2463 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2468 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2472 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2473 SLOG(LOG_DEBUG, TAG_VCC, " ");
2478 int vc_auth_cancel(void)
2480 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2483 if (0 != vc_client_get_client_state(g_vc, &state)) {
2484 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2485 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2486 SLOG(LOG_DEBUG, TAG_VCC, " ");
2487 return VC_ERROR_INVALID_STATE;
2491 if (state != VC_STATE_READY) {
2492 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2493 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2494 SLOG(LOG_DEBUG, TAG_VCC, " ");
2495 return VC_ERROR_INVALID_STATE;
2498 /* Check service state */
2499 vc_service_state_e service_state = -1;
2500 vc_client_get_service_state(g_vc, &service_state);
2501 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2502 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2503 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2504 SLOG(LOG_DEBUG, TAG_VCC, " ");
2505 return VC_ERROR_INVALID_STATE;
2508 /* Check authority */
2509 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2510 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2511 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2512 return VC_ERROR_OPERATION_FAILED;
2515 if (VC_AUTH_STATE_VALID != auth_state) {
2516 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2517 return VC_ERROR_OPERATION_FAILED;
2522 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2523 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2524 return VC_ERROR_OPERATION_FAILED;
2530 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2532 if (VC_ERROR_TIMED_OUT != ret) {
2533 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2536 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2539 if (VC_RETRY_COUNT == count) {
2540 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2545 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2549 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2550 SLOG(LOG_DEBUG, TAG_VCC, " ");