Add the new API for sending wakeup_word

Change-Id: Idfac593bbc829a25036fa9093bb219e157cf1d2d

diff --git a/inc/service_ipc_dbus.h b/inc/service_ipc_dbus.h
index 1089091..d9102e5 100644 (file)
--- a/inc/service_ipc_dbus.h
+++ b/inc/service_ipc_dbus.h
@@ -34,7 +34,9 @@ public:
        int send_hello(pid_t pid);
        int send_error_message(int reason, const char* err_msg);
        int send_streaming_audio_data(pid_t pid, int event, void* data, unsigned int data_size);
-       int change_active_state(pid_t pid, int state);
+       int change_active_state(pid_t pid, int state, const char* wakeup_word,
+               const unsigned char* wakeup_extra_data, size_t wakeup_extra_data_length,
+               const char* wakeup_extra_data_desc);
        int send_preprocessing_information(pid_t pid, const char* app_id);
        int send_streaming_section_changed(pid_t pid, int section);
        int send_preprocessing_result(pid_t pid, bool result);

diff --git a/inc/service_main.h b/inc/service_main.h
index c3fc791..fc0344b 100644 (file)
--- a/inc/service_main.h
+++ b/inc/service_main.h
@@ -19,6 +19,7 @@
 #define __SERVICE_MAIN_H__
 
 #include <string>
+#include <vector>
 
 #include <dlog/dlog.h>
 #include <multi_assistant.h>
@@ -114,14 +115,19 @@ public:
        const char* get_client_appid_by_wakeup_word(const char *wakeup_word);
        int set_current_client_by_wakeup_word(const char *wakeup_word);
        int set_current_client_by_appid(const char *appid);
-       int launch_client_by_wakeup_word(const char *wakeup_word);
+       int launch_client_by_wakeup_word(const char *wakeup_word,
+               const unsigned char* extra_data, size_t extra_data_length, const char *extra_data_desc);
        int prelaunch_default_assistant();
        int set_current_service_state(ma_service_state_e state);
        int bring_client_to_foreground(const char* appid);
        ma_service_state_e get_current_service_state();
-       int launch_client_by_appid(const char *appid, CLIENT_LAUNCH_MODE launch_mode);
+       int launch_client_by_appid(const char *appid, const char *word,
+               const unsigned char *extra_data, size_t extra_data_length, const char *extra_data_desc,
+               CLIENT_LAUNCH_MODE launch_mode);
        int process_preprocessing_state_event(PREPROCESSING_STATE_EVENT event);
        int update_voice_key_support_mode();
+       int get_current_wakeup_word(char** wakeup_word);
+       int set_current_wakeup_word(const char *wakeup_word);
 
        int on_initialize(pid_t pid, std::string sender_info) override;
        int on_deinitialize(pid_t pid, std::string sender_info) override;
@@ -175,7 +181,14 @@ private:
 
        int mCurrentClientInfo{0};
        int mCurrentPreprocessingClientInfo{-1};
-       std::string mWakeupClientAppId;
+
+       typedef struct {
+               std::string wakeupAppId;
+               std::string wakeupWord;
+               std::vector<unsigned char> extraData;
+               std::string extraDataDesc;
+       } WakeupInfo;
+       WakeupInfo mLastWakeupInfo;
 
        CPackageUpdateEventObserver mPackageUpdateEventObserver;
        CPackageUpdateMonitor mPackageUpdateMonitor{mPackageUpdateEventObserver, mClientInfo};

diff --git a/plugins/wakeup-manager/inc/wakeup_policy_default.h b/plugins/wakeup-manager/inc/wakeup_policy_default.h
index c0c6efa..5293273 100644 (file)
--- a/plugins/wakeup-manager/inc/wakeup_policy_default.h
+++ b/plugins/wakeup-manager/inc/wakeup_policy_default.h
@@ -36,6 +36,7 @@ typedef struct {
        std::string wakeup_voice_id;
        std::string wakeup_engine;
 
+       std::vector<unsigned char> extra_data;
        std::string extra_data_description;
        mas_wakeup_event_info info;
 } mas_wakeup_event_info_wrapper;

diff --git a/plugins/wakeup-manager/src/wakeup_policy_default.cpp b/plugins/wakeup-manager/src/wakeup_policy_default.cpp
index ef1bab5..ab8d01f 100644 (file)
--- a/plugins/wakeup-manager/src/wakeup_policy_default.cpp
+++ b/plugins/wakeup-manager/src/wakeup_policy_default.cpp
@@ -83,7 +83,11 @@ void CWakeupPolicyDefault::wakeup_candidate(mas_wakeup_event_info wakeup_info)
        if (wakeup_info.wakeup_engine) wrapper.wakeup_engine = wakeup_info.wakeup_engine;
        if (wakeup_info.extra_data_description) wrapper.extra_data_description = wakeup_info.extra_data_description;
 
-       wrapper.info = wakeup_info;
+       if (wakeup_info.extra_data && wakeup_info.extra_data_length > 0) {
+               wrapper.extra_data.assign(
+                       (unsigned char*)wakeup_info.extra_data,
+                       (unsigned char*)wakeup_info.extra_data + wakeup_info.extra_data_length);
+       }
 
        LOGI("wake word : %s", wakeup_info.wakeup_word);
        mWakeupInfos.push_back(wrapper);
@@ -129,6 +133,8 @@ void CWakeupPolicyDefault::timer_expired()
        selected.info.wakeup_language = selected.wakeup_language.c_str();
        selected.info.wakeup_voice_id = selected.wakeup_voice_id.c_str();
        selected.info.wakeup_engine = selected.wakeup_engine.c_str();
+       selected.info.extra_data = selected.extra_data.data();
+       selected.info.extra_data_length = selected.extra_data.size();
        selected.info.extra_data_description = selected.extra_data_description.c_str();
 
        if (mImpl) mImpl->wakeup(selected.info);

diff --git a/src/service_ipc_dbus.cpp b/src/service_ipc_dbus.cpp
index 04ba438..d5cbcc3 100644 (file)
--- a/src/service_ipc_dbus.cpp
+++ b/src/service_ipc_dbus.cpp
@@ -348,7 +348,9 @@ int CServiceIpcDbus::send_streaming_audio_data(pid_t pid, int event, void* data,
        return 0;
 }
 
-int CServiceIpcDbus::change_active_state(pid_t pid, int state)
+int CServiceIpcDbus::change_active_state(pid_t pid, int state, const char* wakeup_word,
+       const unsigned char* wakeup_extra_data, size_t wakeup_extra_data_length,
+       const char* wakeup_extra_data_desc)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -376,8 +378,24 @@ int CServiceIpcDbus::change_active_state(pid_t pid, int state)
                MAS_LOGD(">>>> Request mas send activate message : %s", service_name);
        }
 
+       char* temp_wakeup_word = NULL;
+       if (!wakeup_word)
+               temp_wakeup_word = strdup("#NULL");
+       else
+               temp_wakeup_word = strdup(wakeup_word);
+
+       char* temp_wakeup_extra_data_desc = NULL;
+       if (!wakeup_extra_data_desc)
+               temp_wakeup_extra_data_desc = strdup("#NULL");
+       else
+               temp_wakeup_extra_data_desc = strdup(wakeup_extra_data_desc);
+
        if (TRUE != dbus_message_append_args(msg,
                DBUS_TYPE_INT32, &state,
+               DBUS_TYPE_STRING, &temp_wakeup_word,
+               DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+               &wakeup_extra_data, wakeup_extra_data_length,
+               DBUS_TYPE_STRING, &temp_wakeup_extra_data_desc,
                DBUS_TYPE_INVALID)) {
                dbus_message_unref(msg);
                MAS_LOGE("[ERROR] Fail to append args");
@@ -395,6 +413,13 @@ int CServiceIpcDbus::change_active_state(pid_t pid, int state)
        }
 
        dbus_message_unref(msg);
+
+       if (temp_wakeup_word)
+               free(temp_wakeup_word);
+
+       if (temp_wakeup_extra_data_desc)
+               free(temp_wakeup_extra_data_desc);
+
        return 0;
 }
 

diff --git a/src/service_main.cpp b/src/service_main.cpp
index 70a7b3e..4d381a4 100644 (file)
--- a/src/service_main.cpp
+++ b/src/service_main.cpp
@@ -548,7 +548,7 @@ int CServiceMain::ui_client_change_assistant(const char* appid)
                        client_send_voice_key_status_change(pid, mLastVoiceKeyStatus);
                }
 
-               mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_ACTIVE);
+               mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_ACTIVE, nullptr, nullptr, 0, nullptr);
                MAS_LOGD("MA Client with appid %s exists, requesting speech data", (appid ? appid : "NULL"));
                /*
                int ret = mServicePlugin.start_streaming_utterance_data();
@@ -567,7 +567,8 @@ int CServiceMain::ui_client_change_assistant(const char* appid)
                                0 < strlen(items[loop].appid) &&
                                0 < strlen(items[loop].wakeup_word[0])) {
                                if (strncmp(appid, items[loop].appid, MAX_APPID_LEN) == 0) {
-                                       launch_client_by_appid(items[loop].appid, CLIENT_LAUNCH_MODE_ACTIVATION);
+                                       launch_client_by_appid(items[loop].appid, nullptr,
+                                               nullptr, 0, nullptr, CLIENT_LAUNCH_MODE_ACTIVATION);
                                }
                        }
                }
@@ -717,7 +718,10 @@ int CServiceMain::initialize_service_plugin(void)
        mCurrentClientInfo = -1;
        MAS_LOGI("mCurrentClientInfo : %d", mCurrentClientInfo);
        mCurrentPreprocessingClientInfo = -1;
-       mWakeupClientAppId.clear();
+       mLastWakeupInfo.wakeupAppId.clear();
+       mLastWakeupInfo.wakeupWord.clear();
+       mLastWakeupInfo.extraData.clear();
+       mLastWakeupInfo.extraDataDesc.clear();
 
        if (0 == mServiceConfig.get_assistant_info(assistant_info_cb, this)) {
                for (int loop = 0; loop < MAX_MACLIENT_INFO_NUM; loop++) {
@@ -1003,7 +1007,7 @@ int CServiceMain::set_current_client_by_wakeup_word(const char *wakeup_word)
        if (mCurrentClientInfo != prev_selection) {
                if (prev_selection >= 0 && prev_selection < MAX_MACLIENT_INFO_NUM) {
                        pid_t pid = get_client_pid_by_appid(items[prev_selection].appid);
-                       mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE);
+                       mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE, nullptr, nullptr, 0, nullptr);
                        if (mLastDuckingRequester == pid) {
                                MAS_LOGE("Last ducking requester is deactivated, resetting background volume");
                                mServicePlugin.set_background_volume(items[prev_selection].appid, 1.0f);
@@ -1038,7 +1042,7 @@ int CServiceMain::set_current_client_by_appid(const char *appid)
        if (mCurrentClientInfo != prev_selection) {
                if (prev_selection >= 0 && prev_selection < MAX_MACLIENT_INFO_NUM) {
                        pid_t pid = get_client_pid_by_appid(items[prev_selection].appid);
-                       mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE);
+                       mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE, nullptr, nullptr, 0, nullptr);
                        if (mLastDuckingRequester == pid) {
                                MAS_LOGE("Last ducking requester is deactivated, resetting background volume");
                                mServicePlugin.set_background_volume(items[prev_selection].appid, 1.0f);
@@ -1050,9 +1054,11 @@ int CServiceMain::set_current_client_by_appid(const char *appid)
        return ret;
 }
 
-int CServiceMain::launch_client_by_appid(const char *appid, CLIENT_LAUNCH_MODE launch_mode)
+int CServiceMain::launch_client_by_appid(const char *appid, const char *word,
+       const unsigned char* extra_data, size_t extra_data_length, const char *extra_data_desc,
+       CLIENT_LAUNCH_MODE launch_mode)
 {
-       LOGI("[ENTER] %s", appid);
+       LOGI("[ENTER] %s %s", appid, word);
        int result = 0;
 
        if (NULL == appid || 0 == strlen(appid)) {
@@ -1078,12 +1084,22 @@ int CServiceMain::launch_client_by_appid(const char *appid, CLIENT_LAUNCH_MODE l
                        if (items[loop].used &&
                                0 < strlen(items[loop].appid)) {
                                if (strncmp(appid, items[loop].appid, MAX_APPID_LEN) == 0) {
-                                       mWakeupClientAppId = items[loop].appid;
+                                       mLastWakeupInfo.wakeupAppId = items[loop].appid;
+                                       mLastWakeupInfo.wakeupWord = (word ? word : "");
+                                       if (extra_data && extra_data_length > 0) {
+                                               mLastWakeupInfo.extraData.assign(extra_data, extra_data + extra_data_length);
+                                       } else {
+                                               mLastWakeupInfo.extraData.clear();
+                                       }
+                                       mLastWakeupInfo.extraDataDesc = (extra_data_desc ? extra_data_desc : "");
                                        found = true;
                                }
                        }
                }
-               MAS_LOGE("mWakeupClientAppId : %s, %d", mWakeupClientAppId.c_str(), found);
+               MAS_LOGE("mLastWakeupInfo.wakeupAppId : %s %s %p %zu %s, %d",
+                       mLastWakeupInfo.wakeupAppId.c_str(), mLastWakeupInfo.wakeupWord.c_str(),
+                       mLastWakeupInfo.extraData.data(), mLastWakeupInfo.extraData.size(),
+                       mLastWakeupInfo.extraDataDesc.c_str(), found);
        }
 
        return result;
@@ -1106,10 +1122,12 @@ int CServiceMain::bring_client_to_foreground(const char* appid)
        return ret;
 }
 
-int CServiceMain::launch_client_by_wakeup_word(const char *wakeup_word)
+int CServiceMain::launch_client_by_wakeup_word(const char *wakeup_word,
+       const unsigned char* extra_data, size_t extra_data_length, const char *extra_data_desc)
 {
        const char *appid = get_client_appid_by_wakeup_word(wakeup_word);
-       return launch_client_by_appid(appid, CLIENT_LAUNCH_MODE_ACTIVATION);
+       return launch_client_by_appid(appid, wakeup_word,
+               extra_data, extra_data_length, extra_data_desc, CLIENT_LAUNCH_MODE_ACTIVATION);
 }
 
 int CServiceMain::prelaunch_default_assistant()
@@ -1124,7 +1142,7 @@ int CServiceMain::prelaunch_default_assistant()
                        if (default_assistant &&
                                !(mApplicationManager.is_application_running(default_assistant))) {
                                MAS_LOGD("prelaunching default_assistant_appid : %s", default_assistant);
-                               launch_client_by_appid(default_assistant, CLIENT_LAUNCH_MODE_PRELAUNCH);
+                               launch_client_by_appid(default_assistant, nullptr, nullptr, 0, nullptr, CLIENT_LAUNCH_MODE_PRELAUNCH);
                        }
                }
        }
@@ -1377,7 +1395,8 @@ bool CServiceMain::app_create(void *data)
                mPreferenceManager.get_string(WAKEUP_SETTINGS_KEY_PREPROCESSING_ASSISTANT_APPID);
        if (preprocessing_assistant) {
                MAS_LOGD("prelaunching preprocessing_assistant_appid : %s", (*preprocessing_assistant).c_str());
-               launch_client_by_appid((*preprocessing_assistant).c_str(), CLIENT_LAUNCH_MODE_PRELAUNCH);
+               launch_client_by_appid((*preprocessing_assistant).c_str(), nullptr,
+                       nullptr, 0, nullptr, CLIENT_LAUNCH_MODE_PRELAUNCH);
        }
 
        mPackageUpdateMonitor.initialize();
@@ -1438,13 +1457,20 @@ int CServiceMain::on_initialize(pid_t pid, std::string sender_info) {
                if (current_maclient_appid && 0 == pid_appid.compare(current_maclient_appid)) {
                        MAS_LOGD("MA client with current maclient appid connected!");
 
-                       if (0 == mWakeupClientAppId.compare(pid_appid)) {
-                               mWakeupClientAppId.clear();
-                               mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_ACTIVE);
+                       if (0 == mLastWakeupInfo.wakeupAppId.compare(pid_appid)) {
+                               mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_ACTIVE,
+                                       mLastWakeupInfo.wakeupWord.c_str(),
+                                       mLastWakeupInfo.extraData.data(),
+                                       mLastWakeupInfo.extraData.size(),
+                                       mLastWakeupInfo.extraDataDesc.c_str());
                                process_preprocessing_state_event(PREPROCESSING_STATE_EVENT_ASSISTANT_ACTIVATED);
+                               mLastWakeupInfo.wakeupAppId.clear();
+                               mLastWakeupInfo.wakeupWord.clear();
+                               mLastWakeupInfo.extraData.clear();
+                               mLastWakeupInfo.extraDataDesc.clear();
                        } else {
-                               MAS_LOGE("[ERROR] mWakeupClientAppId and appid differ : %s %s",
-                                       mWakeupClientAppId.c_str(), pid_appid.c_str());
+                               MAS_LOGE("[ERROR] mLastWakeupInfo.wakeupAppId and appid differ : %s %s",
+                                       mLastWakeupInfo.wakeupAppId.c_str(), pid_appid.c_str());
                        }
                } else {
                        MAS_LOGD("MA client connected, but its appid does not match with current maclient");

diff --git a/src/service_plugin.cpp b/src/service_plugin.cpp
index 908cd9b..4024a74 100644 (file)
--- a/src/service_plugin.cpp
+++ b/src/service_plugin.cpp
@@ -39,7 +39,11 @@ static int g_last_wakeup_event_id = 0;
 
 typedef struct {
        int id;
-       void* data;
+       char* wakeup_word;
+       char* wakeup_appid;
+       unsigned char* extra_data;
+       size_t extra_data_length;
+       char* extra_data_desc;
        CServicePlugin* plugin;
 } AsyncParam;
 
@@ -91,17 +95,27 @@ static void process_wakeup_event_by_appid_timer(void* data)
 
        AsyncParam* param = static_cast<AsyncParam*>(data);
 
-       char* appid = static_cast<char*>(param->data);
-       MAS_LOGI("[ENTER] appid(%s), id(%d), g_last_wakeup_event_id(%d)",
-               appid, param->id, g_last_wakeup_event_id);
-
-       if (!appid) {
+       char* wakeup_word = param->wakeup_word;
+       char* wakeup_appid = param->wakeup_appid;
+       unsigned char *extra_data = param->extra_data;
+       size_t extra_data_length = param->extra_data_length;
+       char* extra_data_desc = param->extra_data_desc;
+       MAS_LOGI("[ENTER] appid(%s), word(%s), id(%d), g_last_wakeup_event_id(%d)",
+               wakeup_appid, wakeup_word, param->id, g_last_wakeup_event_id);
+
+       if (!wakeup_appid) {
+               if (param->wakeup_word) free(param->wakeup_word);
+               if (param->extra_data) free(param->extra_data);
+               if (param->extra_data_desc) free(param->extra_data_desc);
                delete param;
                return;
        }
 
        if (param->id < g_last_wakeup_event_id) {
-               free(param->data);
+               if (param->wakeup_word) free(param->wakeup_word);
+               if (param->wakeup_appid) free(param->wakeup_appid);
+               if (param->extra_data) free(param->extra_data);
+               if (param->extra_data_desc) free(param->extra_data_desc);
                delete param;
                return;
        }
@@ -117,27 +131,32 @@ static void process_wakeup_event_by_appid_timer(void* data)
        }
 
        if (service_ipc && service_main) {
-               bool use_custom_ui = service_main->get_client_custom_ui_option_by_appid(appid);
+               bool use_custom_ui = service_main->get_client_custom_ui_option_by_appid(wakeup_appid);
                bool ui_panel_enabled = false;
                if (param->plugin) ui_panel_enabled = param->plugin->is_ui_panel_enabled();
                if (ui_panel_enabled) {
                        service_ipc->masc_ui_dbus_enable_common_ui(!use_custom_ui);
-                       service_ipc->masc_ui_dbus_change_assistant(appid);
+                       service_ipc->masc_ui_dbus_change_assistant(wakeup_appid);
                }
 
-               service_main->set_current_client_by_appid(appid);
-               if ((pid = service_main->get_client_pid_by_appid(appid)) != -1) {
+               service_main->set_current_client_by_appid(wakeup_appid);
+               if ((pid = service_main->get_client_pid_by_appid(wakeup_appid)) != -1) {
                        service_main->client_send_preprocessing_information(pid);
-                       service_ipc->change_active_state(pid, MA_ACTIVE_STATE_ACTIVE);
+                       service_ipc->change_active_state(pid, MA_ACTIVE_STATE_ACTIVE, wakeup_word,
+                               extra_data, extra_data_length, extra_data_desc);
                        service_main->process_preprocessing_state_event(PREPROCESSING_STATE_EVENT_ASSISTANT_ACTIVATED);
                } else {
                        // Appropriate MA Client not available, trying to launch new one
-                       MAS_LOGI("MA Client with appid %s does not exist, launching client", appid);
-                       service_main->launch_client_by_appid(appid, CLIENT_LAUNCH_MODE_ACTIVATION);
+                       MAS_LOGI("MA Client with appid %s does not exist, launching client", wakeup_appid);
+                       service_main->launch_client_by_appid(wakeup_appid, wakeup_word,
+                               extra_data, extra_data_length, extra_data_desc, CLIENT_LAUNCH_MODE_ACTIVATION);
                }
        }
 
-       if (param->data) free(param->data);
+       if (param->wakeup_word) free(param->wakeup_word);
+       if (param->wakeup_appid) free(param->wakeup_appid);
+       if (param->extra_data) free(param->extra_data);
+       if (param->extra_data_desc) free(param->extra_data_desc);
        delete param;
 }
 
@@ -146,14 +165,25 @@ static void process_wakeup_event_by_word_timer(void* data)
        if (nullptr == data) return;
 
        AsyncParam* param = static_cast<AsyncParam*>(data);
-       MAS_LOGI("[ENTER] wakeword(%s), id(%d)", (const char*)(param->data), param->id);
+       MAS_LOGI("[ENTER] wakeword(%s), id(%d)", (const char*)(param->wakeup_word), param->id);
 
-       if (!param->data) {
+       if (!param->wakeup_word) {
+               if (param->wakeup_appid) free(param->wakeup_appid);
+               if (param->extra_data) free(param->extra_data);
+               if (param->extra_data_desc) free(param->extra_data_desc);
                delete param;
                return;
        }
 
-       char* wakeup_word = static_cast<char*>(param->data);
+       std::string wakeup_word{param->wakeup_word};
+       unsigned char *extra_data = nullptr;
+       size_t extra_data_length = param->extra_data_length;
+       if (param->extra_data && extra_data_length > 0) {
+               extra_data = (unsigned char*)malloc(extra_data_length);
+               if (extra_data)
+                       memcpy(extra_data, param->extra_data, extra_data_length);
+       }
+       std::string extra_data_desc{param->extra_data_desc};
        const char* appid = nullptr;
        int id = param->id;
        CServicePlugin* plugin = param->plugin;
@@ -162,11 +192,14 @@ static void process_wakeup_event_by_word_timer(void* data)
        if (plugin) {
                service_main = plugin->get_service_main();
                if (service_main) {
-                       appid = service_main->get_client_appid_by_wakeup_word(wakeup_word);
+                       appid = service_main->get_client_appid_by_wakeup_word(param->wakeup_word);
                }
        }
 
-       free(param->data);
+       if (param->wakeup_word) free(param->wakeup_word);
+       if (param->wakeup_appid) free(param->wakeup_appid);
+       if (param->extra_data) free(param->extra_data);
+       if (param->extra_data_desc) free(param->extra_data_desc);
        delete param;
        param = nullptr;
 
@@ -174,7 +207,11 @@ static void process_wakeup_event_by_word_timer(void* data)
                param = new(std::nothrow) AsyncParam;
                if (param) {
                        param->id = id;
-                       param->data = static_cast<void*>(strdup(appid));
+                       param->wakeup_word = strdup(wakeup_word.c_str());
+                       param->wakeup_appid = strdup(appid);
+                       param->extra_data = extra_data;
+                       param->extra_data_length = extra_data_length;
+                       param->extra_data_desc = strdup(extra_data_desc.c_str());
                        param->plugin = plugin;
                        process_wakeup_event_by_appid_timer(static_cast<void*>(param));
                }
@@ -189,8 +226,10 @@ static void __wakeup_event_cb(mas_wakeup_event_info wakeup_info, void* user_data
        MAS_LOGI("[SUCCESS] __wakeup_event_cb is called, wakeup_word(%s)", wakeup_info.wakeup_word);
        int ret = -1;
 
+       CServiceMain* service_main = nullptr;
        CServicePlugin *plugin = static_cast<CServicePlugin*>(user_data);
        if (plugin) {
+               service_main = plugin->get_service_main();
                CServiceIpcDbus* service_ipc = plugin->get_service_ipc();
                if (plugin->is_ui_panel_enabled() && service_ipc) {
                        int retry_cnt = 0;
@@ -256,11 +295,25 @@ static void __wakeup_event_cb(mas_wakeup_event_info wakeup_info, void* user_data
                ecore_thread_main_loop_end();
        }
 #endif /* - TEST_CODE */
+
        if (wakeup_info.wakeup_appid) {
                AsyncParam* param = new(std::nothrow) AsyncParam;
                if (param) {
                        param->id = ++g_last_wakeup_event_id;
-                       param->data = static_cast<void*>(strdup(wakeup_info.wakeup_appid));
+                       param->wakeup_word =
+                               wakeup_info.wakeup_word ? strdup(wakeup_info.wakeup_word) : nullptr;
+                       param->wakeup_appid = strdup(wakeup_info.wakeup_appid);
+                       if (wakeup_info.extra_data && wakeup_info.extra_data_length > 0) {
+                               param->extra_data = (unsigned char*)malloc(wakeup_info.extra_data_length);
+                               if (param->extra_data)
+                                       memcpy(param->extra_data, wakeup_info.extra_data, wakeup_info.extra_data_length);
+                               param->extra_data_length = wakeup_info.extra_data_length;
+                       } else {
+                               param->extra_data = nullptr;
+                               param->extra_data_length = 0;
+                       }
+                       param->extra_data_desc =
+                               wakeup_info.extra_data_description ? strdup(wakeup_info.extra_data_description) : nullptr;
                        param->plugin = static_cast<CServicePlugin*>(user_data);
                        ecore_main_loop_thread_safe_call_async(process_wakeup_event_by_appid_timer,
                                static_cast<void*>(param));
@@ -269,7 +322,19 @@ static void __wakeup_event_cb(mas_wakeup_event_info wakeup_info, void* user_data
                AsyncParam* param = new(std::nothrow) AsyncParam;
                if (param) {
                        param->id = ++g_last_wakeup_event_id;
-                       param->data = static_cast<void*>(strdup(wakeup_info.wakeup_word));
+                       param->wakeup_word = strdup(wakeup_info.wakeup_word);
+                       param->wakeup_appid = nullptr;
+                       if (wakeup_info.extra_data && wakeup_info.extra_data_length) {
+                               param->extra_data = (unsigned char*)malloc(wakeup_info.extra_data_length);
+                               if (param->extra_data)
+                                       memcpy(param->extra_data, wakeup_info.extra_data, wakeup_info.extra_data_length);
+                               param->extra_data_length = wakeup_info.extra_data_length;
+                       } else {
+                               param->extra_data = nullptr;
+                               param->extra_data_length = 0;
+                       }
+                       param->extra_data_desc  =
+                               wakeup_info.extra_data_description ? strdup(wakeup_info.extra_data_description) : nullptr;
                        param->plugin = static_cast<CServicePlugin*>(user_data);
                        ecore_main_loop_thread_safe_call_async(process_wakeup_event_by_word_timer,
                                static_cast<void*>(param));
@@ -354,6 +419,11 @@ static void __audio_streaming_cb(mas_speech_streaming_event_e event, void* buffe
                AsyncParam* param = new(std::nothrow) AsyncParam;
                if (param) {
                        param->plugin = plugin;
+                       param->wakeup_word = nullptr;
+                       param->wakeup_appid = nullptr;
+                       param->extra_data = nullptr;
+                       param->extra_data_length = 0;
+                       param->extra_data_desc = nullptr;
                        ecore_main_loop_thread_safe_call_async(
                                handle_speech_streaming_event_failure, static_cast<void*>(param));
                }