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 "vc_client.h"
19 #include "vc_command.h"
20 #include "vc_config_mgr.h"
22 #include "vc_info_parser.h"
24 #include "voice_control.h"
25 #include "voice_control_authority.h"
26 #include "voice_control_command.h"
27 #include "voice_control_command_expand.h"
30 static bool g_is_daemon_started = false;
32 static Ecore_Timer* g_connect_timer = NULL;
34 static vc_h g_vc = NULL;
37 static Ecore_Event_Handler* g_focus_in_hander = NULL;
38 static Ecore_Event_Handler* g_focus_out_hander = NULL;
41 Eina_Bool __vc_notify_state_changed(void *data);
42 Eina_Bool __vc_notify_error(void *data);
45 static const char* __vc_get_error_code(vc_error_e err)
48 case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
49 case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
50 case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
51 case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER"; break;
52 case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT"; break;
53 case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY"; break;
54 case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE"; break;
55 case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE"; break;
56 case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND"; break;
57 case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED"; break;
58 default: return "Invalid error code"; break;
63 static int __vc_convert_config_error_code(vc_config_error_e code)
65 if (code == VC_CONFIG_ERROR_NONE) return VC_ERROR_NONE;
66 if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY) return VC_ERROR_OUT_OF_MEMORY;
67 if (code == VC_CONFIG_ERROR_IO_ERROR) return VC_ERROR_IO_ERROR;
68 if (code == VC_CONFIG_ERROR_INVALID_PARAMETER) return VC_ERROR_INVALID_PARAMETER;
69 if (code == VC_CONFIG_ERROR_INVALID_STATE) return VC_ERROR_INVALID_STATE;
70 if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE) return VC_ERROR_INVALID_LANGUAGE;
71 if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND) return VC_ERROR_ENGINE_NOT_FOUND;
72 if (code == VC_CONFIG_ERROR_OPERATION_FAILED) return VC_ERROR_OPERATION_FAILED;
77 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
79 SECURE_SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
80 before_lang, current_lang);
82 vc_current_language_changed_cb callback;
84 vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
86 if (NULL != callback) {
87 vc_client_use_callback(g_vc);
88 callback(before_lang, current_lang, lang_user_data);
89 vc_client_not_use_callback(g_vc);
90 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
92 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
98 static void __vc_service_state_changed_cb(int before_state, int current_state)
100 SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
101 before_state, current_state);
103 /* Save service state */
104 vc_client_set_service_state(g_vc, (vc_service_state_e)current_state);
106 vc_service_state_changed_cb service_callback = NULL;
107 void* service_user_data;
108 vc_client_get_service_state_changed_cb(g_vc, &service_callback, &service_user_data);
110 if (NULL != service_callback) {
111 vc_client_use_callback(g_vc);
112 service_callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
113 vc_client_not_use_callback(g_vc);
114 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
116 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is NULL");
124 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
127 if (true == vc_client_is_valid(g_vc)) {
128 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already initialized");
129 return VC_ERROR_INVALID_STATE;
132 if (0 < vc_client_get_count()) {
133 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
134 return VC_ERROR_INVALID_STATE;
137 if (0 != vc_dbus_open_connection()) {
138 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
139 return VC_ERROR_OPERATION_FAILED;
142 if (0 != vc_client_create(&g_vc)) {
143 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
144 return VC_ERROR_OUT_OF_MEMORY;
147 int ret = vc_config_mgr_initialize(g_vc->handle);
149 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
150 __vc_get_error_code(__vc_convert_config_error_code(ret)));
151 vc_client_destroy(g_vc);
152 return __vc_convert_config_error_code(ret);
155 ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
157 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
158 vc_config_mgr_finalize(g_vc->handle);
159 vc_client_destroy(g_vc);
160 return __vc_convert_config_error_code(ret);
163 ret = vc_config_mgr_set_service_state_cb(g_vc->handle, __vc_service_state_changed_cb);
165 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set service change callback : %d", ret);
166 vc_config_mgr_unset_lang_cb(g_vc->handle);
167 vc_config_mgr_finalize(g_vc->handle);
168 vc_client_destroy(g_vc);
169 return __vc_convert_config_error_code(ret);
172 int service_state = -1;
173 if (0 != vc_config_mgr_get_service_state(&service_state)) {
174 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
175 vc_config_mgr_finalize(g_vc->handle);
176 vc_client_destroy(g_vc);
177 return __vc_convert_config_error_code(ret);
180 vc_client_set_service_state(g_vc, service_state);
182 SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
184 SLOG(LOG_DEBUG, TAG_VCC, "=====");
185 SLOG(LOG_DEBUG, TAG_VCC, " ");
187 return VC_ERROR_NONE;
190 static void __vc_internal_unprepare()
192 /* return authority */
193 vc_auth_state_e state = VC_AUTH_STATE_NONE;
194 if (0 != vc_client_get_auth_state(g_vc, &state)) {
195 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
198 if (VC_AUTH_STATE_NONE != state) {
199 if (0 != vc_auth_disable()) {
200 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
204 int ret = vc_dbus_request_finalize(g_vc->handle);
206 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
209 g_is_daemon_started = false;
212 ecore_event_handler_del(g_focus_in_hander);
213 ecore_event_handler_del(g_focus_out_hander);
216 vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
217 vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_BACKGROUND);
222 int vc_deinitialize()
224 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
226 if (false == vc_client_is_valid(g_vc)) {
227 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
228 SLOG(LOG_DEBUG, TAG_VCC, "=====");
229 SLOG(LOG_DEBUG, TAG_VCC, " ");
230 return VC_ERROR_INVALID_STATE;
234 vc_client_get_client_state(g_vc, &state);
239 __vc_internal_unprepare();
240 /* no break. need to next step*/
241 case VC_STATE_INITIALIZED:
242 if (NULL != g_connect_timer) {
243 SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
244 ecore_timer_del(g_connect_timer);
247 vc_config_mgr_unset_service_state_cb(g_vc->handle);
248 vc_config_mgr_unset_lang_cb(g_vc->handle);
249 vc_config_mgr_finalize(g_vc->handle);
251 /* Free client resources */
252 vc_client_destroy(g_vc);
261 SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
263 if (0 != vc_dbus_close_connection()) {
264 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
267 SLOG(LOG_DEBUG, TAG_VCC, "=====");
268 SLOG(LOG_DEBUG, TAG_VCC, " ");
270 return VC_ERROR_NONE;
273 static Eina_Bool __notify_auth_changed_cb(void *data)
275 vc_auth_state_changed_cb callback = NULL;
278 vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
280 vc_auth_state_e before = -1;
281 vc_auth_state_e current = -1;
283 vc_client_get_before_auth_state(g_vc, &before, ¤t);
285 if (NULL != callback) {
286 vc_client_use_callback(g_vc);
287 callback(before, current, user_data);
288 vc_client_not_use_callback(g_vc);
289 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
291 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
300 static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
302 Ecore_X_Event_Window_Focus_In *e;
307 if (0 != vc_client_get_xid(g_vc, &xid)) {
308 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
309 return ECORE_CALLBACK_PASS_ON;
312 if (e->win == (Ecore_X_Window)xid) {
313 SLOG(LOG_DEBUG, TAG_VCC, "Focus in : pid(%d) xid(%d)", getpid(), xid);
314 int ret = vc_config_mgr_set_foreground(getpid(), true);
316 ret = vc_config_convert_error_code((vc_config_error_e)ret);
317 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
319 /* set authority valid */
320 vc_auth_state_e state = VC_AUTH_STATE_NONE;
321 if (0 != vc_client_get_auth_state(g_vc, &state)) {
322 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
324 if (VC_AUTH_STATE_INVALID == state) {
325 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
327 /* notify auth changed cb */
328 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
332 return ECORE_CALLBACK_PASS_ON;
335 static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
337 Ecore_X_Event_Window_Focus_In *e;
342 if (0 != vc_client_get_xid(g_vc, &xid)) {
343 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
344 return ECORE_CALLBACK_PASS_ON;
347 if (e->win == (Ecore_X_Window)xid) {
348 SLOG(LOG_DEBUG, TAG_VCC, "Focus out : pid(%d) xid(%d)", getpid(), xid);
349 int ret = vc_config_mgr_set_foreground(getpid(), false);
351 ret = vc_config_convert_error_code((vc_config_error_e)ret);
352 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus out : %s", __vc_get_error_code(ret));
354 /* set authority valid */
355 vc_auth_state_e state = VC_AUTH_STATE_NONE;
356 if (0 != vc_client_get_auth_state(g_vc, &state)) {
357 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
359 if (VC_AUTH_STATE_VALID == state) {
360 vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
362 /* notify authority changed cb */
363 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
367 return ECORE_CALLBACK_PASS_ON;
371 static void __vc_fork_vc_daemon()
378 SLOG(LOG_ERROR, TAG_VCC, "Fail to create daemon");
382 for (i = 0;i < _NSIG;i++)
385 execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
393 static Eina_Bool __vc_connect_daemon(void *data)
396 if (0 != vc_dbus_request_hello()) {
397 if (false == g_is_daemon_started) {
398 g_is_daemon_started = true;
399 __vc_fork_vc_daemon();
404 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
406 /* request initialization */
409 ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid);
410 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
411 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
413 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
414 ecore_timer_add(0, __vc_notify_error, g_vc);
416 SLOG(LOG_DEBUG, TAG_VCC, "=====");
417 SLOG(LOG_DEBUG, TAG_VCC, " ");
420 } else if (0 != ret) {
421 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
423 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
424 ecore_timer_add(0, __vc_notify_error, g_vc);
426 SLOG(LOG_DEBUG, TAG_VCC, "=====");
427 SLOG(LOG_DEBUG, TAG_VCC, " ");
430 /* Success to connect */
433 g_connect_timer = NULL;
436 g_focus_in_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, __vc_x_event_window_focus_in, NULL);
437 g_focus_out_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, __vc_x_event_window_focus_out, NULL);
440 vc_client_set_client_state(g_vc, VC_STATE_READY);
441 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
443 vc_client_set_mgr_pid(g_vc, mgr_pid);
445 SLOG(LOG_DEBUG, TAG_VCC, "=====");
446 SLOG(LOG_DEBUG, TAG_VCC, " ");
453 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
456 if (0 != vc_client_get_client_state(g_vc, &state)) {
457 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
458 SLOG(LOG_DEBUG, TAG_VCC, "=====");
459 SLOG(LOG_DEBUG, TAG_VCC, " ");
460 return VC_ERROR_INVALID_STATE;
464 if (state != VC_STATE_INITIALIZED) {
465 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
466 SLOG(LOG_DEBUG, TAG_VCC, "=====");
467 SLOG(LOG_DEBUG, TAG_VCC, " ");
468 return VC_ERROR_INVALID_STATE;
471 g_is_daemon_started = false;
473 g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
475 SLOG(LOG_DEBUG, TAG_VCC, "=====");
476 SLOG(LOG_DEBUG, TAG_VCC, " ");
478 return VC_ERROR_NONE;
483 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
486 if (0 != vc_client_get_client_state(g_vc, &state)) {
487 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
488 SLOG(LOG_DEBUG, TAG_VCC, "=====");
489 SLOG(LOG_DEBUG, TAG_VCC, " ");
490 return VC_ERROR_INVALID_STATE;
494 if (state != VC_STATE_READY) {
495 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
496 SLOG(LOG_DEBUG, TAG_VCC, "=====");
497 SLOG(LOG_DEBUG, TAG_VCC, " ");
498 return VC_ERROR_INVALID_STATE;
501 __vc_internal_unprepare();
503 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
504 ecore_timer_add(0, __vc_notify_state_changed, g_vc);
506 SLOG(LOG_DEBUG, TAG_VCC, "=====");
507 SLOG(LOG_DEBUG, TAG_VCC, " ");
509 return VC_ERROR_NONE;
512 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
514 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
516 if (NULL == callback) {
517 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
518 SLOG(LOG_DEBUG, TAG_VCC, "=====");
519 SLOG(LOG_DEBUG, TAG_VCC, " ");
520 return VC_ERROR_INVALID_PARAMETER;
524 if (0 != vc_client_get_client_state(g_vc, &state)) {
525 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
526 SLOG(LOG_DEBUG, TAG_VCC, "=====");
527 SLOG(LOG_DEBUG, TAG_VCC, " ");
528 return VC_ERROR_INVALID_STATE;
532 ret = vc_config_mgr_get_language_list(callback, user_data);
534 ret = vc_config_convert_error_code((vc_config_error_e)ret);
535 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
538 SLOG(LOG_DEBUG, TAG_VCC, "=====");
539 SLOG(LOG_DEBUG, TAG_VCC, " ");
541 return VC_ERROR_NONE;
545 int vc_get_current_language(char** language)
547 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
549 if (NULL == language) {
550 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
551 SLOG(LOG_DEBUG, TAG_VCC, "=====");
552 SLOG(LOG_DEBUG, TAG_VCC, " ");
553 return VC_ERROR_INVALID_PARAMETER;
557 if (0 != vc_client_get_client_state(g_vc, &state)) {
558 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
559 SLOG(LOG_DEBUG, TAG_VCC, "=====");
560 SLOG(LOG_DEBUG, TAG_VCC, " ");
561 return VC_ERROR_INVALID_STATE;
565 ret = vc_config_mgr_get_default_language(language);
567 ret = vc_config_convert_error_code((vc_config_error_e)ret);
568 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
571 SLOG(LOG_DEBUG, TAG_VCC, "=====");
572 SLOG(LOG_DEBUG, TAG_VCC, " ");
577 int vc_get_state(vc_state_e* state)
579 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
582 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
583 return VC_ERROR_INVALID_PARAMETER;
587 if (0 != vc_client_get_client_state(g_vc, &temp)) {
588 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
589 SLOG(LOG_DEBUG, TAG_VCC, "=====");
590 SLOG(LOG_DEBUG, TAG_VCC, " ");
591 return VC_ERROR_INVALID_STATE;
597 case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
598 case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
599 case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
600 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
603 SLOG(LOG_DEBUG, TAG_VCC, "=====");
604 SLOG(LOG_DEBUG, TAG_VCC, " ");
606 return VC_ERROR_NONE;
609 int vc_get_service_state(vc_service_state_e* state)
611 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
614 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
615 return VC_ERROR_INVALID_PARAMETER;
619 if (0 != vc_client_get_client_state(g_vc, &temp)) {
620 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
621 SLOG(LOG_DEBUG, TAG_VCC, "=====");
622 SLOG(LOG_DEBUG, TAG_VCC, " ");
623 return VC_ERROR_INVALID_STATE;
626 /* get service state */
627 vc_service_state_e service_state;
628 if (0 != vc_client_get_service_state(g_vc, &service_state)) {
629 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
630 return VC_ERROR_OPERATION_FAILED;
633 *state = service_state;
636 case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
637 case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
638 case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
639 case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
640 default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
643 SLOG(LOG_DEBUG, TAG_VCC, "=====");
644 SLOG(LOG_DEBUG, TAG_VCC, " ");
646 return VC_ERROR_NONE;
650 int vc_set_window_id(int wid)
652 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Window id");
655 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is invalid");
656 SLOG(LOG_DEBUG, TAG_VCC, "=====");
657 SLOG(LOG_DEBUG, TAG_VCC, " ");
658 return VC_ERROR_INVALID_PARAMETER;
662 if (0 != vc_client_get_client_state(g_vc, &state)) {
663 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
664 SLOG(LOG_DEBUG, TAG_VCC, "=====");
665 SLOG(LOG_DEBUG, TAG_VCC, " ");
666 return VC_ERROR_INVALID_STATE;
670 if (state != VC_STATE_READY) {
671 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
672 SLOG(LOG_DEBUG, TAG_VCC, "=====");
673 SLOG(LOG_DEBUG, TAG_VCC, " ");
674 return VC_ERROR_INVALID_STATE;
677 if (0 != vc_client_set_xid(g_vc, wid)) {
678 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
679 SLOG(LOG_DEBUG, TAG_VCC, "=====");
680 SLOG(LOG_DEBUG, TAG_VCC, " ");
681 return VC_ERROR_INVALID_STATE;
684 /* Check if current xid is top window */
686 if ((Ecore_X_Window)wid == ecore_x_window_focus_get()) {
687 /* Set current pid */
688 ret = vc_config_mgr_set_foreground(getpid(), true);
690 ret = vc_config_convert_error_code((vc_config_error_e)ret);
691 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
695 SLOG(LOG_DEBUG, TAG_VCC, "=====");
696 SLOG(LOG_DEBUG, TAG_VCC, " ");
701 int vc_get_window_id(int* wid)
703 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Window id");
706 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
707 SLOG(LOG_DEBUG, TAG_VCC, "=====");
708 SLOG(LOG_DEBUG, TAG_VCC, " ");
709 return VC_ERROR_INVALID_PARAMETER;
713 if (0 != vc_client_get_client_state(g_vc, &state)) {
714 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
715 SLOG(LOG_DEBUG, TAG_VCC, "=====");
716 SLOG(LOG_DEBUG, TAG_VCC, " ");
717 return VC_ERROR_INVALID_STATE;
721 if (state != VC_STATE_READY) {
722 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
723 SLOG(LOG_DEBUG, TAG_VCC, "=====");
724 SLOG(LOG_DEBUG, TAG_VCC, " ");
725 return VC_ERROR_INVALID_STATE;
728 if (0 != vc_client_get_xid(g_vc, wid)) {
729 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
730 SLOG(LOG_DEBUG, TAG_VCC, "=====");
731 SLOG(LOG_DEBUG, TAG_VCC, " ");
732 return VC_ERROR_INVALID_STATE;
735 SLOG(LOG_DEBUG, TAG_VCC, "=====");
736 SLOG(LOG_DEBUG, TAG_VCC, " ");
738 return VC_ERROR_NONE;
743 * @brief Checks whether the command format is supported.
746 * @param[in] format The command format
747 * @param[out] support The result status @c true = supported, @c false = not supported
749 * @return 0 on success, otherwise a negative error value
750 * @retval #VC_ERROR_NONE Successful
751 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
752 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
753 * @retval #VC_ERROR_INVALID_STATE Invalid state
755 * @pre The state should be #VC_STATE_READY.
758 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
760 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
763 if (0 != vc_client_get_client_state(g_vc, &state)) {
764 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
765 SLOG(LOG_DEBUG, TAG_VCC, "=====");
766 SLOG(LOG_DEBUG, TAG_VCC, " ");
767 return VC_ERROR_INVALID_STATE;
771 bool non_fixed_support = false;
772 if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
773 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
777 case VC_CMD_FORMAT_FIXED: *support = true; break;
778 case VC_CMD_FORMAT_FIXED_AND_EXTRA: *support = non_fixed_support; break;
779 case VC_CMD_FORMAT_EXTRA_AND_FIXED: *support = non_fixed_support; break;
780 default: *support = false; break;
783 SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
785 SLOG(LOG_DEBUG, TAG_VCC, "=====");
786 SLOG(LOG_DEBUG, TAG_VCC, " ");
788 return VC_ERROR_NONE;
792 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
794 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
796 if (NULL == vc_cmd_list) {
797 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
798 return VC_ERROR_INVALID_PARAMETER;
802 if (0 != vc_client_get_client_state(g_vc, &state)) {
803 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
804 SLOG(LOG_DEBUG, TAG_VCC, "=====");
805 SLOG(LOG_DEBUG, TAG_VCC, " ");
806 return VC_ERROR_INVALID_STATE;
810 if (state != VC_STATE_READY) {
811 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
812 SLOG(LOG_DEBUG, TAG_VCC, "=====");
813 SLOG(LOG_DEBUG, TAG_VCC, " ");
814 return VC_ERROR_INVALID_STATE;
818 if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
819 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
820 SLOG(LOG_DEBUG, TAG_VCC, "=====");
821 SLOG(LOG_DEBUG, TAG_VCC, " ");
822 return VC_ERROR_INVALID_STATE;
825 vc_cmd_list_s* list = NULL;
826 list = (vc_cmd_list_s*)vc_cmd_list;
829 if (0 != vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list)) {
830 ret = VC_ERROR_INVALID_PARAMETER;
831 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
835 ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
837 if (VC_ERROR_TIMED_OUT != ret) {
838 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
841 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
844 if (VC_RETRY_COUNT == count) {
845 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
853 SLOG(LOG_DEBUG, TAG_VCC, "=====");
854 SLOG(LOG_DEBUG, TAG_VCC, " ");
859 int vc_unset_command_list(int type)
861 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
864 if (0 != vc_client_get_client_state(g_vc, &state)) {
865 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
866 SLOG(LOG_DEBUG, TAG_VCC, "=====");
867 SLOG(LOG_DEBUG, TAG_VCC, " ");
868 return VC_ERROR_INVALID_STATE;
872 if (state != VC_STATE_READY) {
873 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
874 SLOG(LOG_DEBUG, TAG_VCC, "=====");
875 SLOG(LOG_DEBUG, TAG_VCC, " ");
876 return VC_ERROR_INVALID_STATE;
882 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
884 if (VC_ERROR_TIMED_OUT != ret) {
885 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
888 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
891 if (VC_RETRY_COUNT == count) {
892 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
899 ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
901 ret = vc_config_convert_error_code((vc_config_error_e)ret);
902 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
905 SLOG(LOG_DEBUG, TAG_VCC, "=====");
906 SLOG(LOG_DEBUG, TAG_VCC, " ");
912 int vc_get_exclusive_command_option(bool* value)
914 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
917 if (0 != vc_client_get_client_state(g_vc, &state)) {
918 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
919 SLOG(LOG_DEBUG, TAG_VCC, "=====");
920 SLOG(LOG_DEBUG, TAG_VCC, " ");
921 return VC_ERROR_INVALID_STATE;
925 if (state != VC_STATE_READY) {
926 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
927 SLOG(LOG_DEBUG, TAG_VCC, "=====");
928 SLOG(LOG_DEBUG, TAG_VCC, " ");
929 return VC_ERROR_INVALID_STATE;
932 int ret = vc_client_get_exclusive_cmd(g_vc, value);
934 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
935 SLOG(LOG_DEBUG, TAG_VCC, "=====");
936 SLOG(LOG_DEBUG, TAG_VCC, " ");
940 SLOG(LOG_DEBUG, TAG_VCC, "=====");
941 SLOG(LOG_DEBUG, TAG_VCC, " ");
946 int vc_set_exclusive_command_option(bool value)
948 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
951 if (0 != vc_client_get_client_state(g_vc, &state)) {
952 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
953 SLOG(LOG_DEBUG, TAG_VCC, "=====");
954 SLOG(LOG_DEBUG, TAG_VCC, " ");
955 return VC_ERROR_INVALID_STATE;
959 if (state != VC_STATE_READY) {
960 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
961 SLOG(LOG_DEBUG, TAG_VCC, "=====");
962 SLOG(LOG_DEBUG, TAG_VCC, " ");
963 return VC_ERROR_INVALID_STATE;
966 int ret = vc_client_set_exclusive_cmd(g_vc, value);
968 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
969 SLOG(LOG_DEBUG, TAG_VCC, "=====");
970 SLOG(LOG_DEBUG, TAG_VCC, " ");
974 /* Check if current xid is top window */
977 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
979 if (VC_ERROR_TIMED_OUT != ret) {
980 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
983 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
986 if (VC_RETRY_COUNT == count) {
987 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
994 SLOG(LOG_DEBUG, TAG_VCC, "=====");
995 SLOG(LOG_DEBUG, TAG_VCC, " ");
1002 int vc_request_start(bool stop_by_silence)
1004 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1007 if (0 != vc_client_get_client_state(g_vc, &state)) {
1008 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1009 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1010 SLOG(LOG_DEBUG, TAG_VCC, " ");
1011 return VC_ERROR_INVALID_STATE;
1015 if (state != VC_STATE_READY) {
1016 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1017 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1018 SLOG(LOG_DEBUG, TAG_VCC, " ");
1019 return VC_ERROR_INVALID_STATE;
1022 /* Check service state */
1023 vc_service_state_e service_state = -1;
1024 vc_client_get_service_state(g_vc, &service_state);
1025 if (service_state != VC_SERVICE_STATE_READY) {
1026 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1027 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1028 SLOG(LOG_DEBUG, TAG_VCC, " ");
1029 return VC_ERROR_INVALID_STATE;
1039 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1041 if (VC_ERROR_TIMED_OUT != ret) {
1042 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1045 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1048 if (VC_RETRY_COUNT == count) {
1049 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1054 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1058 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1059 SLOG(LOG_DEBUG, TAG_VCC, " ");
1064 int vc_request_stop()
1066 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1069 if (0 != vc_client_get_client_state(g_vc, &state)) {
1070 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1071 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1072 SLOG(LOG_DEBUG, TAG_VCC, " ");
1073 return VC_ERROR_INVALID_STATE;
1077 if (state != VC_STATE_READY) {
1078 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1079 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1080 SLOG(LOG_DEBUG, TAG_VCC, " ");
1081 return VC_ERROR_INVALID_STATE;
1084 /* Check service state */
1085 vc_service_state_e service_state = -1;
1086 vc_client_get_service_state(g_vc, &service_state);
1087 if (service_state != VC_SERVICE_STATE_RECORDING) {
1088 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1089 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1090 SLOG(LOG_DEBUG, TAG_VCC, " ");
1091 return VC_ERROR_INVALID_STATE;
1098 ret = vc_dbus_request_stop(g_vc->handle);
1100 if (VC_ERROR_TIMED_OUT != ret) {
1101 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1104 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1107 if (VC_RETRY_COUNT == count) {
1108 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1113 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1117 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1118 SLOG(LOG_DEBUG, TAG_VCC, " ");
1123 int vc_request_cancel()
1125 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1128 if (0 != vc_client_get_client_state(g_vc, &state)) {
1129 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1130 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1131 SLOG(LOG_DEBUG, TAG_VCC, " ");
1132 return VC_ERROR_INVALID_STATE;
1136 if (state != VC_STATE_READY) {
1137 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1138 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1139 SLOG(LOG_DEBUG, TAG_VCC, " ");
1140 return VC_ERROR_INVALID_STATE;
1143 /* Check service state */
1144 vc_service_state_e service_state = -1;
1145 vc_client_get_service_state(g_vc, &service_state);
1146 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1147 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1148 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1149 SLOG(LOG_DEBUG, TAG_VCC, " ");
1150 return VC_ERROR_INVALID_STATE;
1156 ret = vc_dbus_request_cancel(g_vc->handle);
1158 if (VC_ERROR_TIMED_OUT != ret) {
1159 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1162 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1165 if (VC_RETRY_COUNT == count) {
1166 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1171 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1175 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1176 SLOG(LOG_DEBUG, TAG_VCC, " ");
1182 Eina_Bool __vc_notify_error(void *data)
1184 vc_h vc = (vc_h)data;
1186 vc_error_cb callback = NULL;
1190 vc_client_get_error_cb(vc, &callback, &user_data);
1191 vc_client_get_error(vc, &reason);
1193 if (NULL != callback) {
1194 vc_client_use_callback(vc);
1195 callback(reason, user_data);
1196 vc_client_not_use_callback(vc);
1197 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1199 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1205 int __vc_cb_error(int pid, int reason)
1207 if (0 != vc_client_get_handle(pid, &g_vc)) {
1208 SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid");
1212 vc_client_set_error(g_vc, reason);
1213 ecore_timer_add(0, __vc_notify_error, g_vc);
1218 Eina_Bool __vc_notify_state_changed(void *data)
1220 vc_h vc = (vc_h)data;
1222 vc_state_changed_cb changed_callback = NULL;
1225 vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1227 vc_state_e current_state;
1228 vc_state_e before_state;
1230 vc_client_get_before_state(vc, ¤t_state, &before_state);
1232 if (NULL != changed_callback) {
1233 vc_client_use_callback(vc);
1234 changed_callback(before_state, current_state, user_data);
1235 vc_client_not_use_callback(vc);
1236 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1238 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1244 static Eina_Bool __vc_notify_result(void *data)
1248 vc_cmd_list_h vc_cmd_list = NULL;
1250 vc_result_cb callback = NULL;
1251 void* user_data = NULL;
1253 vc_client_get_result_cb(g_vc, &callback, &user_data);
1255 if (NULL == callback) {
1256 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1260 if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1261 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1265 vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1267 SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1269 vc_cmd_print_list(vc_cmd_list);
1271 vc_client_use_callback(g_vc);
1272 callback(event, vc_cmd_list, temp_text, user_data);
1273 vc_client_not_use_callback(g_vc);
1275 SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1277 vc_cmd_list_destroy(vc_cmd_list, true);
1279 /* Release result */
1280 if (NULL != temp_text) free(temp_text);
1285 void __vc_cb_result()
1287 ecore_timer_add(0, __vc_notify_result, NULL);
1292 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1294 if (NULL == callback)
1295 return VC_ERROR_INVALID_PARAMETER;
1298 if (0 != vc_client_get_client_state(g_vc, &state)) {
1299 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1300 return VC_ERROR_INVALID_STATE;
1304 if (state != VC_STATE_INITIALIZED) {
1305 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1306 return VC_ERROR_INVALID_STATE;
1309 vc_client_set_result_cb(g_vc, callback, user_data);
1314 int vc_unset_result_cb()
1317 if (0 != vc_client_get_client_state(g_vc, &state)) {
1318 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1319 return VC_ERROR_INVALID_STATE;
1323 if (state != VC_STATE_INITIALIZED) {
1324 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1325 return VC_ERROR_INVALID_STATE;
1328 vc_client_set_result_cb(g_vc, NULL, NULL);
1333 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1335 if (NULL == callback)
1336 return VC_ERROR_INVALID_PARAMETER;
1339 if (0 != vc_client_get_client_state(g_vc, &state)) {
1340 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1341 return VC_ERROR_INVALID_STATE;
1345 if (state != VC_STATE_INITIALIZED) {
1346 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1347 return VC_ERROR_INVALID_STATE;
1350 vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1355 int vc_unset_service_state_changed_cb()
1358 if (0 != vc_client_get_client_state(g_vc, &state)) {
1359 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1360 return VC_ERROR_INVALID_STATE;
1364 if (state != VC_STATE_INITIALIZED) {
1365 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1366 return VC_ERROR_INVALID_STATE;
1369 vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1374 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1376 if (callback == NULL)
1377 return VC_ERROR_INVALID_PARAMETER;
1380 if (0 != vc_client_get_client_state(g_vc, &state)) {
1381 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1382 return VC_ERROR_INVALID_STATE;
1386 if (state != VC_STATE_INITIALIZED) {
1387 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1388 return VC_ERROR_INVALID_STATE;
1391 vc_client_set_state_changed_cb(g_vc, callback, user_data);
1396 int vc_unset_state_changed_cb()
1399 if (0 != vc_client_get_client_state(g_vc, &state)) {
1400 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1401 return VC_ERROR_INVALID_STATE;
1405 if (state != VC_STATE_INITIALIZED) {
1406 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1407 return VC_ERROR_INVALID_STATE;
1410 vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1415 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1417 if (NULL == callback)
1418 return VC_ERROR_INVALID_PARAMETER;
1421 if (0 != vc_client_get_client_state(g_vc, &state)) {
1422 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1423 return VC_ERROR_INVALID_STATE;
1427 if (state != VC_STATE_INITIALIZED) {
1428 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1429 return VC_ERROR_INVALID_STATE;
1432 vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1437 int vc_unset_current_language_changed_cb()
1440 if (0 != vc_client_get_client_state(g_vc, &state)) {
1441 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1442 return VC_ERROR_INVALID_STATE;
1446 if (state != VC_STATE_INITIALIZED) {
1447 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1448 return VC_ERROR_INVALID_STATE;
1451 vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1456 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1458 if (NULL == callback)
1459 return VC_ERROR_INVALID_PARAMETER;
1462 if (0 != vc_client_get_client_state(g_vc, &state)) {
1463 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1464 return VC_ERROR_INVALID_STATE;
1468 if (state != VC_STATE_INITIALIZED) {
1469 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1470 return VC_ERROR_INVALID_STATE;
1473 vc_client_set_error_cb(g_vc, callback, user_data);
1478 int vc_unset_error_cb()
1481 if (0 != vc_client_get_client_state(g_vc, &state)) {
1482 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
1483 return VC_ERROR_INVALID_STATE;
1487 if (state != VC_STATE_INITIALIZED) {
1488 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
1489 return VC_ERROR_INVALID_STATE;
1492 vc_client_set_error_cb(g_vc, NULL, NULL);
1498 int vc_auth_enable()
1502 if (0 != vc_client_get_client_state(g_vc, &state)) {
1503 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1504 return VC_ERROR_INVALID_STATE;
1507 if (VC_STATE_READY != state) {
1508 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1509 return VC_ERROR_INVALID_STATE;
1512 /* check already authority */
1513 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1514 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1515 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1516 return VC_ERROR_INVALID_STATE;
1519 if (VC_AUTH_STATE_NONE != auth_state) {
1520 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
1521 return VC_ERROR_INVALID_STATE;
1524 /* request authority */
1526 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1527 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1528 return VC_ERROR_OPERATION_FAILED;
1531 if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
1532 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
1533 return VC_ERROR_OPERATION_FAILED;
1536 /* set authority into handle */
1538 if (0 != vc_config_mgr_get_foreground(&fg_pid)) {
1539 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get foreground");
1540 return VC_ERROR_OPERATION_FAILED;
1543 if (g_vc->handle == fg_pid) {
1544 auth_state = VC_AUTH_STATE_VALID;
1546 auth_state = VC_AUTH_STATE_INVALID;
1549 if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
1550 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1551 return VC_ERROR_OPERATION_FAILED;
1554 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1556 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
1558 return VC_ERROR_NONE;
1561 int vc_auth_disable()
1565 if (0 != vc_client_get_client_state(g_vc, &state)) {
1566 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1567 return VC_ERROR_INVALID_STATE;
1570 if (VC_STATE_READY != state) {
1571 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1572 return VC_ERROR_INVALID_STATE;
1575 /* check autority */
1576 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1577 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1578 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1579 return VC_ERROR_INVALID_STATE;
1582 if (VC_AUTH_STATE_NONE == auth_state) {
1583 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
1584 return VC_ERROR_INVALID_STATE;
1587 if (0 != vc_auth_unset_state_changed_cb()) {
1588 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
1591 /* request return authority by dbus */
1593 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1594 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1595 return VC_ERROR_OPERATION_FAILED;
1598 if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
1599 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
1600 return VC_ERROR_OPERATION_FAILED;
1603 /* unset authority from handle */
1604 if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
1605 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1606 return VC_ERROR_OPERATION_FAILED;
1609 ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1611 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
1613 return VC_ERROR_NONE;
1616 int vc_auth_get_state(vc_auth_state_e* state)
1619 vc_state_e vc_state;
1620 if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
1621 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1622 return VC_ERROR_INVALID_STATE;
1625 if (VC_STATE_READY != vc_state) {
1626 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1627 return VC_ERROR_INVALID_STATE;
1631 vc_auth_state_e temp = VC_AUTH_STATE_NONE;
1632 if (0 != vc_client_get_auth_state(g_vc, &temp)) {
1633 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1634 return VC_ERROR_INVALID_STATE;
1639 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
1641 return VC_ERROR_NONE;
1644 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
1646 /* check parameter */
1647 if (NULL == callback) {
1648 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
1649 return VC_ERROR_INVALID_PARAMETER;
1653 vc_auth_state_e auth_state;
1654 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1655 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1656 return VC_ERROR_INVALID_STATE;
1659 if (VC_AUTH_STATE_NONE == auth_state) {
1660 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
1661 return VC_ERROR_INVALID_STATE;
1664 /* set cb into handle */
1665 if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
1666 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
1667 return VC_ERROR_OPERATION_FAILED;
1670 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Set auth state changed cb");
1672 return VC_ERROR_NONE;
1675 int vc_auth_unset_state_changed_cb()
1678 vc_auth_state_e auth_state;
1679 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1680 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1681 return VC_ERROR_INVALID_STATE;
1684 if (VC_AUTH_STATE_NONE == auth_state) {
1685 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
1686 return VC_ERROR_INVALID_STATE;
1689 /* unset cb from handle */
1690 if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
1691 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
1692 return VC_ERROR_OPERATION_FAILED;
1695 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
1697 return VC_ERROR_NONE;
1702 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1705 if (0 != vc_client_get_client_state(g_vc, &state)) {
1706 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1707 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1708 SLOG(LOG_DEBUG, TAG_VCC, " ");
1709 return VC_ERROR_INVALID_STATE;
1713 if (state != VC_STATE_READY) {
1714 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1715 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1716 SLOG(LOG_DEBUG, TAG_VCC, " ");
1717 return VC_ERROR_INVALID_STATE;
1720 /* Check service state */
1721 vc_service_state_e service_state = -1;
1722 vc_client_get_service_state(g_vc, &service_state);
1723 if (service_state != VC_SERVICE_STATE_READY) {
1724 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1725 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1726 SLOG(LOG_DEBUG, TAG_VCC, " ");
1727 return VC_ERROR_INVALID_STATE;
1730 /* Check authority */
1731 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1732 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1733 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1734 return VC_ERROR_OPERATION_FAILED;
1737 if (VC_AUTH_STATE_VALID != auth_state) {
1738 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1739 return VC_ERROR_OPERATION_FAILED;
1744 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1745 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1746 return VC_ERROR_OPERATION_FAILED;
1755 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
1757 if (VC_ERROR_TIMED_OUT != ret) {
1758 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
1761 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
1764 if (VC_RETRY_COUNT == count) {
1765 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1770 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
1774 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1775 SLOG(LOG_DEBUG, TAG_VCC, " ");
1782 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1785 if (0 != vc_client_get_client_state(g_vc, &state)) {
1786 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1787 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1788 SLOG(LOG_DEBUG, TAG_VCC, " ");
1789 return VC_ERROR_INVALID_STATE;
1793 if (state != VC_STATE_READY) {
1794 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1795 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1796 SLOG(LOG_DEBUG, TAG_VCC, " ");
1797 return VC_ERROR_INVALID_STATE;
1800 /* Check service state */
1801 vc_service_state_e service_state = -1;
1802 vc_client_get_service_state(g_vc, &service_state);
1803 if (service_state != VC_SERVICE_STATE_RECORDING) {
1804 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1805 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1806 SLOG(LOG_DEBUG, TAG_VCC, " ");
1807 return VC_ERROR_INVALID_STATE;
1810 /* Check authority */
1811 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1812 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1813 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1814 return VC_ERROR_OPERATION_FAILED;
1817 if (VC_AUTH_STATE_VALID != auth_state) {
1818 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1819 return VC_ERROR_OPERATION_FAILED;
1824 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1825 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1826 return VC_ERROR_OPERATION_FAILED;
1833 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
1835 if (VC_ERROR_TIMED_OUT != ret) {
1836 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
1839 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
1842 if (VC_RETRY_COUNT == count) {
1843 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1848 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
1852 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1853 SLOG(LOG_DEBUG, TAG_VCC, " ");
1858 int vc_auth_cancel()
1860 SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
1863 if (0 != vc_client_get_client_state(g_vc, &state)) {
1864 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1865 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1866 SLOG(LOG_DEBUG, TAG_VCC, " ");
1867 return VC_ERROR_INVALID_STATE;
1871 if (state != VC_STATE_READY) {
1872 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1873 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1874 SLOG(LOG_DEBUG, TAG_VCC, " ");
1875 return VC_ERROR_INVALID_STATE;
1878 /* Check service state */
1879 vc_service_state_e service_state = -1;
1880 vc_client_get_service_state(g_vc, &service_state);
1881 if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1882 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1883 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1884 SLOG(LOG_DEBUG, TAG_VCC, " ");
1885 return VC_ERROR_INVALID_STATE;
1888 /* Check authority */
1889 vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1890 if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1891 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
1892 return VC_ERROR_OPERATION_FAILED;
1895 if (VC_AUTH_STATE_VALID != auth_state) {
1896 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
1897 return VC_ERROR_OPERATION_FAILED;
1902 if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1903 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1904 return VC_ERROR_OPERATION_FAILED;
1910 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
1912 if (VC_ERROR_TIMED_OUT != ret) {
1913 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
1916 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
1919 if (VC_RETRY_COUNT == count) {
1920 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1925 SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
1929 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1930 SLOG(LOG_DEBUG, TAG_VCC, " ");