/*
-* Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd All Rights Reserved
+* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
/*
* Dbus Client-Daemon Server
-*/
+*/
int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
{
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
-
if (NULL != reply) {
if (!dbus_connection_send(conn, reply, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
int pid;
int uid;
bool silence_supported = false;
- bool profanity_supported = false;
- bool punctuation_supported = false;
+ bool credential_needed = false;
int ret = STTD_ERROR_OPERATION_FAILED;
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INT32, &uid,
DBUS_TYPE_INVALID);
-
+
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt initialize : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
- ret = sttd_server_initialize(pid, uid, &silence_supported, &profanity_supported, &punctuation_supported);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
+ ret = sttd_server_initialize(pid, uid, &silence_supported, &credential_needed);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
+ int int_silence_supported = (int)silence_supported;
+ int int_credential_needed = (int)credential_needed;
+
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_INT32, &silence_supported,
- DBUS_TYPE_INT32, &profanity_supported,
- DBUS_TYPE_INT32, &punctuation_supported,
+ DBUS_TYPE_INT32, &int_silence_supported,
+ DBUS_TYPE_INT32, &int_credential_needed,
DBUS_TYPE_INVALID);
+
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), profanity(%d), punctuation(%d)",
- ret, silence_supported, profanity_supported, punctuation_supported);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
+ ret, silence_supported, credential_needed);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
ret = sttd_server_finalize(uid);
}
DBusMessage* reply;
-
+
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- GList* lang_list = NULL;
+ GSList* engine_list = NULL;
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported engines");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported engines : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
- ret = sttd_server_get_supported_languages(uid, &lang_list);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
+ ret = sttd_server_get_supported_engines(uid, &engine_list);
}
DBusMessage* reply;
if (NULL != reply) {
DBusMessageIter args;
+
dbus_message_iter_init_append(reply, &args);
/* Append result*/
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
if (0 == ret) {
- /* Append language size */
- int size = g_list_length(lang_list);
-
+ /* Append size */
+ int size = g_slist_length(engine_list);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- GList *iter = NULL;
- char* temp_lang;
+ GSList *iter = NULL;
+ engine_s* engine;
- iter = g_list_first(lang_list);
+ iter = g_slist_nth(engine_list, 0);
while (NULL != iter) {
- temp_lang = iter->data;
+ engine = iter->data;
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
-
- if (NULL != temp_lang)
- free(temp_lang);
-
- lang_list = g_list_remove_link(lang_list, iter);
+ if (NULL != engine) {
+ if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
+ SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
+ engine->engine_id, engine->engine_name, engine->ug_name);
+
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name));
+ /* dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name)); */
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
+ }
+
+ if (NULL != engine->engine_id) {
+ free(engine->engine_id);
+ engine->engine_id = NULL;
+ }
+ if (NULL != engine->engine_name) {
+ free(engine->engine_name);
+ engine->engine_name = NULL;
+ }
+ if (NULL != engine->ug_name) {
+ free(engine->ug_name);
+ engine->ug_name = NULL;
+ }
- iter = g_list_first(lang_list);
- }
+ free(engine);
+ engine = NULL;
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
+ }
+
+ engine_list = g_slist_remove_link(engine_list, iter);
+
+ iter = g_slist_nth(engine_list, 0);
+ }
}
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
-
+
if (!dbus_connection_send(conn, reply, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
}
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
- char* lang;
+ char* engine_id;
+ bool silence_supported = false;
+ bool credential_needed = false;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_STRING, &engine_id,
+ DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set current engine");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set current engine : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
- ret = sttd_server_get_current_langauage(uid, &lang);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
+ ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- if (0 == ret) {
- /* Append result and language */
- dbus_message_append_args( reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_STRING, &lang,
- DBUS_TYPE_INVALID);
+ int int_silence_supported = (int)silence_supported;
+ int int_credential_needed = (int)credential_needed;
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &int_silence_supported,
+ DBUS_TYPE_INT32, &int_credential_needed,
+ DBUS_TYPE_INVALID);
- if (NULL != lang) {
- g_free(lang);
- }
+ if (0 == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
+ ret, silence_supported, credential_needed);
} else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
-
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_is_partial_result_supported(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
- int support = -1;
+ char* engine = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is partial result supported");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get current engine");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is partial result supported : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get current engine : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is partial result supported : uid(%d)", uid);
- ret = sttd_server_is_partial_result_supported(uid, &support);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
+ ret = sttd_server_get_current_engine(uid, &engine);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- /* Append result and language */
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_INT32, &support,
- DBUS_TYPE_INVALID);
-
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_STRING, &engine,
+ DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
+ if (NULL != engine) free(engine);
+
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
- char* lang;
- char* type;
- int profanity;
- int punctuation;
- int silence;
+ char* appid;
int ret = STTD_ERROR_OPERATION_FAILED;
+ bool available = false;
- dbus_message_get_args(msg, &err,
+ dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_STRING, &lang,
- DBUS_TYPE_STRING, &type,
- DBUS_TYPE_INT32, &profanity,
- DBUS_TYPE_INT32, &punctuation,
- DBUS_TYPE_INT32, &silence,
+ DBUS_TYPE_STRING, &appid,
DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt Is engine available : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), profanity(%d), punctuation(%d), silence(%d)"
- , uid, lang, type, profanity, punctuation, silence);
- ret = sttd_server_start(uid, lang, type, profanity, punctuation, silence);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
+ ret = sttd_server_check_app_agreed(uid, appid, &available);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &available,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
+ GSList* lang_list = NULL;
+
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
- ret = sttd_server_stop(uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
+ ret = sttd_server_get_supported_languages(uid, &lang_list);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ DBusMessageIter args;
+ dbus_message_iter_init_append(reply, &args);
+
+ /* Append result*/
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ /* Append language size */
+ int size = g_slist_length(lang_list);
+
+ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
+ ret = STTD_ERROR_OPERATION_FAILED;
+ } else {
+ GSList *iter = NULL;
+ char* temp_lang;
+
+ iter = g_slist_nth(lang_list, 0);
+
+ while (NULL != iter) {
+ temp_lang = iter->data;
+
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang));
+
+ if (NULL != temp_lang)
+ free(temp_lang);
+
+ lang_list = g_slist_remove_link(lang_list, iter);
+
+ iter = g_slist_nth(lang_list, 0);
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
+ char* lang = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
+
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
- ret = sttd_server_cancel(uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
+ ret = sttd_server_get_current_langauage(uid, &lang);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
-
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_STRING, &lang,
+ DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
+ if (NULL != lang) free(lang);
+
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-int sttd_dbus_server_start_file_recognition(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_set_private_data(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
int uid;
- char* filepath;
- char* lang;
- char* type;
- int profanity;
- int punctuation;
+ char* key;
+ char* data;
int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_STRING, &filepath,
- DBUS_TYPE_STRING, &lang,
- DBUS_TYPE_STRING, &type,
- DBUS_TYPE_INT32, &profanity,
- DBUS_TYPE_INT32, &punctuation,
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_STRING, &key,
+ DBUS_TYPE_STRING, &data,
DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start File Recognition");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set private data");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start file recognition : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set private data : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file recognition : uid(%d), filepath(%s), lang(%s), type(%s), profanity(%d), punctuation(%d)"
- , uid, filepath, lang, type, profanity, punctuation);
-
- ret = sttd_server_start_file_recognition(uid, filepath, lang, type,profanity, punctuation);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
+ ret = sttd_server_set_private_data(uid, key, data);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-/*
-* Dbus Setting-Daemon Server
-*/
-
-int sttd_dbus_server_setting_initialize(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
+ int uid;
+ char* key = NULL;
+ char* data = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
-
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_STRING, &key,
DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Initialize");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting initializie : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting initializie : uid(%d)", pid);
- ret = sttd_server_setting_initialize(pid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
+ ret = sttd_server_get_private_data(uid, key, &data);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ /* Append result and private data */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_STRING, &data,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
}
+
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
+ if (NULL != data) free(data);
+
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-int sttd_dbus_server_setting_finalize(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
+ int uid;
+ char* type = NULL;
+ int support = -1;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Finalize");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting finalize : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is recognition type supported : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting finalize : uid(%d)", pid);
- ret = sttd_server_setting_finalize(pid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
+ ret = sttd_server_is_recognition_type_supported(uid, type, &support);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &support,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_get_engine_list(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- GList* engine_list = NULL;
+ int uid;
+ char* file = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine List");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine list : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set start sound : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine list : uid(%d)", pid);
- ret = sttd_server_setting_get_engine_list(pid, &engine_list);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
+ ret = sttd_server_set_start_sound(uid, file);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- DBusMessageIter args;
-
- dbus_message_iter_init_append(reply, &args);
-
- /* Append result*/
- dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- /* Append size */
- int size = g_list_length(engine_list);
- if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
- ret = STTD_ERROR_OPERATION_FAILED;
- } else {
- GList *iter = NULL;
- engine_s* engine;
-
- iter = g_list_first(engine_list);
-
- while (NULL != iter) {
- engine = iter->data;
-
- if (NULL != engine) {
-
- if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
- SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
- engine->engine_id, engine->engine_name, engine->ug_name);
-
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id) );
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name) );
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name) );
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
- }
-
- if (NULL != engine->engine_id)
- g_free(engine->engine_id);
- if (NULL != engine->engine_name)
- g_free(engine->engine_name);
- if (NULL != engine->ug_name)
- g_free(engine->ug_name);
-
- g_free(engine);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
- }
-
- engine_list = g_list_remove_link(engine_list, iter);
-
- iter = g_list_first(engine_list);
- }
- }
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_get_engine(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- char* engine_id;
+ int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset start sound");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset start sound : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine : uid(%d)", pid);
- ret = sttd_server_setting_get_engine(pid, &engine_id);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
+ ret = sttd_server_set_start_sound(uid, NULL);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- if (0 == ret) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &engine_id, DBUS_TYPE_INVALID);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Engine id(%s)", ret, engine_id);
- g_free(engine_id);
+ if (0 == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_set_engine(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- char* engine_id;
+ int uid;
+ char* file = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &engine_id,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set stop sound : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine : uid(%d)", pid);
- ret = sttd_server_setting_set_engine(pid, engine_id);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
+ ret = sttd_server_set_stop_sound(uid, file);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
+ SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_get_language_list(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- GList* lang_list = NULL;
- char* engine_id;
+ int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Language List");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset stop sound");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get language list : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset stop sound : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get language list : uid(%d)", pid);
- ret = sttd_server_setting_get_lang_list(pid, &engine_id, &lang_list);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
+ ret = sttd_server_set_stop_sound(uid, NULL);
}
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- DBusMessageIter args;
- dbus_message_iter_init_append(reply, &args);
-
- /* Append result*/
- dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &ret);
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id));
-
- int size = g_list_length(lang_list);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT DEBUG] Count(%d) ", size);
-
- /* Append size */
- if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
- ret = STTD_ERROR_OPERATION_FAILED;
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
- } else {
- GList *iter = NULL;
- char* temp_lang;
-
- iter = g_list_first(lang_list);
-
- while (NULL != iter) {
- temp_lang = iter->data;
-
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
-
- if (NULL != temp_lang)
- free(temp_lang);
-
- lang_list = g_list_remove_link(lang_list, iter);
-
- iter = g_list_first(lang_list);
- }
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
- }
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_get_default_language(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- char* language;
+ int uid;
+ char* lang;
+ char* type;
+ char* appid;
+ int silence;
+ char* credential;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_STRING, &lang,
+ DBUS_TYPE_STRING, &type,
+ DBUS_TYPE_INT32, &silence,
+ DBUS_TYPE_STRING, &appid,
+ DBUS_TYPE_STRING, &credential,
DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Default Language");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get default language : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get default language : uid(%d)", pid);
- ret = sttd_server_setting_get_default_language(pid, &language);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
+ , uid, lang, type, silence, appid, credential);
+ ret = sttd_server_start(uid, lang, type, silence, appid, credential);
}
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (0 == ret) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &language, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Default Language(%s)", ret, language);
- free(language);
- } else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
- }
-
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_setting_set_default_language(DBusConnection* conn, DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int pid;
- char* language;
- int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &language,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Default Language");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set default language : get arguments error (%s)", err.message);
- dbus_error_free(&err);
- ret = STTD_ERROR_OPERATION_FAILED;
- } else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set default language : uid(%d), language(%s)", pid, language);
- ret = sttd_server_setting_set_default_language(pid, language);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
}
+#if 0
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
+#endif
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-int sttd_dbus_server_setting_get_profanity_filter(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- bool value;
+ int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Profanity Filter");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get profanity filter : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get profanity filter : uid(%d)", pid);
- ret = sttd_server_setting_get_profanity_filter(pid, &value);
- }
-
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (0 == ret) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
- } else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
+ ret = sttd_server_stop(uid);
}
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_setting_set_profanity_filter(DBusConnection* conn, DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int pid;
- bool value;
- int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &value,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set profanity filter : get arguments error (%s)", err.message);
- dbus_error_free(&err);
- ret = STTD_ERROR_OPERATION_FAILED;
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set profanity filter : uid(%d), value(%s)", pid, value ? "true":"false");
- ret = sttd_server_setting_set_profanity_filter(pid, (bool)value);
- }
-
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
-
- if (NULL != reply) {
- if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
}
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
-
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_setting_get_punctuation_override(DBusConnection* conn, DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int pid;
- bool value;
- int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Punctuation Override");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get punctuation override : get arguments error (%s)", err.message);
- dbus_error_free(&err);
- ret = STTD_ERROR_OPERATION_FAILED;
- } else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get punctuation override : uid(%d)", pid);
- ret = sttd_server_setting_get_punctuation_override(pid, &value);
- }
-
+#if 0
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- if (0 == ret) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
- } else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- return -1;
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
- }
-
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_setting_set_punctuation_override(DBusConnection* conn, DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int pid;
- bool value;
- int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &value,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set punctuation override : get arguments error (%s)", err.message);
- dbus_error_free(&err);
- ret = STTD_ERROR_OPERATION_FAILED;
- } else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set punctuation override : uid(%d), value(%s)", pid, value ? "true":"false");
- ret = sttd_server_setting_set_punctuation_override(pid, value);
- }
-
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- if (NULL != reply) {
- if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- return -1;
}
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
+#endif
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-int sttd_dbus_server_setting_get_silence_detection(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- bool value;
+ int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Silence Detection");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get silence detection : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get silence detection : uid(%d)", pid);
- ret = sttd_server_setting_get_silence_detection(pid, &value);
- }
-
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (0 == ret) {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , Value(%s)", ret, value ? "true":"false");
- } else {
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- return -1;
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
+ ret = sttd_server_cancel(uid);
}
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_setting_set_silence_detection(DBusConnection* conn, DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int pid;
- bool value;
- int ret = STTD_ERROR_OPERATION_FAILED;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &value,
- DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Silence Detection");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set silence detection : get arguments error (%s)", err.message);
- dbus_error_free(&err);
- ret = STTD_ERROR_OPERATION_FAILED;
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set silence detection : uid(%d), value(%s)", pid, value ? "true":"false");
- ret = sttd_server_setting_set_silence_detection(pid, value);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
}
-
+#if 0
DBusMessage* reply;
reply = dbus_message_new_method_return(msg);
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
-
if (NULL != reply) {
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
}
if (!dbus_connection_send(conn, reply, NULL)) {
dbus_connection_flush(conn);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
}
-
+#endif
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return 0;
}
-
-int sttd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_start_file(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- char* engine_id;
- GList* engine_setting_list = NULL;
+ int uid;
+ char* lang;
+ char* type;
+ char* appid;
+ int silence;
+ char* credential;
+ char* filepath;
+ stte_audio_type_e audio_type;
+ int sample_rate;
+
int ret = STTD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_STRING, &lang,
+ DBUS_TYPE_STRING, &type,
+ DBUS_TYPE_INT32, &silence,
+ DBUS_TYPE_STRING, &appid,
+ DBUS_TYPE_STRING, &credential,
+ DBUS_TYPE_STRING, &filepath,
+ DBUS_TYPE_INT32, &audio_type,
+ DBUS_TYPE_INT32, &sample_rate,
DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine Setting");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start File");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine setting : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start file: get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine setting : uid(%d)", pid);
- ret = sttd_server_setting_get_engine_setting(pid, &engine_id, &engine_setting_list);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) filepath(%s), audio_type(%d), sample_rate(%d)"
+ , uid, lang, type, silence, appid, filepath, audio_type, sample_rate);
+ ret = sttd_server_start_file(uid, lang, type, silence, appid, credential, filepath, audio_type, sample_rate);
}
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- DBusMessageIter args;
- dbus_message_iter_init_append(reply, &args);
-
- /* Append result*/
- dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
-
- if (0 == ret) {
- if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
- ret = STTD_ERROR_OPERATION_FAILED;
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to add engine id");
- } else {
- if (NULL != engine_id) free(engine_id);
-
- /* Append size */
- int size = g_list_length(engine_setting_list);
- if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
- ret = STTD_ERROR_OPERATION_FAILED;
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] setting get engine setting : result(%d)", ret);
- } else {
- GList *iter = NULL;
- engine_setting_s* setting;
-
- iter = g_list_first(engine_setting_list);
-
- while (NULL != iter) {
- setting = iter->data;
-
- if (NULL != setting) {
- if (NULL != setting->key && NULL != setting->value) {
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->key) );
- dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->value) );
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
- }
-
- if (NULL != setting->key)
- g_free(setting->key);
- if (NULL != setting->value)
- g_free(setting->value);
-
- g_free(setting);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
- }
-
- engine_setting_list = g_list_remove_link(engine_setting_list, iter);
-
- iter = g_list_first(engine_setting_list);
- }
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] setting engine setting list : result(%d) \n", ret);
- }
- }
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start file")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
}
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
return 0;
}
-int sttd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg)
+int sttd_dbus_server_cancel_file(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
dbus_error_init(&err);
- int pid;
- char* key;
- char* value;
+ int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &key,
- DBUS_TYPE_STRING, &value,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine Setting");
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel File");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine setting : get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel file : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine setting : uid(%d), key(%s), value(%s)", pid, key, value);
- ret = sttd_server_setting_set_engine_setting(pid, key, value);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel file : uid(%d)", uid);
+ ret = sttd_server_cancel_file(uid);
}
- DBusMessage* reply;
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
-
- if (NULL != reply) {
- if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- }
-
- if (!dbus_connection_send(conn, reply, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
- }
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ if (0 <= ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
} else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
- }
-
- SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
- SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return 0;
-}
-
-int sttd_dbus_server_stop_by_daemon(DBusMessage* msg)
-{
- DBusError err;
- dbus_error_init(&err);
-
- int uid;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_INVALID);
-
- SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Stop by daemon");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] sttd stop by daemon : Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- } else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] sttd stop by daemon : uid(%d)", uid);
- sttd_server_stop(uid);
-
- /* check silence detection option from config */
- int ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
- if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
- /* Remove client */
- sttd_server_finalize(uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
}
}
-
SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
SLOG(LOG_DEBUG, TAG_STTD, " ");
projects / platform / core / uifw / stt.git / blobdiff