Add exception handlers for the functions in external modules

Change-Id: Iae5619b299fc0a6ff737b042f90d23d13a3864c0

diff --git a/plugins/wakeup-manager/src/dependency_resolver.cpp b/plugins/wakeup-manager/src/dependency_resolver.cpp
index 551290e..43b080d 100644 (file)
--- a/plugins/wakeup-manager/src/dependency_resolver.cpp
+++ b/plugins/wakeup-manager/src/dependency_resolver.cpp
@@ -22,6 +22,8 @@
 #include <unistd.h>
 #include <vconf.h>
 
+#include <stdexcept>
+
 #include "multi_assistant_main.h"
 #include "dependency_resolver.h"
 
@@ -93,7 +95,12 @@ int dependency_resolver_initialize(mas_proxy_interface interface)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_INITIALIZE);
                } else {
-                       ret = func(interface, &dependency_version);
+                       try {
+                               ret = func(interface, &dependency_version);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_INITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to initialize, ret(%d)", ret);
                        }
@@ -114,7 +121,12 @@ int dependency_resolver_deinitialize(void)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_DEINITIALIZE);
                } else {
-                       ret = func();
+                       try {
+                               ret = func();
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to deinitialize, ret(%d)", ret);
                        }
@@ -137,7 +149,12 @@ int dependency_resolver_set_error_callback(mas_dependency_error_cb callback, voi
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK);
                } else {
-                       ret = func(callback, user_data);
+                       try {
+                               ret = func(callback, user_data);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to set error callback(%p, %p), ret(%d)", callback, user_data, ret);
                        }
@@ -157,7 +174,12 @@ int dependency_resolver_start_recording(void)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_START_RECORDING);
                } else {
-                       ret = func();
+                       try {
+                               ret = func();
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to start recording, ret(%d)", ret);
                        }
@@ -177,7 +199,12 @@ int dependency_resolver_stop_recording(void)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_STOP_RECORDING);
                } else {
-                       ret = func();
+                       try {
+                               ret = func();
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
                        }
@@ -198,7 +225,12 @@ int dependency_resolver_set_recording_session(unsigned int session)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION);
                } else {
-                       ret = func(session);
+                       try {
+                               ret = func(session);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to set recording session, ret(%d)", ret);
                        }
@@ -218,7 +250,12 @@ int dependency_resolver_set_background_volume(double ratio)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME);
                } else {
-                       ret = func(ratio);
+                       try {
+                               ret = func(ratio);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to set background volume to %f, ret(%d)", ratio, ret);
                        }
@@ -238,7 +275,12 @@ int dependency_resolver_get_audio_format(int* rate, int* channel, int* audio_typ
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT);
                } else {
-                       ret = func(rate, channel, audio_type);
+                       try {
+                               ret = func(rate, channel, audio_type);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to get audio format, ret(%d)", ret);
                        }
@@ -258,7 +300,12 @@ int dependency_resolver_get_audio_source_type(char** type)
                if (NULL == func) {
                        MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
                } else {
-                       ret = func(type);
+                       try {
+                               ret = func(type);
+                       } catch (const std::exception& e) {
+                               MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+                                       MAS_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
+                       }
                        if (0 != ret) {
                                MAS_LOGE("[ERROR] Fail to get audio source type, ret(%d)", ret);
                        }

diff --git a/plugins/wakeup-manager/src/wakeup_engine_manager.cpp b/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
index 46e9a1d..5e1163c 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
+++ b/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
@@ -77,20 +77,25 @@ void CWakeupEngineManager::initialize()
 void CWakeupEngineManager::deinitialize()
 {
        for (auto& info : mEngineInfo) {
-               if (info.interface.set_wakeup_event_callback) {
-                       info.interface.set_wakeup_event_callback(nullptr, nullptr);
-               }
-               if (info.interface.set_speech_status_callback) {
-                       info.interface.set_speech_status_callback(nullptr, nullptr);
-               }
-               if (info.interface.set_error_callback) {
-                       info.interface.set_error_callback(nullptr, nullptr);
-               }
-               if (info.interface.set_audio_data_require_status_callback) {
-                       info.interface.set_audio_data_require_status_callback(nullptr, nullptr);
-               }
-               if (info.interface.deinitialize) {
-                       info.interface.deinitialize();
+               try {
+                       if (info.interface.set_wakeup_event_callback) {
+                               info.interface.set_wakeup_event_callback(nullptr, nullptr);
+                       }
+                       if (info.interface.set_speech_status_callback) {
+                               info.interface.set_speech_status_callback(nullptr, nullptr);
+                       }
+                       if (info.interface.set_error_callback) {
+                               info.interface.set_error_callback(nullptr, nullptr);
+                       }
+                       if (info.interface.set_audio_data_require_status_callback) {
+                               info.interface.set_audio_data_require_status_callback(nullptr, nullptr);
+                       }
+                       if (info.interface.deinitialize) {
+                               info.interface.deinitialize();
+                       }
+               } catch (const std::exception& e) {
+                       MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                               info.engine_name.c_str(), e.what());
                }
                if (info.engine_handle) {
                        dlclose(info.engine_handle);
@@ -138,7 +143,12 @@ bool CWakeupEngineManager::set_language(string language)
 {
        for (const auto& info : mEngineInfo) {
                if (info.interface.set_language) {
-                       info.interface.set_language(language.c_str());
+                       try {
+                               info.interface.set_language(language.c_str());
+                       } catch (const std::exception& e) {
+                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                       info.engine_name.c_str(), e.what());
+                       }
                }
        }
        return true;
@@ -164,9 +174,19 @@ void CWakeupEngineManager::set_assistant_activated(string appid, bool activated)
                        info.activated = (info.activated_assistants.size() > 0);
                        if (previously_activated != info.activated) {
                                if (info.activated) {
-                                       info.interface.activate();
+                                       try {
+                                               info.interface.activate();
+                                       } catch (const std::exception& e) {
+                                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                                       info.engine_name.c_str(), e.what());
+                                       }
                                } else {
-                                       info.interface.deactivate();
+                                       try {
+                                               info.interface.deactivate();
+                                       } catch (const std::exception& e) {
+                                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                                       info.engine_name.c_str(), e.what());
+                                       }
                                }
                                /* Activated status changed, need to update audio_data_require_status too */
                                on_audio_data_require_status(info.engine_name, info.audio_data_require_status);
@@ -181,7 +201,12 @@ void CWakeupEngineManager::set_wake_word_audio_require_flag(bool require)
        mWakeWordAudioRequired = require;
        for (const auto& info : mEngineInfo) {
                if (info.interface.set_wake_word_audio_require_flag) {
-                       info.interface.set_wake_word_audio_require_flag(require);
+                       try {
+                               info.interface.set_wake_word_audio_require_flag(require);
+                       } catch (const std::exception& e) {
+                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                       info.engine_name.c_str(), e.what());
+                       }
                }
        }
 }
@@ -336,7 +361,12 @@ void CWakeupEngineManager::update_manager_state(wakeup_manager_state_e state)
 {
        for (const auto& info : mEngineInfo) {
                if (info.interface.update_manager_state) {
-                       info.interface.update_manager_state(state);
+                       try {
+                               info.interface.update_manager_state(state);
+                       } catch (const std::exception& e) {
+                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                       info.engine_name.c_str(), e.what());
+                       }
                }
        }
 }
@@ -392,7 +422,12 @@ void CWakeupEngineManager::engine_add_wakeup_word(string appid, string wakeup_wo
                bool found = contains(info.assistant_list, appid);
                if (found) {
                        if (info.interface.add_wakeup_word) {
-                               info.interface.add_wakeup_word(appid.c_str(), wakeup_word.c_str(), language.c_str());
+                               try {
+                                       info.interface.add_wakeup_word(appid.c_str(), wakeup_word.c_str(), language.c_str());
+                               } catch (const std::exception& e) {
+                                       MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                               info.engine_name.c_str(), e.what());
+                               }
                        }
                }
        }
@@ -404,7 +439,12 @@ void CWakeupEngineManager::engine_set_assistant_specific_command(string appid, s
                bool found = contains(info.assistant_list, appid);
                if (found) {
                        if (info.interface.set_assistant_specific_command) {
-                               info.interface.set_assistant_specific_command(appid.c_str(), command.c_str());
+                               try {
+                                       info.interface.set_assistant_specific_command(appid.c_str(), command.c_str());
+                               } catch (const std::exception& e) {
+                                       MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                               info.engine_name.c_str(), e.what());
+                               }
                        }
                }
        }
@@ -416,9 +456,14 @@ void CWakeupEngineManager::engine_feed_audio_data(long time, void* data, int len
                if (info.activated &&
                        info.audio_data_require_status &&
                        info.interface.feed_audio_data) {
-                       int ret = info.interface.feed_audio_data(time, data, len);
-                       if (0 != ret) {
-                               LOGE("[ERROR] Fail to feed speech data, ret(%d) : %s", ret, info.engine_name.c_str());
+                       try {
+                               int ret = info.interface.feed_audio_data(time, data, len);
+                               if (0 != ret) {
+                                       LOGE("[ERROR] Fail to feed speech data, ret(%d) : %s", ret, info.engine_name.c_str());
+                               }
+                       } catch (const std::exception& e) {
+                               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                                       info.engine_name.c_str(), e.what());
                        }
                }
        }
@@ -618,35 +663,40 @@ void CWakeupEngineManager::add_engine(string name, string path)
        user_data.engine_name = info.engine_name;
        callback_user_data.push_back(user_data);
 
-       if (info.interface.set_wakeup_event_callback) {
-               info.interface.set_wakeup_event_callback(
-                       [](wakeup_event_info info, void* user_data) {
-                               CallbackUserData *data = static_cast<CallbackUserData*>(user_data);
-                               if (nullptr == data) return;
-                               if (nullptr == data->manager) return;
-                               info.wakeup_engine = data->engine_name.c_str();
-                               data->manager->on_wakeup_event(data->engine_name, info);
-                       }, &(callback_user_data.back()));
-       }
+       try {
+               if (info.interface.set_wakeup_event_callback) {
+                       info.interface.set_wakeup_event_callback(
+                               [](wakeup_event_info info, void* user_data) {
+                                       CallbackUserData *data = static_cast<CallbackUserData*>(user_data);
+                                       if (nullptr == data) return;
+                                       if (nullptr == data->manager) return;
+                                       info.wakeup_engine = data->engine_name.c_str();
+                                       data->manager->on_wakeup_event(data->engine_name, info);
+                               }, &(callback_user_data.back()));
+               }
 
-       if (info.interface.set_audio_data_require_status_callback) {
-               info.interface.set_audio_data_require_status_callback(
-                       [](bool require, void* user_data) {
-                               CallbackUserData *data = static_cast<CallbackUserData*>(user_data);
-                               if (nullptr == data) return;
-                               if (nullptr == data->manager) return;
-                               data->manager->on_audio_data_require_status(data->engine_name, require);
-                       }, &(callback_user_data.back()));
-       }
+               if (info.interface.set_audio_data_require_status_callback) {
+                       info.interface.set_audio_data_require_status_callback(
+                               [](bool require, void* user_data) {
+                                       CallbackUserData *data = static_cast<CallbackUserData*>(user_data);
+                                       if (nullptr == data) return;
+                                       if (nullptr == data->manager) return;
+                                       data->manager->on_audio_data_require_status(data->engine_name, require);
+                               }, &(callback_user_data.back()));
+               }
 
-       if (info.interface.initialize) {
-               info.interface.initialize();
-       }
-       if (info.interface.get_version) {
-               int version;
-               if (0 == info.interface.get_version(&version)) {
-                       info.version = version;
+               if (info.interface.initialize) {
+                       info.interface.initialize();
+               }
+               if (info.interface.get_version) {
+                       int version;
+                       if (0 == info.interface.get_version(&version)) {
+                               info.version = version;
+                       }
                }
+       } catch (const std::exception& e) {
+               MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+                       info.engine_name.c_str(), e.what());
        }
 }