volatile static bool g_is_recording = false;
-static bool __convert_audio_channel(int channel, audio_channel_e* output)
+static bool convert_audio_channel(int channel, audio_channel_e* output)
{
audio_channel_e audio_ch = AUDIO_CHANNEL_MONO;
return true;
}
-static bool __convert_audio_sample_type(vce_audio_type_e audio_type, audio_sample_type_e* output)
+static bool convert_audio_sample_type(vce_audio_type_e audio_type, audio_sample_type_e* output)
{
audio_sample_type_e audio_sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
return true;
}
-static Eina_Bool __recorder_timer_func(void *data)
+static Eina_Bool recorder_timer_func(void *data)
{
const int FRAME_LENGTH = 160;
const int BUFFER_LENGTH = FRAME_LENGTH * 2;
audio_channel_e audio_ch = AUDIO_CHANNEL_MONO;
audio_sample_type_e audio_sample_type = AUDIO_SAMPLE_TYPE_U8;
- if (false == __convert_audio_channel(g_audio_channel, &audio_ch)) {
+ if (false == convert_audio_channel(g_audio_channel, &audio_ch)) {
return VCE_ERROR_INVALID_PARAMETER;
}
- if (false == __convert_audio_sample_type(g_audio_type, &audio_sample_type)) {
+ if (false == convert_audio_sample_type(g_audio_type, &audio_sample_type)) {
return VCE_ERROR_INVALID_PARAMETER;
}
audio_channel_e audio_ch = AUDIO_CHANNEL_MONO;
audio_sample_type_e audio_sample_type = AUDIO_SAMPLE_TYPE_U8;
- if (false == __convert_audio_channel(channel, &audio_ch)) {
+ if (false == convert_audio_channel(channel, &audio_ch)) {
return VCE_ERROR_INVALID_PARAMETER;
}
- if (false == __convert_audio_sample_type(type, &audio_sample_type)) {
+ if (false == convert_audio_sample_type(type, &audio_sample_type)) {
return VCE_ERROR_INVALID_PARAMETER;
}
/* Add ecore timer to read audio data */
ecore_main_loop_thread_safe_call_async([](void* data)->void
{
- ecore_timer_add(0, __recorder_timer_func, NULL);
+ ecore_timer_add(0, recorder_timer_func, NULL);
},
NULL);
static bool g_is_created = false;
-static const char *__get_ducking_stream(sound_stream_type_e stream_type)
+static const char *get_ducking_stream(sound_stream_type_e stream_type)
{
if (SOUND_STREAM_TYPE_MEDIA == stream_type)
return "Media stream";
return "Non matched stream";
}
-static sound_stream_ducking_h __create_ducking_handle(sound_stream_type_e type)
+static sound_stream_ducking_h create_ducking_handle(sound_stream_type_e type)
{
sound_stream_ducking_h ducking_handle = nullptr;
return ducking_handle;
}
-static void __destroy_ducking_handle(sound_stream_ducking_h ducking_handle)
+static void destroy_ducking_handle(sound_stream_ducking_h ducking_handle)
{
if (nullptr == ducking_handle) {
return;
SLOG(LOG_WARN, TAG_VCM, "Destroy ducking handle DONE. ret(%d/%s)", ret, get_error_message(ret));
}
-static bool __is_all_ducking_handle_valid()
+static bool is_all_ducking_handle_valid()
{
if (nullptr == g_media_stream_h || nullptr == g_system_stream_h || nullptr == g_notification_stream_h ||
nullptr == g_alarm_stream_h || nullptr == g_voice_information_stream_h) {
return true;
}
-static void __destroy_all_ducking_handle()
+static void destroy_all_ducking_handle()
{
- __destroy_ducking_handle(g_media_stream_h);
- __destroy_ducking_handle(g_system_stream_h);
- __destroy_ducking_handle(g_notification_stream_h);
- __destroy_ducking_handle(g_alarm_stream_h);
- __destroy_ducking_handle(g_voice_information_stream_h);
+ destroy_ducking_handle(g_media_stream_h);
+ destroy_ducking_handle(g_system_stream_h);
+ destroy_ducking_handle(g_notification_stream_h);
+ destroy_ducking_handle(g_alarm_stream_h);
+ destroy_ducking_handle(g_voice_information_stream_h);
g_media_stream_h = nullptr;
g_system_stream_h = nullptr;
return VC_ERROR_NONE;
}
- g_media_stream_h = __create_ducking_handle(SOUND_STREAM_TYPE_MEDIA);
- g_system_stream_h = __create_ducking_handle(SOUND_STREAM_TYPE_SYSTEM);
- g_notification_stream_h = __create_ducking_handle(SOUND_STREAM_TYPE_NOTIFICATION);
- g_alarm_stream_h = __create_ducking_handle(SOUND_STREAM_TYPE_ALARM);
- g_voice_information_stream_h = __create_ducking_handle(SOUND_STREAM_TYPE_VOICE_INFORMATION);
+ g_media_stream_h = create_ducking_handle(SOUND_STREAM_TYPE_MEDIA);
+ g_system_stream_h = create_ducking_handle(SOUND_STREAM_TYPE_SYSTEM);
+ g_notification_stream_h = create_ducking_handle(SOUND_STREAM_TYPE_NOTIFICATION);
+ g_alarm_stream_h = create_ducking_handle(SOUND_STREAM_TYPE_ALARM);
+ g_voice_information_stream_h = create_ducking_handle(SOUND_STREAM_TYPE_VOICE_INFORMATION);
- if (false == __is_all_ducking_handle_valid()) {
- __destroy_all_ducking_handle();
+ if (false == is_all_ducking_handle_valid()) {
+ destroy_all_ducking_handle();
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create ducking handles");
return VC_ERROR_OPERATION_FAILED;
}
int vc_mgr_ducking_destroy(void)
{
- __destroy_all_ducking_handle();
+ destroy_all_ducking_handle();
g_is_created = false;
return VC_ERROR_NONE;
}
-static int __activate_ducking_sound_stream(sound_stream_type_e type, sound_stream_ducking_h header, double ratio)
+static int activate_ducking_sound_stream(sound_stream_type_e type, sound_stream_ducking_h header, double ratio)
{
bool is_ducked = false;
int ret = SOUND_MANAGER_ERROR_NONE;
ret = sound_manager_is_ducked(header, &is_ducked);
if (is_ducked) {
- SLOG(LOG_DEBUG, TAG_VCM, "The %s is already ducked", __get_ducking_stream(type));
+ SLOG(LOG_DEBUG, TAG_VCM, "The %s is already ducked", get_ducking_stream(type));
return ret;
}
ret = sound_manager_activate_ducking(header, SND_MGR_DUCKING_DURATION, ratio);
if (SOUND_MANAGER_ERROR_NONE != ret)
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to activate ducking for %s", __get_ducking_stream(type));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to activate ducking for %s", get_ducking_stream(type));
else
- SLOG(LOG_INFO, TAG_VCM, "Activate ducking for %s", __get_ducking_stream(type));
+ SLOG(LOG_INFO, TAG_VCM, "Activate ducking for %s", get_ducking_stream(type));
return ret;
}
SLOG(LOG_INFO, TAG_VCM, "vc_mgr_ducking_activate ratio(%lf)", ratio);
int ret = VC_ERROR_NONE;
- ret = __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_h, ratio);
+ ret = activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_h, ratio);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_h, ratio);
+ ret = activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_h, ratio);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_h, ratio);
+ ret = activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_h, ratio);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_h, ratio);
+ ret = activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_h, ratio);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __activate_ducking_sound_stream(SOUND_STREAM_TYPE_VOICE_INFORMATION, g_voice_information_stream_h, ratio);
+ ret = activate_ducking_sound_stream(SOUND_STREAM_TYPE_VOICE_INFORMATION, g_voice_information_stream_h, ratio);
return ret;
}
-static int __deactivate_ducking_sound_stream(sound_stream_type_e type, sound_stream_ducking_h header)
+static int deactivate_ducking_sound_stream(sound_stream_type_e type, sound_stream_ducking_h header)
{
bool is_ducked = false;
int ret = SOUND_MANAGER_ERROR_NONE;
ret = sound_manager_is_ducked(header, &is_ducked);
if (false == is_ducked) {
- SLOG(LOG_DEBUG, TAG_VCM, "The %s is already recovered from ducking", __get_ducking_stream(type));
+ SLOG(LOG_DEBUG, TAG_VCM, "The %s is already recovered from ducking", get_ducking_stream(type));
return ret;
}
ret = sound_manager_deactivate_ducking(header);
if (SOUND_MANAGER_ERROR_NONE != ret)
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to deactivate ducking for %s", __get_ducking_stream(type));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to deactivate ducking for %s", get_ducking_stream(type));
else
- SLOG(LOG_INFO, TAG_VCM, "Deactivate ducking for %s", __get_ducking_stream(type));
+ SLOG(LOG_INFO, TAG_VCM, "Deactivate ducking for %s", get_ducking_stream(type));
return ret;
}
SLOG(LOG_INFO, TAG_VCM, "vc_mgr_ducking_deactivate");
int ret = VC_ERROR_NONE;
- ret = __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_h);
+ ret = deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_h);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_h);
+ ret = deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_h);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_h);
+ ret = deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_h);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_h);
+ ret = deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_h);
if (SOUND_MANAGER_ERROR_NONE != ret)
return ret;
- ret = __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_VOICE_INFORMATION, g_voice_information_stream_h);
+ ret = deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_VOICE_INFORMATION, g_voice_information_stream_h);
return ret;
}
VoiceControlClientInfo::VoiceControlClientInfo(unsigned int uid)
{
SLOG(LOG_INFO, TAG_VCCONFIG, "[Constructor] VoiceControlClientInfo");
- __engineChangedCallback = nullptr;
- __languageChangedCallback = nullptr;
- __enabledChangedCallback = nullptr;
- __uid = uid;
+ mEngineChangedCallback = nullptr;
+ mLanguageChangedCallback = nullptr;
+ mEnabledChangedCallback = nullptr;
+ mUid = uid;
}
VoiceControlClientInfo::~VoiceControlClientInfo()
{
SLOG(LOG_INFO, TAG_VCCONFIG, "[Destructor] VoiceControlClientInfo");
- __engineChangedCallback = nullptr;
- __languageChangedCallback = nullptr;
- __enabledChangedCallback = nullptr;
- __uid = 0;
+ mEngineChangedCallback = nullptr;
+ mLanguageChangedCallback = nullptr;
+ mEnabledChangedCallback = nullptr;
+ mUid = 0;
}
unsigned int VoiceControlClientInfo::getUid()
{
- return __uid;
+ return mUid;
}
void VoiceControlClientInfo::setEngineChangedCallback(vc_config_engine_changed_cb callback)
{
- __engineChangedCallback = callback;
+ mEngineChangedCallback = callback;
}
void VoiceControlClientInfo::invokeEngineChangedCallback(const char *engine_appid)
{
- if (__engineChangedCallback == nullptr) {
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Engine changed callback is not set. uid(%u)", __uid);
+ if (mEngineChangedCallback == nullptr) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Engine changed callback is not set. uid(%u)", mUid);
return;
}
- __engineChangedCallback(engine_appid);
+ mEngineChangedCallback(engine_appid);
}
void VoiceControlClientInfo::setLanguageChangedCallback(vc_config_lang_changed_cb callback)
{
- __languageChangedCallback = callback;
+ mLanguageChangedCallback = callback;
}
void VoiceControlClientInfo::invokeLanguageChangedCallback(const char* before_lang, const char* current_lang)
{
- if (__languageChangedCallback == nullptr) {
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "language changed callback is not set. uid(%u)", __uid);
+ if (mLanguageChangedCallback == nullptr) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "language changed callback is not set. uid(%u)", mUid);
return;
}
- __languageChangedCallback(before_lang, current_lang);
+ mLanguageChangedCallback(before_lang, current_lang);
}
void VoiceControlClientInfo::setEnabledChangedCallback(vc_config_enabled_cb callback)
{
- __enabledChangedCallback = callback;
+ mEnabledChangedCallback = callback;
}
void VoiceControlClientInfo::invokeEnabledChangedCallback(bool enable)
{
- if (__enabledChangedCallback == nullptr) {
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Enabled changed callback is not set. uid(%u)", __uid);
+ if (mEnabledChangedCallback == nullptr) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Enabled changed callback is not set. uid(%u)", mUid);
return;
}
- __enabledChangedCallback(enable);
+ mEnabledChangedCallback(enable);
}
void invokeEnabledChangedCallback(bool enable);
private:
- unsigned int __uid;
- vc_config_engine_changed_cb __engineChangedCallback;
- vc_config_lang_changed_cb __languageChangedCallback;
- vc_config_enabled_cb __enabledChangedCallback;
+ unsigned int mUid;
+ vc_config_engine_changed_cb mEngineChangedCallback;
+ vc_config_lang_changed_cb mLanguageChangedCallback;
+ vc_config_enabled_cb mEnabledChangedCallback;
};
#endif /* __VC_COMMON_VOICE_CONTROL_CLIENT_INFO_H_ */
void VoiceControlClients::printOutClients()
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
SLOG(LOG_DEBUG, TAG_VCCONFIG, "@ Client list @");
- if (0 == __clients.size()) {
+ if (0 == mClients.size()) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, " No Client");
} else {
unsigned int index = 0;
- for (auto &clientInfo : __clients) {
+ for (auto &clientInfo : mClients) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, "[%dth] uid(%u)", index, clientInfo.getUid());
}
}
void VoiceControlClients::appendClient(VoiceControlClientInfo &clientInfo)
{
- unique_lock<mutex> lock(__clientsMutex);
- __clients.push_back(clientInfo);
+ unique_lock<mutex> lock(mClientsMutex);
+ mClients.push_back(clientInfo);
}
std::size_t VoiceControlClients::removeClient(unsigned int uid)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
SLOG(LOG_DEBUG, TAG_VCCONFIG, "Remove client ID (%u)", uid);
- for (auto iter = __clients.begin(); iter != __clients.end(); iter++) {
+ for (auto iter = mClients.begin(); iter != mClients.end(); iter++) {
if (iter->getUid() == uid) {
SLOG(LOG_INFO, TAG_VCCONFIG, "Success to remove client (%u)", uid);
- __clients.erase(iter);
- return __clients.size();
+ mClients.erase(iter);
+ return mClients.size();
}
}
SLOG(LOG_ERROR, TAG_VCCONFIG, "There is no client (%u)", uid);
- return __clients.size();
+ return mClients.size();
}
void VoiceControlClients::setEngineChangedCallback(unsigned int uid, vc_config_engine_changed_cb callback)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
auto clientInfo = findClient(uid);
if (clientInfo == nullptr) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info");
void VoiceControlClients::setLanguageChangedCallback(unsigned int uid, vc_config_lang_changed_cb callback)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
auto clientInfo = findClient(uid);
if (clientInfo == nullptr) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info");
void VoiceControlClients::setEnabledChangedCallback(unsigned int uid, vc_config_enabled_cb callback)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
auto clientInfo = findClient(uid);
if (clientInfo == nullptr) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info");
bool VoiceControlClients::isUidValid(unsigned int uid)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
bool isValid = (nullptr != findClient(uid));
SLOG(LOG_INFO, TAG_VCCONFIG, "Client Id(%u) is %svalid", uid, (isValid ? "" : "not "));
return isValid;
std::shared_ptr<VoiceControlClientInfo> VoiceControlClients::getClientInfo(unsigned int uid)
{
- unique_lock<mutex> lock(__clientsMutex);
+ unique_lock<mutex> lock(mClientsMutex);
SLOG(LOG_INFO, TAG_VCCONFIG, "Get client info with ID(%u)", uid);
auto clientInfo = findClient(uid);
if (clientInfo == nullptr) {
VoiceControlClientInfo *VoiceControlClients::findClient(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_VCCONFIG, "Find client ID (%u)", uid);
- for (auto &clientInfo : __clients) {
+ for (auto &clientInfo : mClients) {
if (clientInfo.getUid() == uid) {
SLOG(LOG_INFO, TAG_VCCONFIG, "Success to find client (%u)", uid);
return &clientInfo;
std::vector<VoiceControlClientInfo> VoiceControlClients::getClients()
{
- unique_lock<mutex> lock(__clientsMutex);
- SLOG(LOG_INFO, TAG_VCCONFIG, "Get clients. size(%zu)", __clients.size());
- return __clients;
+ unique_lock<mutex> lock(mClientsMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get clients. size(%zu)", mClients.size());
+ return mClients;
}
bool VoiceControlClients::isClientEmpty()
{
- unique_lock<mutex> lock(__clientsMutex);
- SLOG(LOG_INFO, TAG_VCCONFIG, "Length of clients (%zu)", __clients.size());
- return __clients.empty();
+ unique_lock<mutex> lock(mClientsMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Length of clients (%zu)", mClients.size());
+ return mClients.empty();
}
private:
VoiceControlClientInfo *findClient(unsigned int uid);
- std::vector<VoiceControlClientInfo> __clients;
- std::mutex __clientsMutex;
+ std::vector<VoiceControlClientInfo> mClients;
+ std::mutex mClientsMutex;
};
VoiceControlConfig::VoiceControlConfig()
{
- unique_lock<mutex> lock(__configMutex);
- __config = nullptr;
+ unique_lock<mutex> lock(mConfigMutex);
+ mConfig = nullptr;
- if (0 != vc_parser_load_config(&__config)) {
+ if (0 != vc_parser_load_config(&mConfig)) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to parse configure information");
throw new runtime_error("Operation failed");
}
VoiceControlConfig::~VoiceControlConfig()
{
- unique_lock<mutex> lock(__configMutex);
- vc_parser_unload_config(__config);
- __config = nullptr;
+ unique_lock<mutex> lock(mConfigMutex);
+ vc_parser_unload_config(mConfig);
+ mConfig = nullptr;
}
void VoiceControlConfig::printOutConfig()
{
- unique_lock<mutex> lock(__configMutex);
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Engine : %s", __config->engine_id);
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Auto lang : %s", __config->auto_lang ? "true" : "false");
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Language : %s", __config->language);
- SLOG(LOG_DEBUG, TAG_VCCONFIG, "Enabled : %s", __config->enabled ? "true" : "false");
+ unique_lock<mutex> lock(mConfigMutex);
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Engine : %s", mConfig->engine_id);
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Auto lang : %s", mConfig->auto_lang ? "true" : "false");
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Language : %s", mConfig->language);
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Enabled : %s", mConfig->enabled ? "true" : "false");
}
void VoiceControlConfig::setEngineId(const std::string engineId)
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return;
}
- free(__config->engine_id);
+ free(mConfig->engine_id);
if (engineId.empty()) {
- __config->engine_id = nullptr;
+ mConfig->engine_id = nullptr;
} else {
- __config->engine_id = strdup(engineId.c_str());
+ mConfig->engine_id = strdup(engineId.c_str());
}
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Engine ID : %s", __config->engine_id);
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Engine ID : %s", mConfig->engine_id);
}
std::string VoiceControlConfig::getEngineId()
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return "";
}
string result;
- if (nullptr != __config->engine_id) {
- result = __config->engine_id;
+ if (nullptr != mConfig->engine_id) {
+ result = mConfig->engine_id;
}
SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Engine ID : %s", result.c_str());
void VoiceControlConfig::setAutoLanguageEnabled(bool isAutoLanguageEnabled)
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return;
}
- __config->auto_lang = isAutoLanguageEnabled;
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Auto language : %s", (__config->auto_lang ? "True" : "False"));
+ mConfig->auto_lang = isAutoLanguageEnabled;
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Auto language : %s", (mConfig->auto_lang ? "True" : "False"));
}
bool VoiceControlConfig::isAutoLanguageEnabled()
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return false;
}
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Auto language : %s", (__config->auto_lang ? "True" : "False"));
- return __config->auto_lang;
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Auto language : %s", (mConfig->auto_lang ? "True" : "False"));
+ return mConfig->auto_lang;
}
void VoiceControlConfig::setCurrentLanguage(const std::string language)
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return;
}
- free(__config->language);
+ free(mConfig->language);
if (language.empty()) {
- __config->language = nullptr;
+ mConfig->language = nullptr;
} else {
- __config->language = strdup(language.c_str());
+ mConfig->language = strdup(language.c_str());
}
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Language : %s", __config->language);
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Language : %s", mConfig->language);
}
std::string VoiceControlConfig::getCurrentLanguage()
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return "";
}
string result;
- if (nullptr != __config->language) {
- result = __config->language;
+ if (nullptr != mConfig->language) {
+ result = mConfig->language;
}
SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Language : %s", result.c_str());
return result;
void VoiceControlConfig::setEnabled(bool isEnabled)
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return;
}
- __config->enabled = isEnabled;
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Enabled : %s", (__config->enabled ? "True" : "False"));
+ mConfig->enabled = isEnabled;
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Set Enabled : %s", (mConfig->enabled ? "True" : "False"));
}
bool VoiceControlConfig::isEnabled()
{
- unique_lock<mutex> lock(__configMutex);
- if (nullptr == __config) {
+ unique_lock<mutex> lock(mConfigMutex);
+ if (nullptr == mConfig) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Config info is NULL");
return false;
}
- SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Enabled : %s", (__config->enabled ? "True" : "False"));
- return __config->enabled;
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "Get Enabled : %s", (mConfig->enabled ? "True" : "False"));
+ return mConfig->enabled;
}
bool isEnabled();
private:
- vc_config_s *__config;
- std::mutex __configMutex;
+ vc_config_s *mConfig;
+ std::mutex mConfigMutex;
};
}
if (engine_info->name) {
- __engineName = engine_info->name;
+ mEngineName = engine_info->name;
}
if (engine_info->uuid) {
- __engineId = engine_info->uuid;
+ mEngineId = engine_info->uuid;
}
if (engine_info->setting) {
- __settingPath = engine_info->setting;
+ mSettingPath = engine_info->setting;
}
if (engine_info->default_lang) {
- __defaultLanguage = engine_info->default_lang;
+ mDefaultLanguage = engine_info->default_lang;
}
- __nonFixedSupported = engine_info->non_fixed_support;
+ mNonFixedSupported = engine_info->non_fixed_support;
GSList *iter = g_slist_nth(engine_info->languages, 0);
while (nullptr != iter) {
const char *language = static_cast<const char *>(iter->data);
if (language != nullptr) {
- __supportedLanguages.push_back(language);
+ mSupportedLanguages.push_back(language);
}
iter = g_slist_next(iter);
void VoiceControlEngineInfo::printOutEngine()
{
- SLOG(LOG_DEBUG, TAG_VCCONFIG, " name : %s", __engineName.c_str());
- SLOG(LOG_DEBUG, TAG_VCCONFIG, " id : %s", __engineId.c_str());
- SLOG(LOG_DEBUG, TAG_VCCONFIG, " setting : %s", __settingPath.c_str());
- SLOG(LOG_DEBUG, TAG_VCCONFIG, " default language : %s", __defaultLanguage.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " name : %s", mEngineName.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " id : %s", mEngineId.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " setting : %s", mSettingPath.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " default language : %s", mDefaultLanguage.c_str());
SLOG(LOG_DEBUG, TAG_VCCONFIG, " languages :");
- if (__supportedLanguages.size() == 0) {
+ if (mSupportedLanguages.size() == 0) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, " language is NONE");
} else {
unsigned int index = 1;
- for (auto &language : __supportedLanguages) {
+ for (auto &language : mSupportedLanguages) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, " [%uth] %s", index, language.c_str());
index++;
}
bool VoiceControlEngineInfo::isLanguageValid(const std::string language)
{
- for (auto &supportedLanguage : __supportedLanguages) {
+ for (auto &supportedLanguage : mSupportedLanguages) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, "Compare language(%s), Target(%s)", supportedLanguage.c_str(), language.c_str());
if (0 == supportedLanguage.compare(language)) {
SLOG(LOG_INFO, TAG_VCCONFIG, "Language(%s) is valid", language.c_str());
std::string VoiceControlEngineInfo::getEngineName()
{
- return __engineName;
+ return mEngineName;
}
std::string VoiceControlEngineInfo::getEngineId()
{
- return __engineId;
+ return mEngineId;
}
std::string VoiceControlEngineInfo::getSettingPath()
{
- return __settingPath;
+ return mSettingPath;
}
std::string VoiceControlEngineInfo::getDefaultLanguage()
{
- return __defaultLanguage;
+ return mDefaultLanguage;
}
std::vector<std::string> VoiceControlEngineInfo::getSupportedLanguages()
{
- return __supportedLanguages;
+ return mSupportedLanguages;
}
bool VoiceControlEngineInfo::isNonFixedSupported()
{
- return __nonFixedSupported;
+ return mNonFixedSupported;
}
bool isNonFixedSupported();
private:
- std::string __engineName;
- std::string __engineId;
- std::string __settingPath;
- std::string __defaultLanguage;
- std::vector<std::string> __supportedLanguages;
- bool __nonFixedSupported;
+ std::string mEngineName;
+ std::string mEngineId;
+ std::string mSettingPath;
+ std::string mDefaultLanguage;
+ std::vector<std::string> mSupportedLanguages;
+ bool mNonFixedSupported;
};
void VoiceControlEngines::printOutEngineInfo()
{
- unique_lock<mutex> lock(__enginesMutex);
+ unique_lock<mutex> lock(mEnginesMutex);
SLOG(LOG_DEBUG, TAG_VCCONFIG, "@ Engine list @");
- if (0 == __engines.size()) {
+ if (0 == mEngines.size()) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, " No Engine in engine directory");
} else {
unsigned int index = 0;
- for (auto &engineInfo : __engines) {
+ for (auto &engineInfo : mEngines) {
SLOG(LOG_DEBUG, TAG_VCCONFIG, "[%uth]", index);
engineInfo.printOutEngine();
}
void VoiceControlEngines::appendEngine(const std::string path)
{
- unique_lock<mutex> lock(__enginesMutex);
+ unique_lock<mutex> lock(mEnginesMutex);
try {
VoiceControlEngineInfo engineInfo(path);
- __engines.push_back(engineInfo);
+ mEngines.push_back(engineInfo);
} catch (runtime_error &error) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to append engine info from path(%s)", path.c_str());
throw error;
return false;
}
- unique_lock<mutex> lock(__enginesMutex);
+ unique_lock<mutex> lock(mEnginesMutex);
bool isValid = (nullptr != findEngine(engineId));
SLOG(LOG_INFO, TAG_VCCONFIG, "Engine Id(%s) is %svalid", engineId.c_str(), (isValid ? "" : "not "));
return isValid;
return nullptr;
}
- unique_lock<mutex> lock(__enginesMutex);
+ unique_lock<mutex> lock(mEnginesMutex);
SLOG(LOG_INFO, TAG_VCCONFIG, "Get engine info with ID(%s)", engineId.c_str());
auto engineInfo = findEngine(engineId);
if (engineInfo == nullptr) {
std::shared_ptr<VoiceControlEngineInfo> VoiceControlEngines::getFirstEngineInfo()
{
- unique_lock<mutex> lock(__enginesMutex);
- if (__engines.size() == 0) {
+ unique_lock<mutex> lock(mEnginesMutex);
+ if (mEngines.size() == 0) {
SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] There is no engine");
return nullptr;
}
- SLOG(LOG_INFO, TAG_VCCONFIG, "Get first engine info. size(%zu)", __engines.size());
- return make_shared<VoiceControlEngineInfo>(__engines[0]);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get first engine info. size(%zu)", mEngines.size());
+ return make_shared<VoiceControlEngineInfo>(mEngines[0]);
}
VoiceControlEngineInfo *VoiceControlEngines::findEngine(const std::string engineId)
}
SLOG(LOG_INFO, TAG_VCCONFIG, "Find engine ID (%s)", engineId.c_str());
- for (auto &engineInfo : __engines) {
+ for (auto &engineInfo : mEngines) {
if (0 == engineInfo.getEngineId().compare(engineId)) {
SLOG(LOG_INFO, TAG_VCCONFIG, "Success to find engine (%s)", engineId.c_str());
return &engineInfo;
std::vector<VoiceControlEngineInfo> VoiceControlEngines::getEngines()
{
- unique_lock<mutex> lock(__enginesMutex);
- SLOG(LOG_INFO, TAG_VCCONFIG, "Get engines. size(%zu)", __engines.size());
- return __engines;
+ unique_lock<mutex> lock(mEnginesMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get engines. size(%zu)", mEngines.size());
+ return mEngines;
}
bool VoiceControlEngines::isEngineEmpty()
{
- unique_lock<mutex> lock(__enginesMutex);
- SLOG(LOG_INFO, TAG_VCCONFIG, "Length of engines (%zu)", __engines.size());
- return __engines.empty();
+ unique_lock<mutex> lock(mEnginesMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Length of engines (%zu)", mEngines.size());
+ return mEngines.empty();
}
private:
VoiceControlEngineInfo *findEngine(const std::string engineId);
- std::vector<VoiceControlEngineInfo> __engines;
- std::mutex __enginesMutex;
+ std::vector<VoiceControlEngineInfo> mEngines;
+ std::mutex mEnginesMutex;
};
static GList* g_ino_list = nullptr;
static mutex g_ino_list_mutex;
-static int __vc_config_mgr_register_engine_config_updated_event(const char* path);
-static int __vc_config_mgr_unregister_engine_config_updated_event();
-static int __vc_config_mgr_set_default_language(const char* language);
+static int register_engine_config_updated_event(const char* path);
+static int unregister_engine_config_updated_event();
+static int set_current_language(const char* language);
-static void __vc_config_mgr_notify_engine_changed(const char *engine_appid)
+static void notify_engine_changed(const char *engine_appid)
{
SLOG(LOG_INFO, vc_config_tag(), "[INFO] Invoke engine changed callback");
if (nullptr == engine_appid) {
}
}
-static void __vc_config_mgr_notify_language_changed(const char* before_lang, const char* current_lang)
+static void notify_language_changed(const char* before_lang, const char* current_lang)
{
SLOG(LOG_INFO, vc_config_tag(), "[INFO] Invoke language changed callback");
if (nullptr == before_lang || nullptr == current_lang) {
}
}
-static void __vc_config_mgr_notify_enabled_changed(bool enable)
+static void notify_enabled_changed(bool enable)
{
SLOG(LOG_INFO, vc_config_tag(), "[INFO] Invoke enabled callback");
auto clients = g_VoiceControlClients->getClients();
}
}
-static int __initialize_config_info()
+static int initialize_config_info()
{
g_VoiceControlConfig = new(nothrow) VoiceControlConfig();
if (nullptr == g_VoiceControlConfig) {
return VC_CONFIG_ERROR_NONE;
}
-static void __finalize_config_info()
+static void finalize_config_info()
{
delete g_VoiceControlConfig;
g_VoiceControlConfig = nullptr;
return VC_CONFIG_ERROR_NONE;
}
-static int __vc_config_mgr_check_and_set_default_engine_id(const char* engine_id)
+static int check_and_set_default_engine_id(const char* engine_id)
{
if (NULL == engine_id) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Input parameter is NULL");
return VC_CONFIG_ERROR_NONE;
}
-static bool __vc_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
+static bool is_language_valid_in_engine(const char* engine_id, const char* language)
{
if (NULL == engine_id || NULL == language) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Input parameter is NULL");
return is_language_valid;
}
-static int __vc_config_mgr_select_lang(const char* engine_id, char** language)
+static int get_default_language_of_engine(const char* engine_id, char** language)
{
if (NULL == engine_id || NULL == language) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Input parameter is NULL");
return VC_CONFIG_ERROR_NONE;
}
-void __vc_config_release_engine()
+static void release_engines_information()
{
delete g_VoiceControlEngines;
g_VoiceControlEngines = nullptr;
}
-static int __vc_config_mgr_get_engine_info()
+static int load_engines_information()
{
DIR *dp = NULL;
struct dirent *dirp = NULL;
SLOG(LOG_DEBUG, vc_config_tag(), "[CONFIG] Release engine and Unregister engine config");
- __vc_config_release_engine();
+ release_engines_information();
g_VoiceControlEngines = new(nothrow) VoiceControlEngines();
if (g_VoiceControlEngines == nullptr) {
return VC_CONFIG_ERROR_OUT_OF_MEMORY;
}
- __vc_config_mgr_unregister_engine_config_updated_event();
+ unregister_engine_config_updated_event();
SLOG(LOG_DEBUG, vc_config_tag(), "[CONFIG] default directory : %s", VC_DEFAULT_ENGINE_INFO);
try {
g_VoiceControlEngines->appendEngine(filepath);
- if (0 != __vc_config_mgr_register_engine_config_updated_event(filepath)) {
+ if (0 != register_engine_config_updated_event(filepath)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to register engine config updated event");
}
} catch (exception &error) {
return VC_CONFIG_ERROR_NONE;
}
-static Eina_Bool __vc_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
+static Eina_Bool engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
SLOG(LOG_DEBUG, vc_config_tag(), "@@@ Engine config updated callback event");
ecore_thread_main_loop_begin();
}
if (IN_CLOSE_WRITE == event.mask) {
- int ret = __vc_config_mgr_get_engine_info();
+ int ret = load_engines_information();
if (0 != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get engine info when config updated");
}
SLOG(LOG_DEBUG, vc_config_tag(), "[ERROR] Default language is not valid");
char* temp_lang = NULL;
string default_engine_id = g_VoiceControlConfig->getEngineId();
- ret = __vc_config_mgr_select_lang(default_engine_id.c_str(), &temp_lang);
+ ret = get_default_language_of_engine(default_engine_id.c_str(), &temp_lang);
if (0 != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get language");
}
- ret = __vc_config_mgr_set_default_language(temp_lang);
+ ret = set_current_language(temp_lang);
if (0 != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to set language");
} else {
return ECORE_CALLBACK_PASS_ON;
}
-static int __vc_config_mgr_register_engine_config_updated_event(const char* path)
+static int register_engine_config_updated_event(const char* path)
{
if (NULL == path) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Path is NULL");
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
- ino->dir_fd_handler = ecore_main_fd_handler_add(ino->dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)__vc_config_mgr_engine_config_inotify_event_callback, (void *)ino, NULL, NULL);
+ ino->dir_fd_handler = ecore_main_fd_handler_add(ino->dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)engine_config_inotify_event_callback, (void *)ino, NULL, NULL);
if (NULL == ino->dir_fd_handler) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to add fd handler");
free(ino);
return VC_CONFIG_ERROR_NONE;
}
-static int __vc_config_mgr_unregister_engine_config_updated_event()
+static int unregister_engine_config_updated_event()
{
unique_lock<mutex> lock(g_ino_list_mutex);
return VC_CONFIG_ERROR_NONE;
}
-static Eina_Bool __vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
+static Eina_Bool language_config_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
{
SLOG(LOG_DEBUG, vc_config_tag(), "@@@ Config changed callback event");
g_VoiceControlConfig->setCurrentLanguage(lang);
/* Call all callbacks of client*/
- __vc_config_mgr_notify_language_changed(before_lang.c_str(), lang);
+ notify_language_changed(before_lang.c_str(), lang);
free(lang);
lang = NULL;
g_VoiceControlConfig->setEngineId(engine);
/* Call all callbacks of client*/
- __vc_config_mgr_notify_engine_changed(engine);
+ notify_engine_changed(engine);
free(engine);
engine = NULL;
}
g_VoiceControlConfig->setEnabled((bool)enabled);
/* Call all callbacks of client*/
- __vc_config_mgr_notify_enabled_changed((bool)enabled);
+ notify_enabled_changed((bool)enabled);
}
} else {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Undefined event");
return ECORE_CALLBACK_PASS_ON;
}
-int __vc_config_set_auto_language()
+static int set_language_by_automatic_selection()
{
char candidate_lang[6] = {'\0', };
char* value = NULL;
}
string default_engine_id = g_VoiceControlConfig->getEngineId();
- if (true == __vc_config_mgr_check_lang_is_valid(default_engine_id.c_str(), candidate_lang)) {
+ if (true == is_language_valid_in_engine(default_engine_id.c_str(), candidate_lang)) {
/* vc default language change */
string before_language = g_VoiceControlConfig->getCurrentLanguage();
if (0 != vc_parser_set_language(candidate_lang)) {
before_language.c_str(), candidate_lang);
/* Call all callbacks of client*/
- __vc_config_mgr_notify_language_changed(before_language.c_str(), candidate_lang);
+ notify_language_changed(before_language.c_str(), candidate_lang);
} else {
/* Candidate language is not valid */
char* tmp_language = NULL;
- if (0 != __vc_config_mgr_select_lang(default_engine_id.c_str(), &tmp_language)) {
+ if (0 != get_default_language_of_engine(default_engine_id.c_str(), &tmp_language)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to select language");
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
before_language.c_str(), tmp_language);
/* Call all callbacks of client*/
- __vc_config_mgr_notify_language_changed(before_language.c_str(), tmp_language);
+ notify_language_changed(before_language.c_str(), tmp_language);
free(tmp_language);
}
return VC_CONFIG_ERROR_NONE;
}
-static void __vc_config_language_changed_cb(keynode_t *key, void *data)
+static void language_changed_cb(keynode_t *key, void *data)
{
if (g_VoiceControlConfig->isAutoLanguageEnabled()) {
/* Get voice input vconf key */
- __vc_config_set_auto_language();
+ set_language_by_automatic_selection();
}
}
-static int __initialize_vc_config_mgr()
+static int initialize_vc_config_mgr()
{
if (g_config_mgr_initialized.load()) {
SLOG(LOG_DEBUG, vc_config_tag(), "Config mgr module is already initialized");
}
}
- if (0 != __vc_config_mgr_get_engine_info()) {
+ if (0 != load_engines_information()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get engine info");
- __vc_config_release_engine();
+ release_engines_information();
return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
g_VoiceControlEngines->printOutEngineInfo();
- if (0 != __initialize_config_info()) {
+ if (0 != initialize_config_info()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to parse configure information");
- __vc_config_release_engine();
+ release_engines_information();
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
string default_engine_id = g_VoiceControlConfig->getEngineId();
- if (0 != __vc_config_mgr_check_and_set_default_engine_id(default_engine_id.c_str())) {
+ if (0 != check_and_set_default_engine_id(default_engine_id.c_str())) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to set default engine");
- __vc_config_release_engine();
- __finalize_config_info();
+ release_engines_information();
+ finalize_config_info();
return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
if (g_VoiceControlConfig->isAutoLanguageEnabled()) {
/* Check language with display language */
- __vc_config_set_auto_language();
+ set_language_by_automatic_selection();
} else {
string default_language = g_VoiceControlConfig->getCurrentLanguage();
- if (false == __vc_config_mgr_check_lang_is_valid(default_engine_id.c_str(), default_language.c_str())) {
+ if (false == is_language_valid_in_engine(default_engine_id.c_str(), default_language.c_str())) {
/* Default language is not valid */
char* tmp_language;
- if (0 != __vc_config_mgr_select_lang(default_engine_id.c_str(), &tmp_language)) {
+ if (0 != get_default_language_of_engine(default_engine_id.c_str(), &tmp_language)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to select language");
- __vc_config_release_engine();
- __finalize_config_info();
+ release_engines_information();
+ finalize_config_info();
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
if (0 != vc_parser_set_language(tmp_language)) {
free(tmp_language);
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to save config");
- __vc_config_release_engine();
- __finalize_config_info();
+ release_engines_information();
+ finalize_config_info();
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
g_lang_ref_count = 0;
/* Register to detect display language change */
- vconf_notify_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb, nullptr);
+ vconf_notify_key_changed(VCONFKEY_LANGSET, language_changed_cb, nullptr);
g_config_mgr_initialized = true;
return VC_CONFIG_ERROR_NONE;
SLOG(LOG_INFO, vc_config_tag(), "[WARNING] Enter critical section");
ecore_thread_main_loop_begin();
- int ret = __initialize_vc_config_mgr();
+ int ret = initialize_vc_config_mgr();
if (VC_CONFIG_ERROR_NONE != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to initialize vc_config_mgr");
ecore_thread_main_loop_end();
delete g_VoiceControlClients;
g_VoiceControlClients = nullptr;
- __vc_config_release_engine();
+ release_engines_information();
- __vc_config_mgr_unregister_engine_config_updated_event();
+ unregister_engine_config_updated_event();
- vconf_ignore_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb);
- __finalize_config_info();
+ vconf_ignore_key_changed(VCONFKEY_LANGSET, language_changed_cb);
+ finalize_config_info();
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
}
-static int __vc_config_mgr_register_lang_event()
+static int register_language_config_changed_event()
{
if (0 == g_lang_ref_count) {
/* get file notification handler */
wd = inotify_add_watch(fd, VC_CONFIG, IN_CLOSE_WRITE);
g_wd_lang = wd;
- g_fd_handler_lang = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)__vc_config_mgr_inotify_event_cb, NULL, NULL, NULL);
+ g_fd_handler_lang = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)language_config_inotify_event_cb, NULL, NULL, NULL);
if (NULL == g_fd_handler_lang) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get handler_noti");
return VC_CONFIG_ERROR_OPERATION_FAILED;
return VC_CONFIG_ERROR_NONE;
}
-static int __vc_config_mgr_unregister_config_event()
+static int unregister_language_config_event()
{
if (0 == g_lang_ref_count) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Lang ref count is 0");
g_fd_handler_lang = NULL;
g_fd_lang = -1;
- vconf_ignore_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb);
+ vconf_ignore_key_changed(VCONFKEY_LANGSET, language_changed_cb);
}
return VC_CONFIG_ERROR_NONE;
g_VoiceControlClients->setEngineChangedCallback(uid, engine_cb);
- if (VC_CONFIG_ERROR_NONE != __vc_config_mgr_register_lang_event()) {
+ if (VC_CONFIG_ERROR_NONE != register_language_config_changed_event()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to register config event");
ecore_thread_main_loop_end();
return VC_CONFIG_ERROR_OPERATION_FAILED;
g_VoiceControlClients->setEngineChangedCallback(uid, nullptr);
- __vc_config_mgr_unregister_config_event();
+ unregister_language_config_event();
ecore_thread_main_loop_end();
return VC_CONFIG_ERROR_NONE;
g_VoiceControlConfig->setAutoLanguageEnabled(value);
if (true == value) {
- __vc_config_set_auto_language();
+ set_language_by_automatic_selection();
}
}
return VC_CONFIG_ERROR_NONE;
}
-static int __vc_config_set_buxtonkey(const char* engine)
+static int set_default_engine_id_on_buxtonkey(const char* engine)
{
/* Set vconfkey */
struct buxton_client * bux_cli;
SLOG(LOG_DEBUG, vc_config_tag(), "New engine id : %s", engine);
- int ret = __vc_config_set_buxtonkey(engine);
+ int ret = set_default_engine_id_on_buxtonkey(engine);
if (0 != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] set buxtonkey Failed!!!");
return ret;
return VC_CONFIG_ERROR_NONE;
}
-static int __vc_config_mgr_set_default_language(const char* language)
+static int set_current_language(const char* language)
{
if (g_config_mgr_initialized.load() == false) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
int vc_config_mgr_set_default_language(const char* language)
{
- int ret = __vc_config_mgr_set_default_language(language);
+ int ret = set_current_language(language);
return ret;
}
static pthread_mutex_t g_tts_text_data_mutex = PTHREAD_MUTEX_INITIALIZER;
-static int __data_show_text_list(void)
+static int show_text_list(void)
{
SLOG(LOG_DEBUG, TAG_VCD, "----- Text list -----");
*iter, (*iter)->uid, (*iter)->pid, (*iter)->utt_id, (*iter)->text, (*iter)->language);
#ifdef DATA_DEBUG
- __data_show_text_list();
+ show_text_list();
#endif
pthread_mutex_unlock(&g_tts_text_data_mutex);
}
#ifdef DATA_DEBUG
- __data_show_text_list();
+ show_text_list();
#endif
pthread_mutex_unlock(&g_tts_text_data_mutex);
SLOG(LOG_INFO, TAG_VCD, "[DATA] Get first tts text data");
#ifdef DATA_DEBUG
- __data_show_text_list();
+ show_text_list();
#endif
/* mutex is locked */
projects / platform / core / uifw / voice-control.git / commitdiff