From 137c84eed7a7a8a1afd264f638f94b5191b94414 Mon Sep 17 00:00:00 2001 From: Suyeon Hwang Date: Thu, 19 Jan 2023 19:23:10 +0900 Subject: [PATCH] Fix coding convention about member variables and static functions - Issue: Using two underscores(__) as name of variables or functions is reserved by C and CPP compilers, so it may occur name colision. - Solution: Previously, most of the code followed old tizen coding convention. However, in case of name, the convention conflicts with C and CPP standard, because two underscore is already reserved as an identifier by C and CPP standard. Thus, using two underscores may cause some problems. To resolve this collision, this patch fixes the name of member variables and static functions to match C and CPP standard. Through this patch, CPP files in the project do not use two underscore as name of variables and functions anymore. Change-Id: I2309c0c1d7bdb37a3b55f996d1d0372dc39dd856 Signed-off-by: Suyeon Hwang --- audio-manager/src/vc_audio_manager.cpp | 16 +-- client/vc_mgr_ducking.cpp | 72 +++++++------- common/VoiceControlClientInfo.cpp | 42 ++++---- common/VoiceControlClientInfo.h | 8 +- common/VoiceControlClients.cpp | 44 ++++----- common/VoiceControlClients.h | 4 +- common/VoiceControlConfig.cpp | 94 +++++++++--------- common/VoiceControlConfig.h | 4 +- common/VoiceControlEngineInfo.cpp | 38 +++---- common/VoiceControlEngineInfo.h | 12 +-- common/VoiceControlEngines.cpp | 36 +++---- common/VoiceControlEngines.h | 4 +- common/vc_config_mgr.cpp | 132 ++++++++++++------------- server/vcd_server_data.cpp | 8 +- 14 files changed, 257 insertions(+), 257 deletions(-) diff --git a/audio-manager/src/vc_audio_manager.cpp b/audio-manager/src/vc_audio_manager.cpp index 51c7a97..00f7485 100644 --- a/audio-manager/src/vc_audio_manager.cpp +++ b/audio-manager/src/vc_audio_manager.cpp @@ -46,7 +46,7 @@ static int g_audio_channel = 0; 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; @@ -84,7 +84,7 @@ static bool __convert_audio_channel(int channel, audio_channel_e* output) 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; @@ -104,7 +104,7 @@ static bool __convert_audio_sample_type(vce_audio_type_e audio_type, audio_sampl 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; @@ -150,11 +150,11 @@ int vcd_dependency_initialize(sound_stream_info_h stream_info_h, dependency_audi 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; } @@ -241,11 +241,11 @@ int vcd_dependency_set_audio_info(sound_stream_info_h stream_info_h, const char* 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; } @@ -319,7 +319,7 @@ int vcd_dependency_start_recording(void) /* 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); diff --git a/client/vc_mgr_ducking.cpp b/client/vc_mgr_ducking.cpp index 06a2290..bbec1d7 100644 --- a/client/vc_mgr_ducking.cpp +++ b/client/vc_mgr_ducking.cpp @@ -32,7 +32,7 @@ static sound_stream_ducking_h g_voice_information_stream_h = nullptr; 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"; @@ -48,7 +48,7 @@ static const char *__get_ducking_stream(sound_stream_type_e stream_type) 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; @@ -62,7 +62,7 @@ static sound_stream_ducking_h __create_ducking_handle(sound_stream_type_e type) 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; @@ -73,7 +73,7 @@ static void __destroy_ducking_handle(sound_stream_ducking_h ducking_handle) 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) { @@ -83,13 +83,13 @@ static bool __is_all_ducking_handle_valid() 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; @@ -105,14 +105,14 @@ int vc_mgr_ducking_create(void) 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; } @@ -123,27 +123,27 @@ int vc_mgr_ducking_create(void) 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; } @@ -153,41 +153,41 @@ int vc_mgr_ducking_activate(double ratio) 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; } @@ -197,22 +197,22 @@ int vc_mgr_ducking_deactivate(void) 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; } diff --git a/common/VoiceControlClientInfo.cpp b/common/VoiceControlClientInfo.cpp index 8ce8f62..b1954af 100644 --- a/common/VoiceControlClientInfo.cpp +++ b/common/VoiceControlClientInfo.cpp @@ -25,68 +25,68 @@ using namespace std; 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); } diff --git a/common/VoiceControlClientInfo.h b/common/VoiceControlClientInfo.h index d6df960..755f912 100644 --- a/common/VoiceControlClientInfo.h +++ b/common/VoiceControlClientInfo.h @@ -38,10 +38,10 @@ public: 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_ */ diff --git a/common/VoiceControlClients.cpp b/common/VoiceControlClients.cpp index cb72caf..2b5464d 100644 --- a/common/VoiceControlClients.cpp +++ b/common/VoiceControlClients.cpp @@ -30,14 +30,14 @@ VoiceControlClients::~VoiceControlClients() void VoiceControlClients::printOutClients() { - unique_lock lock(__clientsMutex); + unique_lock 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()); } } @@ -47,29 +47,29 @@ void VoiceControlClients::printOutClients() void VoiceControlClients::appendClient(VoiceControlClientInfo &clientInfo) { - unique_lock lock(__clientsMutex); - __clients.push_back(clientInfo); + unique_lock lock(mClientsMutex); + mClients.push_back(clientInfo); } std::size_t VoiceControlClients::removeClient(unsigned int uid) { - unique_lock lock(__clientsMutex); + unique_lock 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 lock(__clientsMutex); + unique_lock lock(mClientsMutex); auto clientInfo = findClient(uid); if (clientInfo == nullptr) { SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info"); @@ -82,7 +82,7 @@ void VoiceControlClients::setEngineChangedCallback(unsigned int uid, vc_config_e void VoiceControlClients::setLanguageChangedCallback(unsigned int uid, vc_config_lang_changed_cb callback) { - unique_lock lock(__clientsMutex); + unique_lock lock(mClientsMutex); auto clientInfo = findClient(uid); if (clientInfo == nullptr) { SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info"); @@ -95,7 +95,7 @@ void VoiceControlClients::setLanguageChangedCallback(unsigned int uid, vc_config void VoiceControlClients::setEnabledChangedCallback(unsigned int uid, vc_config_enabled_cb callback) { - unique_lock lock(__clientsMutex); + unique_lock lock(mClientsMutex); auto clientInfo = findClient(uid); if (clientInfo == nullptr) { SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found client info"); @@ -108,7 +108,7 @@ void VoiceControlClients::setEnabledChangedCallback(unsigned int uid, vc_config_ bool VoiceControlClients::isUidValid(unsigned int uid) { - unique_lock lock(__clientsMutex); + unique_lock lock(mClientsMutex); bool isValid = (nullptr != findClient(uid)); SLOG(LOG_INFO, TAG_VCCONFIG, "Client Id(%u) is %svalid", uid, (isValid ? "" : "not ")); return isValid; @@ -116,7 +116,7 @@ bool VoiceControlClients::isUidValid(unsigned int uid) std::shared_ptr VoiceControlClients::getClientInfo(unsigned int uid) { - unique_lock lock(__clientsMutex); + unique_lock lock(mClientsMutex); SLOG(LOG_INFO, TAG_VCCONFIG, "Get client info with ID(%u)", uid); auto clientInfo = findClient(uid); if (clientInfo == nullptr) { @@ -130,7 +130,7 @@ std::shared_ptr VoiceControlClients::getClientInfo(unsig 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; @@ -143,15 +143,15 @@ VoiceControlClientInfo *VoiceControlClients::findClient(unsigned int uid) std::vector VoiceControlClients::getClients() { - unique_lock lock(__clientsMutex); - SLOG(LOG_INFO, TAG_VCCONFIG, "Get clients. size(%zu)", __clients.size()); - return __clients; + unique_lock lock(mClientsMutex); + SLOG(LOG_INFO, TAG_VCCONFIG, "Get clients. size(%zu)", mClients.size()); + return mClients; } bool VoiceControlClients::isClientEmpty() { - unique_lock lock(__clientsMutex); - SLOG(LOG_INFO, TAG_VCCONFIG, "Length of clients (%zu)", __clients.size()); - return __clients.empty(); + unique_lock lock(mClientsMutex); + SLOG(LOG_INFO, TAG_VCCONFIG, "Length of clients (%zu)", mClients.size()); + return mClients.empty(); } diff --git a/common/VoiceControlClients.h b/common/VoiceControlClients.h index 01303f5..5a10ecc 100644 --- a/common/VoiceControlClients.h +++ b/common/VoiceControlClients.h @@ -44,8 +44,8 @@ public: private: VoiceControlClientInfo *findClient(unsigned int uid); - std::vector __clients; - std::mutex __clientsMutex; + std::vector mClients; + std::mutex mClientsMutex; }; diff --git a/common/VoiceControlConfig.cpp b/common/VoiceControlConfig.cpp index 750d245..9f754b2 100644 --- a/common/VoiceControlConfig.cpp +++ b/common/VoiceControlConfig.cpp @@ -26,10 +26,10 @@ using namespace std; VoiceControlConfig::VoiceControlConfig() { - unique_lock lock(__configMutex); - __config = nullptr; + unique_lock 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"); } @@ -37,48 +37,48 @@ VoiceControlConfig::VoiceControlConfig() VoiceControlConfig::~VoiceControlConfig() { - unique_lock lock(__configMutex); - vc_parser_unload_config(__config); - __config = nullptr; + unique_lock lock(mConfigMutex); + vc_parser_unload_config(mConfig); + mConfig = nullptr; } void VoiceControlConfig::printOutConfig() { - unique_lock 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 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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()); @@ -87,56 +87,56 @@ std::string VoiceControlConfig::getEngineId() void VoiceControlConfig::setAutoLanguageEnabled(bool isAutoLanguageEnabled) { - unique_lock lock(__configMutex); - if (nullptr == __config) { + unique_lock 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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; @@ -144,24 +144,24 @@ std::string VoiceControlConfig::getCurrentLanguage() void VoiceControlConfig::setEnabled(bool isEnabled) { - unique_lock lock(__configMutex); - if (nullptr == __config) { + unique_lock 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 lock(__configMutex); - if (nullptr == __config) { + unique_lock 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; } diff --git a/common/VoiceControlConfig.h b/common/VoiceControlConfig.h index 2f898e4..ede37e2 100644 --- a/common/VoiceControlConfig.h +++ b/common/VoiceControlConfig.h @@ -40,8 +40,8 @@ public: bool isEnabled(); private: - vc_config_s *__config; - std::mutex __configMutex; + vc_config_s *mConfig; + std::mutex mConfigMutex; }; diff --git a/common/VoiceControlEngineInfo.cpp b/common/VoiceControlEngineInfo.cpp index 475bee1..296d74d 100644 --- a/common/VoiceControlEngineInfo.cpp +++ b/common/VoiceControlEngineInfo.cpp @@ -33,24 +33,24 @@ VoiceControlEngineInfo::VoiceControlEngineInfo(const std::string filePath) } 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(iter->data); if (language != nullptr) { - __supportedLanguages.push_back(language); + mSupportedLanguages.push_back(language); } iter = g_slist_next(iter); @@ -66,17 +66,17 @@ VoiceControlEngineInfo::~VoiceControlEngineInfo() 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++; } @@ -85,7 +85,7 @@ void VoiceControlEngineInfo::printOutEngine() 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()); @@ -99,31 +99,31 @@ bool VoiceControlEngineInfo::isLanguageValid(const std::string language) 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 VoiceControlEngineInfo::getSupportedLanguages() { - return __supportedLanguages; + return mSupportedLanguages; } bool VoiceControlEngineInfo::isNonFixedSupported() { - return __nonFixedSupported; + return mNonFixedSupported; } diff --git a/common/VoiceControlEngineInfo.h b/common/VoiceControlEngineInfo.h index 910af97..6c899d2 100644 --- a/common/VoiceControlEngineInfo.h +++ b/common/VoiceControlEngineInfo.h @@ -37,12 +37,12 @@ public: bool isNonFixedSupported(); private: - std::string __engineName; - std::string __engineId; - std::string __settingPath; - std::string __defaultLanguage; - std::vector __supportedLanguages; - bool __nonFixedSupported; + std::string mEngineName; + std::string mEngineId; + std::string mSettingPath; + std::string mDefaultLanguage; + std::vector mSupportedLanguages; + bool mNonFixedSupported; }; diff --git a/common/VoiceControlEngines.cpp b/common/VoiceControlEngines.cpp index 47a3251..e30a1a8 100644 --- a/common/VoiceControlEngines.cpp +++ b/common/VoiceControlEngines.cpp @@ -30,14 +30,14 @@ VoiceControlEngines::~VoiceControlEngines() void VoiceControlEngines::printOutEngineInfo() { - unique_lock lock(__enginesMutex); + unique_lock 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(); } @@ -48,11 +48,11 @@ void VoiceControlEngines::printOutEngineInfo() void VoiceControlEngines::appendEngine(const std::string path) { - unique_lock lock(__enginesMutex); + unique_lock 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; @@ -66,7 +66,7 @@ bool VoiceControlEngines::isEngineIdValid(const std::string engineId) return false; } - unique_lock lock(__enginesMutex); + unique_lock lock(mEnginesMutex); bool isValid = (nullptr != findEngine(engineId)); SLOG(LOG_INFO, TAG_VCCONFIG, "Engine Id(%s) is %svalid", engineId.c_str(), (isValid ? "" : "not ")); return isValid; @@ -79,7 +79,7 @@ std::shared_ptr VoiceControlEngines::getEngineInfo(const return nullptr; } - unique_lock lock(__enginesMutex); + unique_lock lock(mEnginesMutex); SLOG(LOG_INFO, TAG_VCCONFIG, "Get engine info with ID(%s)", engineId.c_str()); auto engineInfo = findEngine(engineId); if (engineInfo == nullptr) { @@ -92,14 +92,14 @@ std::shared_ptr VoiceControlEngines::getEngineInfo(const std::shared_ptr VoiceControlEngines::getFirstEngineInfo() { - unique_lock lock(__enginesMutex); - if (__engines.size() == 0) { + unique_lock 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(__engines[0]); + SLOG(LOG_INFO, TAG_VCCONFIG, "Get first engine info. size(%zu)", mEngines.size()); + return make_shared(mEngines[0]); } VoiceControlEngineInfo *VoiceControlEngines::findEngine(const std::string engineId) @@ -110,7 +110,7 @@ VoiceControlEngineInfo *VoiceControlEngines::findEngine(const std::string engine } 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; @@ -123,15 +123,15 @@ VoiceControlEngineInfo *VoiceControlEngines::findEngine(const std::string engine std::vector VoiceControlEngines::getEngines() { - unique_lock lock(__enginesMutex); - SLOG(LOG_INFO, TAG_VCCONFIG, "Get engines. size(%zu)", __engines.size()); - return __engines; + unique_lock lock(mEnginesMutex); + SLOG(LOG_INFO, TAG_VCCONFIG, "Get engines. size(%zu)", mEngines.size()); + return mEngines; } bool VoiceControlEngines::isEngineEmpty() { - unique_lock lock(__enginesMutex); - SLOG(LOG_INFO, TAG_VCCONFIG, "Length of engines (%zu)", __engines.size()); - return __engines.empty(); + unique_lock lock(mEnginesMutex); + SLOG(LOG_INFO, TAG_VCCONFIG, "Length of engines (%zu)", mEngines.size()); + return mEngines.empty(); } diff --git a/common/VoiceControlEngines.h b/common/VoiceControlEngines.h index ae436a5..9848900 100644 --- a/common/VoiceControlEngines.h +++ b/common/VoiceControlEngines.h @@ -40,8 +40,8 @@ public: private: VoiceControlEngineInfo *findEngine(const std::string engineId); - std::vector __engines; - std::mutex __enginesMutex; + std::vector mEngines; + std::mutex mEnginesMutex; }; diff --git a/common/vc_config_mgr.cpp b/common/vc_config_mgr.cpp index 2ee8af5..23a1fd1 100644 --- a/common/vc_config_mgr.cpp +++ b/common/vc_config_mgr.cpp @@ -74,11 +74,11 @@ static int g_wd_lang = -1; 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) { @@ -97,7 +97,7 @@ static void __vc_config_mgr_notify_engine_changed(const char *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) { @@ -116,7 +116,7 @@ static void __vc_config_mgr_notify_language_changed(const char* before_lang, con } } -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(); @@ -130,7 +130,7 @@ static void __vc_config_mgr_notify_enabled_changed(bool enable) } } -static int __initialize_config_info() +static int initialize_config_info() { g_VoiceControlConfig = new(nothrow) VoiceControlConfig(); if (nullptr == g_VoiceControlConfig) { @@ -141,7 +141,7 @@ static int __initialize_config_info() return VC_CONFIG_ERROR_NONE; } -static void __finalize_config_info() +static void finalize_config_info() { delete g_VoiceControlConfig; g_VoiceControlConfig = nullptr; @@ -161,7 +161,7 @@ int vc_config_convert_error_code(vc_config_error_e code) 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"); @@ -190,7 +190,7 @@ static int __vc_config_mgr_check_and_set_default_engine_id(const char* engine_id 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"); @@ -209,7 +209,7 @@ static bool __vc_config_mgr_check_lang_is_valid(const char* engine_id, const cha 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"); @@ -242,13 +242,13 @@ static int __vc_config_mgr_select_lang(const char* engine_id, char** language) 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; @@ -258,7 +258,7 @@ static int __vc_config_mgr_get_engine_info() 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) { @@ -266,7 +266,7 @@ static int __vc_config_mgr_get_engine_info() 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); @@ -334,7 +334,7 @@ static int __vc_config_mgr_get_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) { @@ -354,7 +354,7 @@ static int __vc_config_mgr_get_engine_info() 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(); @@ -375,7 +375,7 @@ static Eina_Bool __vc_config_mgr_engine_config_inotify_event_callback(void* data } 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"); } @@ -387,13 +387,13 @@ static Eina_Bool __vc_config_mgr_engine_config_inotify_event_callback(void* data 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 { @@ -414,7 +414,7 @@ static Eina_Bool __vc_config_mgr_engine_config_inotify_event_callback(void* data 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"); @@ -446,7 +446,7 @@ static int __vc_config_mgr_register_engine_config_updated_event(const char* path 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); @@ -469,7 +469,7 @@ static int __vc_config_mgr_register_engine_config_updated_event(const char* path return VC_CONFIG_ERROR_NONE; } -static int __vc_config_mgr_unregister_engine_config_updated_event() +static int unregister_engine_config_updated_event() { unique_lock lock(g_ino_list_mutex); @@ -497,7 +497,7 @@ static int __vc_config_mgr_unregister_engine_config_updated_event() 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"); @@ -537,7 +537,7 @@ static Eina_Bool __vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler * 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; @@ -548,7 +548,7 @@ static Eina_Bool __vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler * g_VoiceControlConfig->setEngineId(engine); /* Call all callbacks of client*/ - __vc_config_mgr_notify_engine_changed(engine); + notify_engine_changed(engine); free(engine); engine = NULL; } @@ -557,7 +557,7 @@ static Eina_Bool __vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler * 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"); @@ -568,7 +568,7 @@ static Eina_Bool __vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler * 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; @@ -592,7 +592,7 @@ int __vc_config_set_auto_language() } 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)) { @@ -605,11 +605,11 @@ int __vc_config_set_auto_language() 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; } @@ -631,22 +631,22 @@ int __vc_config_set_auto_language() 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"); @@ -688,40 +688,40 @@ static int __initialize_vc_config_mgr() } } - 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; } @@ -730,8 +730,8 @@ static int __initialize_vc_config_mgr() 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; } @@ -748,7 +748,7 @@ static int __initialize_vc_config_mgr() 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; @@ -759,7 +759,7 @@ int vc_config_mgr_initialize(unsigned int uid) 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(); @@ -803,12 +803,12 @@ int vc_config_mgr_finalize(unsigned int uid) 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"); @@ -818,7 +818,7 @@ int vc_config_mgr_finalize(unsigned int uid) } -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 */ @@ -835,7 +835,7 @@ static int __vc_config_mgr_register_lang_event() 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; @@ -855,7 +855,7 @@ static int __vc_config_mgr_register_lang_event() 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"); @@ -871,7 +871,7 @@ static int __vc_config_mgr_unregister_config_event() 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; @@ -893,7 +893,7 @@ int vc_config_mgr_set_engine_cb(unsigned int uid, vc_config_engine_changed_cb en 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; @@ -914,7 +914,7 @@ int vc_config_mgr_unset_engine_cb(unsigned int uid) 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; @@ -1011,7 +1011,7 @@ int vc_config_mgr_set_auto_language(bool value) g_VoiceControlConfig->setAutoLanguageEnabled(value); if (true == value) { - __vc_config_set_auto_language(); + set_language_by_automatic_selection(); } } @@ -1075,7 +1075,7 @@ int vc_config_mgr_get_engine(char** engine) 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; @@ -1150,7 +1150,7 @@ int vc_config_mgr_set_engine(const char* engine) 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; @@ -1246,7 +1246,7 @@ int vc_config_mgr_get_default_language(char** language) 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"); @@ -1275,7 +1275,7 @@ static int __vc_config_mgr_set_default_language(const char* language) 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; } diff --git a/server/vcd_server_data.cpp b/server/vcd_server_data.cpp index 579928a..b57c97d 100644 --- a/server/vcd_server_data.cpp +++ b/server/vcd_server_data.cpp @@ -33,7 +33,7 @@ std::list g_tts_text_data; 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 -----"); @@ -75,7 +75,7 @@ int vcd_data_add_tts_text_data(vc_tts_text_data_s* data) *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); @@ -136,7 +136,7 @@ int vcd_data_get_tts_text_data(unsigned int tts_uid, vc_tts_text_data_s** data) } #ifdef DATA_DEBUG - __data_show_text_list(); + show_text_list(); #endif pthread_mutex_unlock(&g_tts_text_data_mutex); @@ -149,7 +149,7 @@ int vcd_data_get_first_tts_text_data(vc_tts_text_data_s** data) 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 */ -- 2.34.1