Add support for wakeup engine command transmission

Change-Id: I0588f24a03d888e15c952cd09bba60472f8e2074

diff --git a/inc/multi_assistant_main.h b/inc/multi_assistant_main.h
index 8acd240..3e2b2c1 100644 (file)
--- a/inc/multi_assistant_main.h
+++ b/inc/multi_assistant_main.h
@@ -81,6 +81,7 @@
 #define MAS_METHOD_SEND_PREPROCESSING_INFORMATION      "mas_method_send_preprocessing_information"
 #define MAS_METHOD_AUDIO_STREAMING_DATA_SECTION                "mas_method_audio_streaming_data_section"
 #define MAS_METHOD_SEND_PREPROCESSING_RESULT           "mas_method_send_preprocessing_result"
+#define MAS_METHOD_SEND_WAKEUP_ENGINE_COMMAND          "mas_method_send_wakeup_engine_command"
 
 #define MAS_UI_METHOD_SEND_ASR_RESULT                          "mas_ui_method_send_asr_result"
 #define MAS_UI_METHOD_SEND_RESULT                                      "mas_ui_method_send_result"

diff --git a/inc/multi_assistant_service_plugin.h b/inc/multi_assistant_service_plugin.h
index 48a9233..b225b29 100644 (file)
--- a/inc/multi_assistant_service_plugin.h
+++ b/inc/multi_assistant_service_plugin.h
@@ -177,6 +177,8 @@ typedef int (*wakeup_manager_set_setting_changed_callback)(wakeup_service_settin
 typedef int (*wakeup_manager_set_error_callback)(wakeup_service_error_cb callback, void* user_data);
 #define MA_WAKEUP_MANAGER_FUNC_SET_STREAMING_SECTION_CHANGED_CALLBACK "wakeup_manager_set_streaming_section_changed_callback"
 typedef int (*wakeup_manager_set_streaming_section_changed_callback)(wakeup_service_streaming_section_changed_cb callback, void* user_data);
+#define MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK "wakeup_manager_set_wakeup_engine_command_callback"
+typedef int (*wakeup_manager_set_wakeup_engine_command_callback)(wakeup_service_wakeup_engine_command_cb callback, void* user_data);
 
 typedef struct {
        wakeup_manager_initialize                                                                initialize;
@@ -213,6 +215,7 @@ typedef struct {
        wakeup_manager_set_setting_changed_callback                              set_setting_changed_callback;
        wakeup_manager_set_error_callback                                                set_error_callback;
        wakeup_manager_set_streaming_section_changed_callback    set_streaming_section_changed_callback;
+       wakeup_manager_set_wakeup_engine_command_callback                set_wakeup_engine_command_callback;
 } wakeup_manager_interface;
 
 #ifdef __cplusplus

diff --git a/inc/multi_wakeup_recognizer.h b/inc/multi_wakeup_recognizer.h
index b0732f9..f928720 100644 (file)
--- a/inc/multi_wakeup_recognizer.h
+++ b/inc/multi_wakeup_recognizer.h
@@ -105,6 +105,8 @@ typedef void (*wakeup_service_error_cb)(int error, const char* err_msg, void* us
 
 typedef void (*wakeup_service_streaming_section_changed_cb)(ma_audio_streaming_data_section_e section, void* user_data);
 
+typedef void (*wakeup_service_wakeup_engine_command_cb)(const char* assistant_name, const char* command, void* user_data);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/plugins/wakeup-manager/inc/wakeup_engine_manager.h b/plugins/wakeup-manager/inc/wakeup_engine_manager.h
index d9d478c..8789ee8 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_engine_manager.h
+++ b/plugins/wakeup-manager/inc/wakeup_engine_manager.h
@@ -84,6 +84,8 @@ typedef int (*wakeup_engine_set_speech_status_callback)(wakeup_service_speech_st
 typedef int (*wakeup_engine_set_error_callback)(wakeup_service_error_cb callback, void* user_data);
 #define MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_DATA_REQUIRE_STATUS_CALLBACK "wakeup_engine_set_audio_data_require_status_callback"
 typedef int (*wakeup_engine_set_audio_data_require_status_callback)(wakeup_service_audio_data_require_status_cb callback, void* user_data);
+#define MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK "wakeup_engine_set_wakeup_engine_command_callback"
+typedef int (*wakeup_engine_set_wakeup_engine_command_callback)(wakeup_service_engine_command_cb callback, void* user_data);
 
 /* Interfaces after version 1 */
 #define MA_WAKEUP_ENGINE_FUNC_GET_VERSION "wakeup_engine_get_version"
@@ -113,6 +115,7 @@ typedef struct {
        wakeup_engine_set_speech_status_callback                                set_speech_status_callback;
        wakeup_engine_set_error_callback                                                set_error_callback;
        wakeup_engine_set_audio_data_require_status_callback    set_audio_data_require_status_callback;
+       wakeup_engine_set_wakeup_engine_command_callback                set_wakeup_engine_command_callback;
 } wakeup_engine_interface;
 
 class IEngineEventObserver
@@ -127,6 +130,7 @@ public:
        virtual bool on_streaming_audio_data(
                wakeup_speech_streaming_event_e event, void* buffer, unsigned int len) = 0;
        virtual bool on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) = 0;
+       virtual bool on_wakeup_engine_command(string assistant_name, string command) = 0;
 };
 
 class CWakeupEngineManager
@@ -169,6 +173,7 @@ public:
        bool on_speech_status(string engine_name, wakeup_service_speech_status_e status);
        bool on_error(string engine_name, int error_code, string error_message);
        bool on_audio_data_require_status(string engine_name, bool require);
+       bool on_wakeup_engine_command(string engine_name, string assistant_name, string command);
 private:
        typedef struct {
                int version;

diff --git a/plugins/wakeup-manager/inc/wakeup_manager.h b/plugins/wakeup-manager/inc/wakeup_manager.h
index c6623a2..ef2574d 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_manager.h
+++ b/plugins/wakeup-manager/inc/wakeup_manager.h
@@ -48,6 +48,7 @@ public:
        virtual void on_streaming_audio_data(
                wakeup_speech_streaming_event_e event, void* buffer, unsigned int len) = 0;
        virtual void on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) = 0;
+       virtual void on_wakeup_engine_command(const char* assistant_name, const char* command) = 0;
 };
 
 class ISettingValueObserver {
@@ -138,6 +139,7 @@ private:
                bool on_streaming_audio_data(
                        wakeup_speech_streaming_event_e event, void* buffer, unsigned int len) override;
                bool on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) override;
+               bool on_wakeup_engine_command(string assistant_name, string command) 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 d6d20a5..561d855 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h
+++ b/plugins/wakeup-manager/inc/wakeup_manager_wrapper.h
@@ -71,6 +71,8 @@ typedef void (*wakeup_service_audio_data_require_status_cb)(bool require, void*
 
 typedef void (*wakeup_service_streaming_section_changed_cb)(ma_audio_streaming_data_section_e section, void* user_data);
 
+typedef void (*wakeup_service_engine_command_cb)(const char* assistant_name, const char* command, void* user_data);
+
 typedef enum {
        MA_PLUGIN_EVENT_VOICE_KEY_PRESSED = 0,
        MA_PLUGIN_EVENT_VOICE_KEY_RELEASED,
@@ -156,6 +158,8 @@ EXPORT_API int wakeup_manager_set_error_callback(wakeup_service_error_cb callbac
 
 EXPORT_API int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data);
 
+EXPORT_API int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data);
+
 /* Internal API declarations for dependency modules */
 
 int wakeup_manager_feed_audio_data(wakeup_speech_streaming_event_e event, void* buffer, int len);

diff --git a/plugins/wakeup-manager/src/wakeup_engine_manager.cpp b/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
index 896057f..d9f6d7e 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
+++ b/plugins/wakeup-manager/src/wakeup_engine_manager.cpp
@@ -99,6 +99,9 @@ void CWakeupEngineManager::deinitialize()
                        if (info.interface.set_audio_data_require_status_callback) {
                                info.interface.set_audio_data_require_status_callback(nullptr, nullptr);
                        }
+                       if (info.interface.set_wakeup_engine_command_callback) {
+                               info.interface.set_wakeup_engine_command_callback(nullptr, nullptr);
+                       }
                        MWR_LOGI("Trying to deinitialize engine : %s", info.engine_name.c_str());
                        if (info.interface.deinitialize) {
                                int ret = info.interface.deinitialize();
@@ -587,6 +590,30 @@ bool CWakeupEngineManager::on_audio_data_require_status(string engine_name, bool
        return true;
 }
 
+bool CWakeupEngineManager::on_wakeup_engine_command(string engine_name, string assistant_name, string command)
+{
+       MWR_LOGD("[ENTER]");
+
+       for (const auto& observer : mObservers) {
+               if (observer) {
+                       const auto& iter = find_if(mEngineInfo.begin(), mEngineInfo.end(),
+                               [engine_name](const EngineInfo& info) {
+                                       return (0 == info.engine_name.compare(engine_name));
+                               });
+                       if (mEngineInfo.end() != iter) {
+                               for (const auto& assistant : iter->assistant_list) {
+                                       if (0 == assistant_name.compare(assistant) || 0 == assistant_name.length())
+                                       if (!observer->on_wakeup_engine_command(assistant, command)) {
+                                               LOGE("[Recorder WARNING] One of the observer returned false");
+                                       }
+                               }
+                       }
+               }
+       }
+
+       return true;
+}
+
 void CWakeupEngineManager::add_engine(string name, string path)
 {
        MWR_LOGD("Name (%s), Filepath(%s)", name.c_str(), path.c_str());
@@ -667,6 +694,9 @@ void CWakeupEngineManager::add_engine(string name, string path)
        info.interface.set_audio_data_require_status_callback =
                (wakeup_engine_set_audio_data_require_status_callback)dlsym(info.engine_handle,
                MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_DATA_REQUIRE_STATUS_CALLBACK);
+       info.interface.set_wakeup_engine_command_callback =
+               (wakeup_engine_set_wakeup_engine_command_callback)dlsym(info.engine_handle,
+               MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK);
 
        /* Interfaces after version 1 */
        info.interface.get_version =
@@ -722,6 +752,18 @@ void CWakeupEngineManager::add_engine(string name, string path)
                                }, &(callback_user_data.back()));
                }
 
+               if (info.interface.set_wakeup_engine_command_callback) {
+                       info.interface.set_wakeup_engine_command_callback(
+                               [](const char* assistant_name, const char* command, void* user_data) {
+                                       CallbackUserData* data = static_cast<CallbackUserData*>(user_data);
+                                       if (nullptr == data) return;
+                                       if (nullptr == data->manager) return;
+                                       if (nullptr == command) return;
+                                       data->manager->on_wakeup_engine_command(
+                                               data->engine_name, (assistant_name ? assistant_name : ""), command);
+                               }, &(callback_user_data.back()));
+               }
+
                if (info.interface.initialize) {
                        info.interface.initialize();
                }

diff --git a/plugins/wakeup-manager/src/wakeup_manager.cpp b/plugins/wakeup-manager/src/wakeup_manager.cpp
index 1b89605..d0b0e05 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_manager.cpp
+++ b/plugins/wakeup-manager/src/wakeup_manager.cpp
@@ -909,6 +909,19 @@ bool CWakeupManager::CEngineEventObserver::on_audio_streaming_data_section(
        return true;
 }
 
+bool CWakeupManager::CEngineEventObserver::on_wakeup_engine_command(
+       string assistant_name, string command)
+{
+       if (nullptr == mWakeupManager) return false;
+
+       vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+       for (const auto& observer : observers) {
+               observer->on_wakeup_engine_command(assistant_name.c_str(), command.c_str());
+       }
+
+       return true;
+}
+
 void CWakeupManager::CPolicyEventObserver::on_wakeup(wakeup_event_info wakeup_info)
 {
        if (nullptr == mWakeupManager) return;

diff --git a/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp b/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
index 0d30121..5e041ee 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
+++ b/plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp
@@ -45,12 +45,16 @@ static void* g_error_user_data;
 static wakeup_service_streaming_section_changed_cb g_streaming_section_changed_cb;
 static void* g_streaming_section_changed_user_data;
 
+static wakeup_service_engine_command_cb g_wakeup_engine_command_cb;
+static void* g_wakeup_engine_command_user_data;
+
 class CWakeupEventObserver : public IWakeupEventObserver
 {
        void on_wakeup(wakeup_event_info wakeup_info) override;
        void on_streaming_audio_data(
                wakeup_speech_streaming_event_e event, void* buffer, unsigned int len) override;
        void on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) override;
+       void on_wakeup_engine_command(const char* assistant_name, const char* command) override;
 };
 
 class CSettingValueObserver : public ISettingValueObserver
@@ -99,6 +103,12 @@ int wakeup_manager_initialize(void)
        g_error_cb = NULL;
        g_error_user_data = NULL;
 
+       g_streaming_section_changed_cb = NULL;
+       g_streaming_section_changed_user_data = NULL;
+
+       g_wakeup_engine_command_cb = NULL;
+       g_wakeup_engine_command_user_data = NULL;
+
        g_wakeup_manager->initialize();
 
        MWR_LOGD("[END]");
@@ -617,6 +627,23 @@ int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streami
        return 0;
 }
 
+int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data)
+{
+       MWR_LOGD("[ENTER]");
+
+       if (NULL == callback) {
+               MWR_LOGE("[ERROR] Input parameter is NULL");
+               return -1;
+       }
+
+       g_wakeup_engine_command_cb = callback;
+       g_wakeup_engine_command_user_data = user_data;
+
+       MWR_LOGD("[END]");
+       return 0;
+}
+
+
 int wakeup_manager_feed_audio_data(wakeup_speech_streaming_event_e event, void* buffer, int len)
 {
        if (nullptr == g_wakeup_manager) return -1;
@@ -655,6 +682,14 @@ void CWakeupEventObserver::on_audio_streaming_data_section(
        }
 }
 
+void CWakeupEventObserver::on_wakeup_engine_command(
+       const char* assistant_name, const char* command)
+{
+       if (g_wakeup_engine_command_cb) {
+               g_wakeup_engine_command_cb(assistant_name, command, g_wakeup_engine_command_user_data);
+       }
+}
+
 void CSettingValueObserver::on_value_changed()
 {
        if (g_setting_changed_cb) {

diff --git a/src/multi_assistant_dbus.c b/src/multi_assistant_dbus.c
index 53130d8..e1ee0a6 100644 (file)
--- a/src/multi_assistant_dbus.c
+++ b/src/multi_assistant_dbus.c
@@ -447,6 +447,71 @@ int masc_dbus_send_preprocessing_result(int pid, bool result)
        return 0;
 }
 
+int masc_dbus_send_wakeup_engine_command(int pid, const char* command)
+{
+       if (0 != __dbus_check()) {
+               return -1; //MAS_ERROR_OPERATION_FAILED;
+       }
+
+       DBusMessage* msg;
+
+       DBusError err;
+       dbus_error_init(&err);
+
+       char service_name[64];
+       memset(service_name, '\0', 64);
+       snprintf(service_name, 64, "%s_%d", MA_CLIENT_SERVICE_NAME, pid);
+
+       msg = dbus_message_new_method_call(
+                       service_name,
+                       MA_CLIENT_SERVICE_OBJECT_PATH,
+                       MA_CLIENT_SERVICE_INTERFACE,
+                       MAS_METHOD_SEND_WAKEUP_ENGINE_COMMAND);
+
+       static int count = 0;
+       if (NULL == msg) {
+               MAS_LOGE(">>>> Request mas send wakeup engine command : Fail to make message");
+               return -1; // MAS_ERROR_OPERATION_FAILED;
+       } else {
+               MAS_LOGD(">>>> Request mas send wakeup engine command : %s", service_name);
+       }
+
+       char* temp_command = NULL;
+       if (!command)
+               temp_command = strdup("#NULL");
+       else
+               temp_command = strdup(command);
+
+       if (true != dbus_message_append_args(msg,
+               DBUS_TYPE_STRING, &temp_command,
+               DBUS_TYPE_INVALID)) {
+               dbus_message_unref(msg);
+               MAS_LOGE("[ERROR] Fail to append args");
+               if (temp_command)
+                       free(temp_command);
+               return -1;
+       }
+
+       dbus_message_set_no_reply(msg, TRUE);
+
+       if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+               MAS_LOGE("[Dbus ERROR] Fail to Send");
+               if (temp_command)
+                       free(temp_command);
+               return -1; // MAS_ERROR_OPERATION_FAILED;
+       } else {
+               MAS_LOGD("[Dbus DEBUG] Success to Send wakeup_engine_command : %s", command);
+               dbus_connection_flush(g_conn_sender);
+       }
+
+       dbus_message_unref(msg);
+
+       if (temp_command)
+               free(temp_command);
+
+       return 0;
+}
+
 int masc_ui_dbus_send_hello(void)
 {
        if (0 != __dbus_check()) {

diff --git a/src/multi_assistant_service_plugin.c b/src/multi_assistant_service_plugin.c
index e7640f6..3af09f0 100644 (file)
--- a/src/multi_assistant_service_plugin.c
+++ b/src/multi_assistant_service_plugin.c
@@ -354,6 +354,19 @@ static void __streaming_section_changed_cb(ma_audio_streaming_data_section_e sec
        }
 }
 
+static void __wakeup_engine_command_cb(const char* assistant_name, const char* command, void* user_data)
+{
+       MAS_LOGD( "[SUCCESS] __wakeup_engine_command_cb is called, command(%s)", command);
+
+       int pid = mas_get_client_pid_by_appid(assistant_name);
+       if (-1 != pid) {
+               int ret = masc_dbus_send_wakeup_engine_command(pid, command);
+               if (0 != ret) {
+                       MAS_LOGE("[ERROR] Fail to send wakeup engine command, ret(%d)", ret);
+               }
+       }
+}
+
 int multi_assistant_service_plugin_initialize(void)
 {
        MAS_LOGD( "[Enter]");
@@ -472,6 +485,9 @@ int multi_assistant_service_plugin_initialize(void)
        _wakeup_manager_interface.set_streaming_section_changed_callback =
                (wakeup_manager_set_streaming_section_changed_callback)dlsym(g_handle,
                MA_WAKEUP_MANAGER_FUNC_SET_STREAMING_SECTION_CHANGED_CALLBACK);
+       _wakeup_manager_interface.set_wakeup_engine_command_callback =
+               (wakeup_manager_set_wakeup_engine_command_callback)dlsym(g_handle,
+               MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK);
 
        int ret = -1;
        if (NULL != g_handle) {
@@ -1046,6 +1062,12 @@ int multi_assistant_service_plugin_set_callbacks(void)
                return ret;
        }
 
+       ret = multi_assistant_service_plugin_set_wakeup_engine_command_callback(__wakeup_engine_command_cb, NULL);
+       if (0 != ret) {
+               MAS_LOGE("Fail to set wakeup engine command cb");
+               return ret;
+       }
+
        return 0;
 }
 
@@ -1192,3 +1214,20 @@ int multi_assistant_service_plugin_set_streaming_section_changed_callback(wakeup
        }
        return ret;
 }
+
+int multi_assistant_service_plugin_set_wakeup_engine_command_callback(wakeup_service_wakeup_engine_command_cb callback, void* user_data)
+{
+       int ret = -1;
+       if (NULL != g_handle) {
+               wakeup_manager_set_wakeup_engine_command_callback func = _wakeup_manager_interface.set_wakeup_engine_command_callback;
+               if (NULL == func) {
+                       MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK);
+               } else {
+                       ret = func(callback, user_data);
+                       if (0 != ret) {
+                               MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
+                       }
+               }
+       }
+       return ret;
+}
\ No newline at end of file