Modified to load only required wakeup engines

Change-Id: I5088222fbe6217cf8381de5280f552efe3889599

diff --git a/inc/service_common.h b/inc/service_common.h
index a488e74..2a3ff4f 100644 (file)
--- a/inc/service_common.h
+++ b/inc/service_common.h
@@ -119,6 +119,8 @@ typedef void (*wakeup_service_wakeup_service_state_changed_cb)(ma_service_state_
 
 typedef void (*wakeup_service_voice_key_status_changed_cb)(ma_voice_key_status_e status, void* user_data);
 
+typedef void (*wakeup_service_loaded_engine_changed_cb)(void *user_data);
+
 #define MAX_WAKEUP_WORDS_NUM 255
 #define MAX_WAKEUP_WORD_LEN 32
 #define MAX_SUPPORTED_LANGUAGES_NUM 255

diff --git a/inc/service_main.h b/inc/service_main.h
index fc0344b..ea87dad 100644 (file)
--- a/inc/service_main.h
+++ b/inc/service_main.h
@@ -155,6 +155,7 @@ public:
 
        bool app_create(void *data);
        void app_terminate(void *data);
+       void app_restart();
 
        int initialize_service_plugin(void);
        int deinitialize_service_plugin(void);

diff --git a/inc/service_plugin.h b/inc/service_plugin.h
index 112a9cb..69d081c 100644 (file)
--- a/inc/service_plugin.h
+++ b/inc/service_plugin.h
@@ -74,6 +74,7 @@ public:
        int set_wakeup_engine_command_callback(wakeup_service_wakeup_engine_command_cb callback, void* user_data);
        int set_wakeup_service_state_changed_callback(wakeup_service_wakeup_service_state_changed_cb callback, void* user_data);
        int set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data);
+       int set_loaded_engine_changed_callback(wakeup_service_loaded_engine_changed_cb callback, void* user_data);
 
        bool is_ui_panel_enabled();
 

diff --git a/inc/service_plugin_interface.h b/inc/service_plugin_interface.h
index 1cd8d35..ae2a74e 100644 (file)
--- a/inc/service_plugin_interface.h
+++ b/inc/service_plugin_interface.h
@@ -111,6 +111,8 @@ typedef int (*wakeup_manager_set_wakeup_engine_command_callback)(wakeup_service_
 typedef int (*wakeup_manager_set_wakeup_service_state_changed_callback)(wakeup_service_wakeup_service_state_changed_cb callback, void* user_data);
 #define MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_STATUS_CHANGED_CALLBACK "wakeup_manager_set_voice_key_status_changed_callback"
 typedef int (*wakeup_manager_set_voice_key_status_changed_callback)(wakeup_service_voice_key_status_changed_cb callback, void* user_data);
+#define MA_WAKEUP_MANAGER_FUNC_SET_LOADED_ENGINE_CHANGED_CALLBACK "wakeup_manager_set_loaded_engine_changed_callback"
+typedef int (*wakeup_manager_set_loaded_engine_changed_callback)(wakeup_service_loaded_engine_changed_cb callback, void* user_data);
 
 typedef struct {
        wakeup_manager_initialize                                                                       initialize;
@@ -154,6 +156,7 @@ typedef struct {
        wakeup_manager_set_wakeup_engine_command_callback                       set_wakeup_engine_command_callback;
        wakeup_manager_set_wakeup_service_state_changed_callback        set_wakeup_service_state_changed_callback;
        wakeup_manager_set_voice_key_status_changed_callback            set_voice_key_status_changed_callback;
+       wakeup_manager_set_loaded_engine_changed_callback                       set_loaded_engine_changed_callback;
 } wakeup_manager_interface;
 
 #endif /* __SERVICE_PLUGIN_INTERFACE_H__ */

diff --git a/plugins/wakeup-manager/inc/wakeup_manager.h b/plugins/wakeup-manager/inc/wakeup_manager.h
index 267216f..eb8f158 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_manager.h
+++ b/plugins/wakeup-manager/inc/wakeup_manager.h
@@ -61,6 +61,7 @@ class ISettingValueObserver {
 public:
        virtual ~ISettingValueObserver() = default;
        virtual void on_value_changed() = 0;
+       virtual void on_loaded_wakeup_engine_changed() = 0;
 };
 
 /* If a wakeup event is raised by pressing a voice key,
@@ -200,6 +201,7 @@ private:
                bool on_voice_input_language_changed(const char* language) override;
                bool on_assistant_enabled_info_changed(const char* appid, bool enabled) override;
                bool on_default_assistant_appid_changed(const char* appid) override;
+               bool on_multiple_mode_changed() override;
 
                void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
        private:

diff --git a/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h b/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h
index 3ee305f..b34a8f2 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h
+++ b/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h
@@ -60,6 +60,8 @@ typedef void (*wakeup_service_state_changed_cb)(ma_service_state_e state, void*
 
 typedef void (*wakeup_service_voice_key_status_changed_cb)(ma_voice_key_status_e state, void* user_data);
 
+typedef void (*wakeup_service_loaded_engine_changed_cb)(void* user_data);
+
 typedef struct {
        int plugin_version;
        bool ui_panel_enabled;
@@ -147,6 +149,8 @@ EXPORT_API int wakeup_manager_set_wakeup_service_state_changed_callback(wakeup_s
 
 EXPORT_API int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data);
 
+EXPORT_API int wakeup_manager_set_loaded_engine_changed_callback(wakeup_service_loaded_engine_changed_cb callback, void* user_data);
+
 /* Internal API declarations for dependency modules */
 
 int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);

diff --git a/plugins/wakeup-manager/inc/wakeup_settings.h b/plugins/wakeup-manager/inc/wakeup_settings.h
index 64b8b25..cb24f0d 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_settings.h
+++ b/plugins/wakeup-manager/inc/wakeup_settings.h
@@ -47,6 +47,7 @@ public:
        virtual bool on_voice_input_language_changed(const char* language) = 0;
        virtual bool on_assistant_enabled_info_changed(const char* appid, bool enabled) = 0;
        virtual bool on_default_assistant_appid_changed(const char* appid) = 0;
+       virtual bool on_multiple_mode_changed() = 0;
 };
 
 class CWakeupSettings

diff --git a/plugins/wakeup-manager/src/wakeup_manager.cpp b/plugins/wakeup-manager/src/wakeup_manager.cpp
index b209f8f..285cdc6 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_manager.cpp
+++ b/plugins/wakeup-manager/src/wakeup_manager.cpp
@@ -279,7 +279,19 @@ bool CWakeupManager::add_assistant_wakeup_engine(string appid, string engine)
 {
        MWR_LOGI("[ENTER] %s %s", appid.c_str(), engine.c_str());
 
-       mWakeupEngineManager.engine_add_target_assistant(engine, appid);
+       bool found = false;
+       if (mWakeupSettings.get_multiple_mode()) {
+               vector<string> assistants = mWakeupSettings.get_enabled_assistants();
+               auto iter = find(assistants.begin(), assistants.end(), appid);
+               if (iter != assistants.end())
+                       found = true;
+       } else {
+               if (0 == appid.compare(mWakeupSettings.get_default_assistant_appid()))
+                       found = true;
+       }
+
+       if (found)
+               mWakeupEngineManager.engine_add_target_assistant(engine, appid);
 
        MWR_LOGD("[END]");
        return true;
@@ -1212,7 +1224,10 @@ bool CWakeupManager::CSettingsEventObserver::on_assistant_enabled_info_changed(
        mWakeupManager->set_assistant_enabled(std::string(appid), enabled);
        vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
        for (const auto& observer : observers) {
-               observer->on_value_changed();
+               if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
+                       observer->on_loaded_wakeup_engine_changed();
+               else
+                       observer->on_value_changed();
        }
        return true;
 }
@@ -1225,7 +1240,20 @@ bool CWakeupManager::CSettingsEventObserver::on_default_assistant_appid_changed(
        mWakeupManager->process_default_assistant_changed(std::string(appid), false);
        vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
        for (const auto& observer : observers) {
-               observer->on_value_changed();
+               if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
+                       observer->on_value_changed();
+               else
+                       observer->on_loaded_wakeup_engine_changed();
+       }
+       return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_multiple_mode_changed()
+{
+       if (nullptr == mWakeupManager) return false;
+       vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+       for (const auto& observer : observers) {
+               observer->on_loaded_wakeup_engine_changed();
        }
        return true;
 }

diff --git a/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp b/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
index 00c258f..fd89d43 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
+++ b/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
@@ -73,6 +73,9 @@ static void *g_wakeup_service_state_changed_user_data;
 static wakeup_service_voice_key_status_changed_cb g_wakeup_service_voice_key_status_changed_cb;
 static void *g_wakeup_service_voice_key_status_changed_user_data;
 
+static wakeup_service_loaded_engine_changed_cb g_loaded_engine_changed_cb;
+static void *g_loaded_engine_changed_user_data;
+
 class CWakeupEventObserver : public IWakeupEventObserver
 {
        void on_wakeup(mas_wakeup_event_info wakeup_info) override;
@@ -88,6 +91,7 @@ class CWakeupEventObserver : public IWakeupEventObserver
 class CSettingValueObserver : public ISettingValueObserver
 {
        void on_value_changed() override;
+       void on_loaded_wakeup_engine_changed() override;
 };
 
 static std::unique_ptr<CWakeupEventObserver> g_wakeup_event_observer;
@@ -167,6 +171,9 @@ int wakeup_manager_initialize(void)
        g_wakeup_service_voice_key_status_changed_cb = NULL;
        g_wakeup_service_voice_key_status_changed_user_data = NULL;
 
+       g_loaded_engine_changed_cb = NULL;
+       g_loaded_engine_changed_user_data = NULL;
+
        g_wakeup_manager->initialize();
 
        MWR_LOGD("[END]");
@@ -830,6 +837,22 @@ int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_ke
        return 0;
 }
 
+int wakeup_manager_set_loaded_engine_changed_callback(wakeup_service_loaded_engine_changed_cb callback, void* user_data)
+{
+       MWR_LOGI("[ENTER]");
+
+       if (NULL == callback) {
+               MWR_LOGE("[ERROR] Input parameter is NULL");
+               return -1;
+       }
+
+       g_loaded_engine_changed_cb = callback;
+       g_loaded_engine_changed_user_data = user_data;
+
+       MWR_LOGD("[END]");
+       return 0;
+}
+
 int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
 {
        if (nullptr == g_wakeup_manager) return -1;
@@ -922,3 +945,10 @@ void CSettingValueObserver::on_value_changed()
                g_setting_changed_cb(g_setting_changed_user_data);
        }
 }
+
+void CSettingValueObserver::on_loaded_wakeup_engine_changed()
+{
+       if (g_loaded_engine_changed_cb) {
+               g_loaded_engine_changed_cb(g_loaded_engine_changed_user_data);
+       }
+}

diff --git a/plugins/wakeup-manager/src/wakeup_settings.cpp b/plugins/wakeup-manager/src/wakeup_settings.cpp
index 329d4c3..bb90051 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_settings.cpp
+++ b/plugins/wakeup-manager/src/wakeup_settings.cpp
@@ -125,6 +125,23 @@ static void wakeup_setting_default_assistant_appid_changed_cb(keynode_t* node, v
        }
 }
 
+static void wakeup_setting_multiple_mode_changed_cb(keynode_t* node, void* data)
+{
+       MWR_LOGD("[ENTER]");
+
+       CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
+       if (nullptr == settings) return;
+
+       const auto& observers = settings->get_observers();
+       for (const auto& observer : observers) {
+               if (observer) {
+                       if (!observer->on_multiple_mode_changed()) {
+                               LOGW("[Settings WARNING] One of the observer returned false");
+                       }
+               }
+       }
+}
+
 void CWakeupSettings::initialize()
 {
        int vconf_ret;
@@ -227,6 +244,8 @@ void CWakeupSettings::initialize()
                vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS,
                        wakeup_setting_enabled_assistants_changed_cb, this);
        }
+       vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
+               wakeup_setting_multiple_mode_changed_cb, this);
 }
 
 void CWakeupSettings::deinitialize()
@@ -239,6 +258,8 @@ void CWakeupSettings::deinitialize()
                vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS,
                        wakeup_setting_enabled_assistants_changed_cb);
        }
+       vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
+               wakeup_setting_multiple_mode_changed_cb);
 }
 
 void CWakeupSettings::subscribe(ISettingsEventObserver *observer)

diff --git a/src/service_main.cpp b/src/service_main.cpp
index 4d381a4..c670fdd 100644 (file)
--- a/src/service_main.cpp
+++ b/src/service_main.cpp
@@ -1427,6 +1427,11 @@ void CServiceMain::app_terminate(void *data)
        return;
 }
 
+void CServiceMain::app_restart()
+{
+       service_app_exit();
+}
+
 int CServiceMain::on_initialize(pid_t pid, std::string sender_info) {
        MAS_LOGD("[Enter] pid(%d)", pid);
 

diff --git a/src/service_plugin.cpp b/src/service_plugin.cpp
index 4024a74..a24989d 100644 (file)
--- a/src/service_plugin.cpp
+++ b/src/service_plugin.cpp
@@ -588,6 +588,19 @@ static void __wakeup_service_voice_key_status_changed_cb(ma_voice_key_status_e s
        }
 }
 
+static void __loaded_engine_changed_cb(void* user_data)
+{
+       MAS_LOGD("[SUCCESS] __loaded_engine_changed_cb is called");
+
+       CServicePlugin *plugin = static_cast<CServicePlugin*>(user_data);
+       if (nullptr == plugin) return;
+
+       CServiceMain* service_main = plugin->get_service_main();
+       if (service_main) {
+               service_main->app_restart();
+       }
+}
+
 int CServicePlugin::initialize(void)
 {
        MAS_LOGD("[Enter]");
@@ -733,6 +746,9 @@ int CServicePlugin::initialize(void)
        mWakeupManagerInterface.set_voice_key_status_changed_callback =
                (wakeup_manager_set_voice_key_status_changed_callback)dlsym(mPluginHandle,
                MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_STATUS_CHANGED_CALLBACK);
+       mWakeupManagerInterface.set_loaded_engine_changed_callback =
+               (wakeup_manager_set_loaded_engine_changed_callback)dlsym(mPluginHandle,
+               MA_WAKEUP_MANAGER_FUNC_SET_LOADED_ENGINE_CHANGED_CALLBACK);
 
        int ret = -1;
        if (NULL != mPluginHandle) {
@@ -1402,6 +1418,12 @@ int CServicePlugin::set_callbacks(void)
                return ret;
        }
 
+       ret = set_loaded_engine_changed_callback(__loaded_engine_changed_cb, this);
+       if (0 != ret) {
+               MAS_LOGE("Fail to set loaded engine changed cb");
+               return ret;
+       }
+
        return 0;
 }
 
@@ -1600,3 +1622,19 @@ int CServicePlugin::set_voice_key_status_changed_callback(wakeup_service_voice_k
        return ret;
 }
 
+int CServicePlugin::set_loaded_engine_changed_callback(wakeup_service_loaded_engine_changed_cb callback, void* user_data)
+{
+       int ret = -1;
+       if (NULL != mPluginHandle) {
+               wakeup_manager_set_loaded_engine_changed_callback func = mWakeupManagerInterface.set_loaded_engine_changed_callback;
+               if (NULL == func) {
+                       MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_LOADED_ENGINE_CHANGED_CALLBACK);
+               } else {
+                       ret = func(callback, user_data);
+                       if (0 != ret) {
+                               MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
+                       }
+               }
+       }
+       return ret;
+}