* limitations under the License.
*/
+#include <aul.h>
+#include <system_info.h>
#include "vc_client.h"
#include "vc_command.h"
#include "voice_control_command_expand.h"
-static bool g_is_daemon_started = false;
static Ecore_Timer* g_connect_timer = NULL;
static vc_h g_vc = NULL;
+static int g_feature_enabled = -1;
+
#if 0
static Ecore_Event_Handler* g_focus_in_hander = NULL;
static Ecore_Event_Handler* g_focus_out_hander = NULL;
Eina_Bool __vc_notify_state_changed(void *data);
Eina_Bool __vc_notify_error(void *data);
+static int __vc_get_feature_enabled()
+{
+ if (0 == g_feature_enabled) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ } else if (-1 == g_feature_enabled) {
+ bool vc_supported = false;
+ bool mic_supported = false;
+ if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
+ if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
+ if (false == vc_supported || false == mic_supported) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
+ g_feature_enabled = 0;
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
+ g_feature_enabled = 1;
+ }
+ }
+ }
+
+ return 0;
+}
static const char* __vc_get_error_code(vc_error_e err)
{
- switch(err) {
+ switch (err) {
case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
- before_lang, current_lang);
+ SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
+ before_lang, current_lang);
vc_current_language_changed_cb callback;
void* lang_user_data;
return;
}
-static void __vc_service_state_changed_cb(int before_state, int current_state)
+static Eina_Bool __notify_auth_changed_cb(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
+ vc_auth_state_changed_cb callback = NULL;
+ void* user_data;
- /* Save service state */
- vc_client_set_service_state(g_vc, (vc_service_state_e)current_state);
+ vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
- vc_service_state_changed_cb service_callback = NULL;
- void* service_user_data;
- vc_client_get_service_state_changed_cb(g_vc, &service_callback, &service_user_data);
+ vc_auth_state_e before = -1;
+ vc_auth_state_e current = -1;
+
+ vc_client_get_before_auth_state(g_vc, &before, ¤t);
- if (NULL != service_callback) {
+ if (NULL != callback) {
vc_client_use_callback(g_vc);
- service_callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ callback(before, current, user_data);
vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
+ SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
} else {
- SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is NULL");
+ SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
}
- return;
+ return EINA_FALSE;
}
-int vc_initialize()
+
+int vc_initialize(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
/* check handle */
int ret = vc_config_mgr_initialize(g_vc->handle);
if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
- __vc_get_error_code(__vc_convert_config_error_code(ret)));
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
+ __vc_get_error_code(__vc_convert_config_error_code(ret)));
vc_client_destroy(g_vc);
return __vc_convert_config_error_code(ret);
}
return __vc_convert_config_error_code(ret);
}
- ret = vc_config_mgr_set_service_state_cb(g_vc->handle, __vc_service_state_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set service change callback : %d", ret);
- vc_config_mgr_unset_lang_cb(g_vc->handle);
- vc_config_mgr_finalize(g_vc->handle);
- vc_client_destroy(g_vc);
- return __vc_convert_config_error_code(ret);
- }
-
- int service_state = -1;
- if (0 != vc_config_mgr_get_service_state(&service_state)) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
- vc_config_mgr_finalize(g_vc->handle);
- vc_client_destroy(g_vc);
- return __vc_convert_config_error_code(ret);
- }
-
- vc_client_set_service_state(g_vc, service_state);
-
SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return VC_ERROR_NONE;
}
-static void __vc_internal_unprepare()
+static void __vc_internal_unprepare(void)
{
/* return authority */
vc_auth_state_e state = VC_AUTH_STATE_NONE;
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
}
- g_is_daemon_started = false;
#if 0
ecore_event_handler_del(g_focus_in_hander);
return;
}
-int vc_deinitialize()
+int vc_deinitialize(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
if (false == vc_client_is_valid(g_vc)) {
ecore_timer_del(g_connect_timer);
}
- vc_config_mgr_unset_service_state_cb(g_vc->handle);
vc_config_mgr_unset_lang_cb(g_vc->handle);
vc_config_mgr_finalize(g_vc->handle);
return VC_ERROR_NONE;
}
-static Eina_Bool __notify_auth_changed_cb(void *data)
-{
- vc_auth_state_changed_cb callback = NULL;
- void* user_data;
-
- vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
-
- vc_auth_state_e before = -1;
- vc_auth_state_e current = -1;
-
- vc_client_get_before_auth_state(g_vc, &before, ¤t);
-
- if (NULL != callback) {
- vc_client_use_callback(g_vc);
- callback(before, current, user_data);
- vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
- }
-
- return EINA_FALSE;
-
-
-}
-
#if 0
-static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
-{
+static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
+{
Ecore_X_Event_Window_Focus_In *e;
e = event;
}
if (VC_AUTH_STATE_INVALID == state) {
vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
-
+
/* notify auth changed cb */
ecore_timer_add(0, __notify_auth_changed_cb, NULL);
}
}
return ECORE_CALLBACK_PASS_ON;
-}
+}
-static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
-{
+static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
+{
Ecore_X_Event_Window_Focus_In *e;
e = event;
}
#endif
-static void __vc_fork_vc_daemon()
-{
- int pid, i;
- pid = fork();
-
- switch(pid) {
- case -1:
- SLOG(LOG_ERROR, TAG_VCC, "Fail to create daemon");
- break;
- case 0:
- setsid();
- for (i = 0;i < _NSIG;i++)
- signal(i, SIG_DFL);
-
- execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
- break;
- default:
- break;
- }
- return;
-}
-
static Eina_Bool __vc_connect_daemon(void *data)
{
/* Send hello */
if (0 != vc_dbus_request_hello()) {
- if (false == g_is_daemon_started) {
- g_is_daemon_started = true;
- __vc_fork_vc_daemon();
- }
return EINA_TRUE;
}
/* request initialization */
int ret = -1;
int mgr_pid = -1;
- ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid);
+ int service_state = 0;
+ ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
/* Success to connect */
}
- g_connect_timer = NULL;
+ /* Set service state */
+ vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
+ g_connect_timer = NULL;
#if 0
g_focus_in_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, __vc_x_event_window_focus_in, NULL);
g_focus_out_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, __vc_x_event_window_focus_out, NULL);
return EINA_FALSE;
}
-int vc_prepare()
+int vc_prepare(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
vc_state_e state;
return VC_ERROR_INVALID_STATE;
}
- g_is_daemon_started = false;
-
g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return VC_ERROR_NONE;
}
-int vc_unprepare()
+int vc_unprepare(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
vc_state_e state;
int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
if (NULL == callback) {
int vc_get_current_language(char** language)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
if (NULL == language) {
int vc_get_state(vc_state_e* state)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
if (NULL == state) {
*state = temp;
- switch(*state) {
+ switch (*state) {
case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
int vc_get_service_state(vc_service_state_e* state)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
if (NULL == state) {
*state = service_state;
- switch(*state) {
- case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
- case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
- case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
- case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
- default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
+ switch (*state) {
+ case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
+ case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
+ case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
+ case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
+ default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
}
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return VC_ERROR_NONE;
}
-#if 0
+#if 0
int vc_set_window_id(int wid)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Window id");
*
* @pre The state should be #VC_STATE_READY.
*/
-#if 0
+#if 0
int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
#endif
int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
-{
+{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
SLOG(LOG_DEBUG, TAG_VCC, " ");
- return VC_ERROR_INVALID_STATE;
+ return VC_ERROR_INVALID_PARAMETER;
}
vc_cmd_list_s* list = NULL;
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
}
SLOG(LOG_DEBUG, TAG_VCC, "=====");
int vc_unset_command_list(int type)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
vc_state_e state;
int vc_set_exclusive_command_option(bool value)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
vc_state_e state;
return ret;
}
-int vc_request_stop()
+int vc_request_stop(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
return ret;
}
-int vc_request_cancel()
+int vc_request_cancel(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
} else {
SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
- }
+ }
return EINA_FALSE;
}
int __vc_cb_error(int pid, int reason)
{
if (0 != vc_client_get_handle(pid, &g_vc)) {
- SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid");
+ SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
return -1;
}
callback(event, vc_cmd_list, temp_text, user_data);
vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
+ SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
vc_cmd_list_destroy(vc_cmd_list, true);
return EINA_FALSE;
}
-void __vc_cb_result()
+void __vc_cb_result(int pid)
{
+ if (0 != vc_client_get_handle(pid, &g_vc)) {
+ SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
+ return;
+ }
+
ecore_timer_add(0, __vc_notify_result, NULL);
return;
int vc_set_result_cb(vc_result_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
}
vc_client_set_result_cb(g_vc, callback, user_data);
-
+
return 0;
}
-int vc_unset_result_cb()
+int vc_unset_result_cb(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
return 0;
}
+int __vc_cb_service_state(int state)
+{
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_client_get_service_state(g_vc, &before_state);
+
+ if (current_state == before_state) {
+ return 0;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
+
+ /* Save service state */
+ vc_client_set_service_state(g_vc, current_state);
+
+ vc_service_state_changed_cb callback = NULL;
+ void* service_user_data;
+ vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_client_use_callback(g_vc);
+ callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ vc_client_not_use_callback(g_vc);
+ SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
+ }
+
+ return 0;
+}
+
int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
}
vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
-
+
return 0;
}
-int vc_unset_service_state_changed_cb()
+int vc_unset_service_state_changed_cb(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
if (callback == NULL)
return VC_ERROR_INVALID_PARAMETER;
return 0;
}
-int vc_unset_state_changed_cb()
+int vc_unset_state_changed_cb(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
return 0;
}
-int vc_unset_current_language_changed_cb()
+int vc_unset_current_language_changed_cb(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
int vc_set_error_cb(vc_error_cb callback, void* user_data)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
return 0;
}
-int vc_unset_error_cb()
+int vc_unset_error_cb(void)
{
+ if (0 != __vc_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
}
/* Authority */
-int vc_auth_enable()
+int vc_auth_enable(void)
{
/* check state */
vc_state_e state;
ecore_timer_add(0, __notify_auth_changed_cb, NULL);
SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
-
+
return VC_ERROR_NONE;
}
-int vc_auth_disable()
+int vc_auth_disable(void)
{
/* check state */
vc_state_e state;
*state = temp;
SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
-
+
return VC_ERROR_NONE;
}
return VC_ERROR_NONE;
}
-int vc_auth_unset_state_changed_cb()
+int vc_auth_unset_state_changed_cb(void)
{
/* check auth */
vc_auth_state_e auth_state;
return VC_ERROR_NONE;
}
-int vc_auth_start()
+int vc_auth_start(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
return ret;
}
-int vc_auth_stop()
+int vc_auth_stop(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
return ret;
}
-int vc_auth_cancel()
+int vc_auth_cancel(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
projects / platform / core / uifw / voice-control.git / blobdiff