vconf
pkgmgr-info
jsoncpp
+ capi-media-audio-io
+ capi-media-sound-manager
+ eina
)
# SET FLAG ---------------------------------------------------------------------------------------
LINK_DIRECTORIES(${CMAKE_SOURCE_DIR}/lib)
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src)
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/inc)
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/wakeup-manager/inc)
SET(SRCS
src/service_config.cpp
src/service_ipc_dbus.cpp
src/service_ipc_dbus_dispatcher.cpp
src/main.cpp
+ wakeup-manager/src/wakeup_manager.cpp
+ wakeup-manager/src/wakeup_settings.cpp
+ wakeup-manager/src/wakeup_policy.cpp
+ wakeup-manager/src/wakeup_policy_default.cpp
+ wakeup-manager/src/wakeup_policy_external.cpp
+ wakeup-manager/src/wakeup_audio_manager.cpp
+ wakeup-manager/src/wakeup_engine_manager.cpp
+ wakeup-manager/src/wakeup_manager_wrapper.cpp
+ wakeup-manager/src/dependency_resolver.cpp
+ wakeup-manager/src/heap_tracer.cpp
+ wakeup-manager/src/assistant_config_manager.cpp
)
ADD_EXECUTABLE(${BINNAME} ${SRCS})
#include "service_ipc_dbus.h"
#include "service_plugin_interface.h"
+#include "wakeup_manager_wrapper.h"
+
class CServiceMain;
class CServicePlugin {
FILE* mDumpFile{NULL};
int mDumpCount{1};
#endif
-
- void* mPluginHandle{NULL};
-
- wakeup_manager_interface mWakeupManagerInterface{NULL, };
ma_plugin_settings* mPluginSettings{NULL};
CServiceIpcDbus* mServiceIpc{nullptr};
#include <tzplatform_config.h>
-typedef struct {
- int plugin_version;
- bool ui_panel_enabled;
-} ma_plugin_settings;
-
#define MA_WAKEUP_MANAGER_PATH tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_SHARE"), "multiassistant/")
-#define MA_DEFAULT_WAKEUP_MANAGER_FILENAME "libma-wakeup-manager.so"
-
-#define MA_WAKEUP_MANAGER_FUNC_INITIALIZE "wakeup_manager_initialize"
-typedef int (*wakeup_manager_initialize)(void);
-#define MA_WAKEUP_MANAGER_FUNC_DEINITIALIZE "wakeup_manager_deinitialize"
-typedef int (*wakeup_manager_deinitialize)(void);
-#define MA_WAKEUP_MANAGER_FUNC_GET_SETTINGS "wakeup_manager_get_settings"
-typedef int (*wakeup_manager_get_settings)(ma_plugin_settings **settings, size_t *struct_size);
-#define MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_WORD "wakeup_manager_add_assistant_wakeup_word"
-typedef int (*wakeup_manager_add_assistant_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
-#define MA_WAKEUP_MANAGER_FUNC_REMOVE_ASSISTANT_WAKEUP_WORD "wakeup_manager_remove_assistant_wakeup_word"
-typedef int (*wakeup_manager_remove_assistant_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
-#define MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_LANGUAGE "wakeup_manager_add_assistant_language"
-typedef int (*wakeup_manager_add_assistant_language)(const char* appid, const char* language);
-#define MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_ENGINE "wakeup_manager_add_assistant_wakeup_engine"
-typedef int (*wakeup_manager_add_assistant_wakeup_engine)(const char* appid, const char* engine);
-#define MA_WAKEUP_MANAGER_FUNC_SET_DEFAULT_ASSISTANT "wakeup_manager_set_default_assistant"
-typedef int (*wakeup_manager_set_default_assistant)(const char* appid);
-#define MA_WAKEUP_MANAGER_FUNC_GET_DEFAULT_ASSISTANT "wakeup_manager_get_default_assistant"
-typedef int (*wakeup_manager_get_default_assistant)(const char** appid);
-#define MA_WAKEUP_MANAGER_FUNC_SET_LANGUAGE "wakeup_manager_set_language"
-typedef int (*wakeup_manager_set_language)(const char* language);
-#define MA_WAKEUP_MANAGER_FUNC_ACTIVATE "wakeup_manager_activate"
-typedef int (*wakeup_manager_activate)(void);
-#define MA_WAKEUP_MANAGER_FUNC_DEACTIVATE "wakeup_manager_deactivate"
-typedef int (*wakeup_manager_deactivate)(void);
-#define MA_WAKEUP_MANAGER_FUNC_UPDATE_VOICE_FEEDBACK_STATE "wakeup_manager_update_voice_feedback_state"
-typedef int (*wakeup_manager_update_voice_feedback_state)(const char* appid, int state);
-#define MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND "wakeup_manager_set_assistant_specific_command"
-typedef int (*wakeup_manager_set_assistant_specific_command)(const char* appid, const char* command);
-#define MA_WAKEUP_MANAGER_FUNC_SET_BACKGROUND_VOLUME "wakeup_manager_set_background_volume"
-typedef int (*wakeup_manager_set_background_volume)(const char* appid, double ratio);
-#define MA_WAKEUP_MANAGER_FUNC_UPDATE_RECOGNITION_RESULT "wakeup_manager_update_recognition_result"
-typedef int (*wakeup_manager_update_recognition_result)(const char* appid, int result);
-#define MA_WAKEUP_MANAGER_FUNC_PROCESS_PLUGIN_EVENT "wakeup_manager_process_plugin_event"
-typedef int (*wakeup_manager_process_plugin_event)(int event, void* data, int len);
-#define MA_WAKEUP_MANAGER_FUNC_START_STREAMING_UTTERANCE_DATA "wakeup_manager_start_streaming_utterance_data"
-typedef int (*wakeup_manager_start_streaming_utterance_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_UTTERANCE_DATA "wakeup_manager_stop_streaming_utterance_data"
-typedef int (*wakeup_manager_stop_streaming_utterance_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_START_STREAMING_PREVIOUS_UTTERANCE_DATA "wakeup_manager_start_streaming_previous_utterance_data"
-typedef int (*wakeup_manager_start_streaming_previous_utterance_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_PREVIOUS_UTTERANCE_DATA "wakeup_manager_stop_streaming_previous_utterance_data"
-typedef int (*wakeup_manager_stop_streaming_previous_utterance_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_START_STREAMING_FOLLOW_UP_DATA "wakeup_manager_start_streaming_follow_up_data"
-typedef int (*wakeup_manager_start_streaming_follow_up_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_FOLLOW_UP_DATA "wakeup_manager_stop_streaming_follow_up_data"
-typedef int (*wakeup_manager_stop_streaming_follow_up_data)(void);
-#define MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_FORMAT "wakeup_manager_get_audio_format"
-typedef int (*wakeup_manager_get_audio_format)(int* rate, int* channel, int* audio_type);
-#define MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_SOURCE_TYPE "wakeup_manager_get_audio_source_type"
-typedef int (*wakeup_manager_get_audio_source_type)(char** type);
-#define MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_TAP_DURATION "wakeup_manager_set_voice_key_tap_duration"
-typedef int (*wakeup_manager_set_voice_key_tap_duration)(float duration);
-#define MA_WAKEUP_MANAGER_FUNC_UNSET_VOICE_KEY_TAP_DURATION "wakeup_manager_unset_voice_key_tap_duration"
-typedef int (*wakeup_manager_unset_voice_key_tap_duration)();
-#define MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_SUPPORT_MODE "wakeup_manager_set_voice_key_support_mode"
-typedef int (*wakeup_manager_set_voice_key_support_mode)(int mode);
-#define MA_WAKEUP_MANAGER_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG "wakeup_manager_set_wake_word_audio_require_flag"
-typedef int (*wakeup_manager_set_wake_word_audio_require_flag)(bool require);
-#define MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_LANGUAGE "wakeup_manager_set_assistant_language"
-typedef int (*wakeup_manager_set_assistant_language)(const char* appid, const char* language);
-#define MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_EVENT_CALLBACK "wakeup_manager_set_wakeup_event_callback"
-typedef int (*wakeup_manager_set_wakeup_event_callback)(wakeup_service_wakeup_event_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_UTTERANCE_STREAMING_CALLBACK "wakeup_manager_set_utterance_streaming_callback"
-typedef int (*wakeup_manager_set_utterance_streaming_callback)(wakeup_service_speech_streaming_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_PREVIOUS_UTTERANCE_STREAMING_CALLBACK "wakeup_manager_set_previous_utterance_streaming_callback"
-typedef int (*wakeup_manager_set_previous_utterance_streaming_callback)(wakeup_service_speech_streaming_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_FOLLOW_UP_STREAMING_CALLBACK "wakeup_manager_set_follow_up_streaming_callback"
-typedef int (*wakeup_manager_set_follow_up_streaming_callback)(wakeup_service_speech_streaming_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_SPEECH_STATUS_CALLBACK "wakeup_manager_set_speech_status_callback"
-typedef int (*wakeup_manager_set_speech_status_callback)(wakeup_service_speech_status_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_SETTING_CHANGED_CALLBACK "wakeup_manager_set_setting_changed_callback"
-typedef int (*wakeup_manager_set_setting_changed_callback)(wakeup_service_setting_changed_cb callback, void* user_data);
-#define MA_WAKEUP_MANAGER_FUNC_SET_ERROR_CALLBACK "wakeup_manager_set_error_callback"
-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);
-#define MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_SERVICE_STATE_CHANGED_CALLBACK "wakeup_manager_set_wakeup_service_state_changed_callback"
-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;
- wakeup_manager_deinitialize deinitialize;
- wakeup_manager_get_settings get_settings;
- wakeup_manager_add_assistant_wakeup_word add_assistant_wakeup_word;
- wakeup_manager_remove_assistant_wakeup_word remove_assistant_wakeup_word;
- wakeup_manager_add_assistant_language add_assistant_language;
- wakeup_manager_add_assistant_wakeup_engine add_assistant_wakeup_engine;
- wakeup_manager_set_default_assistant set_default_assistant;
- wakeup_manager_get_default_assistant get_default_assistant;
- wakeup_manager_set_language set_language;
- wakeup_manager_activate activate;
- wakeup_manager_deactivate deactivate;
- wakeup_manager_update_voice_feedback_state update_voice_feedback_state;
- wakeup_manager_set_assistant_specific_command set_assistant_specific_command;
- wakeup_manager_set_background_volume set_background_volume;
- wakeup_manager_update_recognition_result update_recognition_result;
- wakeup_manager_process_plugin_event process_plugin_event;
- wakeup_manager_start_streaming_utterance_data start_streaming_utterance_data;
- wakeup_manager_stop_streaming_utterance_data stop_streaming_utterance_data;
- wakeup_manager_start_streaming_previous_utterance_data start_streaming_previous_utterance_data;
- wakeup_manager_stop_streaming_previous_utterance_data stop_streaming_previous_utterance_data;
- wakeup_manager_start_streaming_follow_up_data start_streaming_follow_up_data;
- wakeup_manager_stop_streaming_follow_up_data stop_streaming_follow_up_data;
- wakeup_manager_get_audio_format get_audio_format;
- wakeup_manager_get_audio_source_type get_audio_source_type;
- wakeup_manager_set_voice_key_tap_duration set_voice_key_tap_duration;
- wakeup_manager_unset_voice_key_tap_duration unset_voice_key_tap_duration;
- wakeup_manager_set_voice_key_support_mode set_voice_key_support_mode;
- wakeup_manager_set_wake_word_audio_require_flag set_wake_word_audio_require_flag;
- wakeup_manager_set_assistant_language set_assistant_language;
- wakeup_manager_set_wakeup_event_callback set_wakeup_event_callback;
- wakeup_manager_set_utterance_streaming_callback set_utterance_streaming_callback;
- wakeup_manager_set_previous_utterance_streaming_callback set_previous_utterance_streaming_callback;
- wakeup_manager_set_follow_up_streaming_callback set_follow_up_streaming_callback;
- wakeup_manager_set_speech_status_callback set_speech_status_callback;
- 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_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__ */
%manifest %{name}.manifest
%defattr(-,root,root,-)
/usr/share/packages/org.tizen.multi-assistant-service.xml
-%{TZ_SYS_RO_SHARE}/multiassistant/libma-wakeup-manager.so
%{TZ_SYS_RO_SHARE}/multiassistant/libma-dependency-default.so
%{TZ_SYS_RO_APP}/%{name}/*
#%{_appdir}/lib/*
-ADD_SUBDIRECTORY(wakeup-manager)
+ADD_SUBDIRECTORY(dependency-default)
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(ma-dependency-default)
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(PACKAGE ${PROJECT_NAME})
+
+SET(CMAKE_SKIP_BUILD_RPATH TRUE)
+
+INCLUDE_DIRECTORIES(
+ ${CMAKE_SOURCE_DIR}/inc
+ ./inc
+ )
+
+SET(DDPKG_CHECK_MODULES
+ ecore
+ ecore-wl2
+ dlog
+ capi-media-audio-io
+ capi-media-sound-manager
+ eina
+ vconf
+ pkgmgr-info
+ multi-assistant
+)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(ddpkgs REQUIRED ${DDPKG_CHECK_MODULES})
+MESSAGE("Modules : ${DDPKG_CHECK_MODULES}")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
+
+SET(SRCS
+ src/dependency_default.cpp
+ src/dependency_default_audio.cpp
+ src/dependency_default_button.cpp
+)
+
+FOREACH(flag ${ddpkgs_CFLAGS})
+ SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+
+
+SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} -fPIC -Wall" )
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fstack-protector-strong -D_FORTIFY_SOURCE=2 -Wl,-z,relro -fPIC -std=c++11 -fvisibility=hidden")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS} )
+
+# Install libraries
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${ddpkgs_LDFLAGS} -ldl ${EXTRA_LDFLAGS})
+MESSAGE("LDFLAG : ${ddpkgs_LDFLAGS}")
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/plugins/dependency-default/lib${PACKAGE}.so DESTINATION ${TZ_SYS_RO_SHARE}/multiassistant/)
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _DEPENDENCY_DEFAULT_H_
+#define _DEPENDENCY_DEFAULT_H_
+
+#include <tizen.h>
+
+#include <multi_assistant_service.h>
+
+#ifndef LOG_TAG
+#define LOG_TAG "dependency_default"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXPORT_API int mas_dependency_initialize(mas_dependency_plugin_proxy_interface interfaces, int *dependency_version);
+EXPORT_API int mas_dependency_deinitialize(void);
+EXPORT_API int mas_dependency_set_error_callback(mas_error_cb callback, void* user_data);
+EXPORT_API int mas_dependency_start_recording(void);
+EXPORT_API int mas_dependency_stop_recording(void);
+EXPORT_API int mas_dependency_set_recording_session(unsigned int session);
+EXPORT_API int mas_dependency_set_background_volume(double ratio);
+EXPORT_API int mas_dependency_get_audio_format(int* rate, int* channel, int* audio_type);
+EXPORT_API int mas_dependency_get_audio_source_type(char** type);
+EXPORT_API int mas_dependency_process_wakeup_engine_command(const char* engine_name, const char* command);
+EXPORT_API int mas_dependency_set_voice_key_tap_duration(float duration);
+EXPORT_API int mas_dependency_unset_voice_key_tap_duration(void);
+EXPORT_API int mas_dependency_set_voice_key_support_mode(const char* support_mode);
+EXPORT_API int mas_dependency_get_custom_vconf_key(const char* default_key, char** custom_key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _DEPENDENCY_DEFAULT_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DEPENDENCY_DEFAULT_AUDIO_H_
+#define _DEPENDENCY_DEFAULT_AUDIO_H_
+
+#include "dependency_default.h"
+
+void dependency_default_audio_initialize(mas_dependency_plugin_proxy_interface interface);
+void dependency_default_audio_deinitialize();
+
+void dependency_default_audio_start_recording();
+void dependency_default_audio_stop_recording();
+
+void dependency_default_audio_set_recording_session(unsigned int session);
+
+void dependency_default_audio_voice_key_pressed_set(bool pressed);
+
+void dependency_default_audio_set_background_volume(double ratio);
+
+void dependency_default_audio_get_audio_format(int* rate, int* channel, int* audio_type);
+void dependency_default_audio_get_audio_source_type(char** type);
+
+#endif //_DEPENDENCY_DEFAULT_AUDIO_H_
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DEPENDENCY_DEFAULT_BUTTON_H_
+#define _DEPENDENCY_DEFAULT_BUTTON_H_
+
+#include "dependency_default.h"
+
+void dependency_default_button_initialize(mas_dependency_plugin_proxy_interface interface);
+void dependency_default_button_deinitialize();
+void dependency_default_button_set_voice_key_tap_duration(float duration);
+void dependency_default_button_unset_voice_key_tap_duration(void);
+
+#endif //_DEPENDENCY_DEFAULT_BUTTON_H_
--- /dev/null
+#include "dependency_default.h"
+#include "dependency_default_audio.h"
+#include "dependency_default_button.h"
+
+#include <dlog.h>
+#include <service_app_extension.h>
+
+#include <thread>
+
+static mas_dependency_plugin_proxy_interface g_proxy_interface;
+const int g_dependency_version = 1;
+
+static bool g_should_exit = false;
+
+int mas_dependency_initialize(mas_dependency_plugin_proxy_interface interface, int *dependency_version)
+{
+ g_proxy_interface = interface;
+
+ dependency_default_audio_initialize(interface);
+ dependency_default_button_initialize(interface);
+
+ if (dependency_version) {
+ *dependency_version = g_dependency_version;
+ }
+
+ /* If the service process has to terminate in certain circumstances,
+ set g_should_exit variable to true as below. */
+ // g_should_exit = true;
+
+ if (g_should_exit) {
+ LOGE("g_should_exit value contains positive value, registering timer");
+ std::thread([]() {
+ std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+ LOGE("Now trying to exit");
+ mas_dependency_deinitialize();
+ service_app_exit_without_restart();
+ }).detach();
+ }
+
+ return 0;
+}
+
+int mas_dependency_deinitialize(void)
+{
+ dependency_default_audio_deinitialize();
+ dependency_default_button_deinitialize();
+
+ return 0;
+}
+
+int mas_dependency_set_error_callback(mas_error_cb callback, void* user_data)
+{
+ return 0;
+}
+
+int mas_dependency_start_recording(void)
+{
+ dependency_default_audio_start_recording();
+ return 0;
+}
+
+int mas_dependency_stop_recording(void)
+{
+ dependency_default_audio_stop_recording();
+ return 0;
+}
+
+int mas_dependency_set_recording_session(unsigned int session)
+{
+ dependency_default_audio_set_recording_session(session);
+ return 0;
+}
+
+int mas_dependency_set_background_volume(double ratio)
+{
+ dependency_default_audio_set_background_volume(ratio);
+ return 0;
+}
+
+int mas_dependency_get_audio_format(int* rate, int* channel, int* audio_type)
+{
+ dependency_default_audio_get_audio_format(rate, channel, audio_type);
+ return 0;
+}
+
+int mas_dependency_get_audio_source_type(char** type)
+{
+ dependency_default_audio_get_audio_source_type(type);
+ return 0;
+}
+
+int mas_dependency_process_wakeup_engine_command(const char* engine_name, const char* command)
+{
+ LOGD("Wakeup Engine %s has sent a command : %s", engine_name, command);
+ return 0;
+}
+
+int mas_dependency_set_voice_key_tap_duration(float duration)
+{
+ dependency_default_button_set_voice_key_tap_duration(duration);
+ return 0;
+}
+
+int mas_dependency_unset_voice_key_tap_duration(void)
+{
+ dependency_default_button_unset_voice_key_tap_duration();
+ return 0;
+}
+
+int mas_dependency_set_voice_key_support_mode(const char* support_mode)
+{
+ LOGD("support_mode : %s", support_mode);
+ return 0;
+}
+
+int mas_dependency_get_custom_vconf_key(const char* default_key, char** custom_key)
+{
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+#include "dependency_default_audio.h"
+
+static bool g_voice_key_pressed = false;
+static mas_dependency_plugin_proxy_interface g_proxy_interface;
+
+#include <stdlib.h>
+#include <thread>
+#include <atomic>
+#include <chrono>
+
+#include <dlog.h>
+#include <audio_io.h>
+#include <sound_manager.h>
+#include <sound_manager_internal.h>
+
+using namespace std;
+
+static audio_in_h g_audio_in = NULL;
+static audio_io_state_e g_audio_io_state = AUDIO_IO_STATE_IDLE;
+
+static sound_stream_info_h g_volume_stream = NULL;
+static virtual_sound_stream_h g_virtual_sound_stream = NULL;
+
+static int g_device_id = -1;
+static sound_stream_info_h g_stream_info = NULL;
+
+static thread g_recorder_thread;
+static atomic_bool g_stop_recorder_thread{false};
+
+static long long get_current_milliseconds_after_epoch()
+{
+ auto now = chrono::steady_clock::now();
+ auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
+ /* number of milliseconds since the epoch of system_clock */
+ auto value = now_ms.time_since_epoch();
+
+ return value.count();
+}
+
+static int _apply_device_for_stream_routing(void *user_data)
+{
+ sound_device_list_h deviceList = NULL;
+ sound_device_h device = NULL;
+ sound_device_type_e type;
+ sound_device_io_direction_e ioDirection;
+
+ if (0 != sound_manager_get_device_list(SOUND_DEVICE_IO_DIRECTION_IN_MASK, &deviceList)) {
+ LOGE("[Recorder ERROR] Fail to get current device list");
+ return -1;
+ }
+
+ bool isFound = false;
+ while (0 == sound_manager_get_next_device(deviceList, &device)) {
+ if (0 != sound_manager_get_device_type(device, &type)) {
+ LOGE("[Recorder ERROR] Fail to get device type");
+ continue;
+ }
+ if (0 != sound_manager_get_device_io_direction(device, &ioDirection)) {
+ LOGE("[Recorder ERROR] Fail to get device io direction");
+ continue;
+ }
+
+ if (SOUND_DEVICE_USB_AUDIO == type && SOUND_DEVICE_IO_DIRECTION_IN == ioDirection) {
+ if (0 != sound_manager_add_device_for_stream_routing(g_stream_info, device)) {
+ LOGE("[Recorder ERROR] Fail to add device");
+ continue;
+ }
+ if (0 != sound_manager_apply_stream_routing(g_stream_info)) {
+ LOGE("[Recorder ERROR] Fail to apply stream routing");
+ continue;
+ }
+ isFound = true;
+ break;
+ }
+ }
+
+ sound_manager_free_device_list(deviceList);
+ deviceList = NULL;
+
+ if (true != isFound) {
+ LOGI("[Recorder] No USB device");
+ } else {
+ LOGD("[Recorder] Apply device for stream routing");
+ }
+ return 0;
+}
+
+static void _device_connection_changed_cb(sound_device_h device, bool isConnected, void *user_data)
+{
+ sound_device_type_e type;
+ if (isConnected) {
+ if (0 != sound_manager_get_device_type(device, &type)) {
+ LOGE("[Recorder ERROR] Fail to get device type");
+ return;
+ }
+ if (type == SOUND_DEVICE_USB_AUDIO) {
+ if (0 != sound_manager_remove_device_for_stream_routing(g_stream_info, device))
+ LOGE("[Recorder ERROR] Fail to remove device");
+
+ if (0 != sound_manager_add_device_for_stream_routing(g_stream_info, device)) {
+ LOGE("[Recorder ERROR] Fail to add device");
+ return;
+ }
+ if (0 != sound_manager_apply_stream_routing(g_stream_info)) {
+ LOGE("[Recorder ERROR} Fail to apply stream routing");
+ return;
+ }
+ LOGD("[Recorder] Apply device for stream routing");
+ }
+ }
+ return;
+}
+
+static void _audio_in_state_changed_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
+{
+ if (handle == g_audio_in) {
+ g_audio_io_state = current;
+ }
+}
+
+void dependency_default_audio_initialize(mas_dependency_plugin_proxy_interface interfaces)
+{
+ const int rate = 16000;
+ const audio_channel_e channel = AUDIO_CHANNEL_MONO;
+ const audio_sample_type_e type = AUDIO_SAMPLE_TYPE_S16_LE;
+
+ g_proxy_interface = interfaces;
+
+ int ret = audio_in_create(rate, channel, type, &g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGE("[Recorder ERROR] Rate(%d) Channel(%d) Type(%d)", rate, channel, type);
+ LOGE("[Recorder ERROR] Fail to create audio handle : %d", ret);
+ return;
+ }
+
+ ret = sound_manager_add_device_connection_changed_cb(SOUND_DEVICE_IO_DIRECTION_IN_MASK, _device_connection_changed_cb, NULL, &g_device_id);
+ if (0 != ret) {
+ LOGE("[Recorder ERROR] Fail to add device connection changed callback");
+ audio_in_destroy(g_audio_in);
+ g_audio_in = NULL;
+ return;
+ }
+
+ ret = sound_manager_create_stream_information_internal(
+ SOUND_STREAM_TYPE_VOICE_RECOGNITION_SERVICE, NULL, NULL, &g_stream_info);
+ if (0 != ret) {
+ LOGE("[Recorder ERROR] Fail to create stream info");
+ sound_manager_remove_device_connection_changed_cb(g_device_id);
+ audio_in_destroy(g_audio_in);
+ g_audio_in = NULL;
+ return;
+ }
+
+ ret = _apply_device_for_stream_routing(NULL);
+ if (0 != ret) {
+ LOGE("[Recorder ERROR] Fail to apply device for stream routing: %d", ret);
+ }
+
+ ret = audio_in_set_state_changed_cb(g_audio_in, _audio_in_state_changed_cb, NULL);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGE("[Recorder ERROR] Fail to set state changed callback : %d", ret);
+ sound_manager_remove_device_connection_changed_cb(g_device_id);
+ sound_manager_destroy_stream_information(g_stream_info);
+ g_stream_info = NULL;
+ audio_in_destroy(g_audio_in);
+ g_audio_in = NULL;
+ return;
+ }
+
+ ret = audio_in_set_sound_stream_info(g_audio_in, g_stream_info);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGE("[Recorder ERROR] Fail to set stream info : %d", ret);
+ sound_manager_remove_device_connection_changed_cb(g_device_id);
+ sound_manager_destroy_stream_information(g_stream_info);
+ g_stream_info = NULL;
+ audio_in_unset_state_changed_cb(g_audio_in);
+ audio_in_destroy(g_audio_in);
+ g_audio_in = NULL;
+ return;
+ }
+
+ ret = audio_in_prepare(g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ if (AUDIO_IO_ERROR_SOUND_POLICY == ret)
+ {
+ LOGE("[Recorder ERROR] Audio is busy.");
+ } else {
+ LOGE("[Recorder ERROR] Fail to start audio : %d", ret);
+ }
+ sound_manager_remove_device_connection_changed_cb(g_device_id);
+ sound_manager_destroy_stream_information(g_stream_info);
+ g_stream_info = NULL;
+ audio_in_unset_state_changed_cb(g_audio_in);
+ audio_in_destroy(g_audio_in);
+ g_audio_in = NULL;
+ return;
+ }
+
+ ret = audio_in_pause(g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGE("[Recorder ERROR] Fail to pause audio in : %d", ret);
+ }
+}
+
+void dependency_default_audio_deinitialize()
+{
+ dependency_default_audio_stop_recording();
+
+ int ret = 0;
+ if (g_virtual_sound_stream) {
+ sound_manager_stop_virtual_stream(g_virtual_sound_stream);
+ ret = sound_manager_destroy_virtual_stream(g_virtual_sound_stream);
+ if (0 != ret) {
+ LOGE("[Audio ERROR] Fail to destroy virtual stream, ret(%d)", ret);
+ }
+ g_virtual_sound_stream = NULL;
+ }
+
+ if (g_device_id) {
+ ret = sound_manager_remove_device_connection_changed_cb(g_device_id);
+ if (0 != ret)
+ LOGE("[Audio ERROR] Fail to remove device connection changed callback, ret(%d)", ret);
+ }
+
+ if (g_volume_stream) {
+ ret = sound_manager_destroy_stream_information(g_volume_stream);
+ if (0 != ret) {
+ LOGE("[Audio ERROR] Fail to destroy stream information, ret(%d)", ret);
+ }
+ g_volume_stream = NULL;
+ }
+
+ if (g_audio_in) {
+ ret = audio_in_unprepare(g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGD("[Recorder ERROR] Fail to stop audio : %d", ret);
+ }
+ }
+
+ if (g_stream_info) {
+ if (0 != sound_manager_destroy_stream_information(g_stream_info)) {
+ LOGD("[Recorder ERROR] Fail to destroy stream info");
+ }
+ g_stream_info = NULL;
+ }
+
+ if (g_audio_in) {
+ ret = audio_in_unset_state_changed_cb(g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGD("[Recorder ERROR] Fail to unset state changed callback : %d", ret);
+ }
+
+ ret = audio_in_destroy(g_audio_in);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGD("[Recorder ERROR] Fail to destroy audio : %d", ret);
+ }
+ g_audio_in = NULL;
+ }
+}
+
+static void recorder_thread_func()
+{
+ const int FRAME_LENGTH = 160;
+ const int BUFFER_LENGTH = FRAME_LENGTH * 2;
+
+ static int buffer_count = 0;
+
+ while (!(g_stop_recorder_thread.load())) {
+ unsigned char buffer[BUFFER_LENGTH];
+ memset(buffer, '\0', BUFFER_LENGTH);
+
+ int read_bytes = audio_in_read(g_audio_in, buffer, BUFFER_LENGTH);
+ if (0 > read_bytes) {
+ LOGE("[Recorder WARNING] Fail to read audio : %d", read_bytes);
+ break;
+ }
+
+ g_proxy_interface.feed_audio_data(MAS_SPEECH_STREAMING_EVENT_CONTINUE,
+ buffer, read_bytes);
+
+ /* Audio read log */
+ if (0 == buffer_count % 300) {
+ LOGD("[Recorder][%d] Recording... : read_size(%d)", buffer_count, read_bytes);
+ }
+
+ buffer_count++;
+ }
+}
+
+void dependency_default_audio_start_recording()
+{
+ if (g_audio_in) {
+ int ret = AUDIO_IO_ERROR_NONE;
+ if (AUDIO_IO_STATE_RUNNING != g_audio_io_state) {
+ ret = audio_in_resume(g_audio_in);
+ }
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGD("[Recorder ERROR] Fail to resume audio in : %d", ret);
+ }
+ g_stop_recorder_thread.store(false);
+ LOGD("Starting recorder thread");
+ g_recorder_thread = thread(recorder_thread_func);
+ }
+}
+
+void dependency_default_audio_stop_recording()
+{
+ if (g_recorder_thread.joinable()) {
+ LOGD("g_recorder_thread is joinable, trying join()");
+ g_stop_recorder_thread.store(true);
+ g_recorder_thread.join();
+ }
+ if (g_audio_in) {
+ int ret = AUDIO_IO_ERROR_NONE;
+ if (AUDIO_IO_STATE_RUNNING == g_audio_io_state) {
+ ret = audio_in_pause(g_audio_in);
+ }
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ LOGD("[Recorder ERROR] Fail to pause audio in : %d", ret);
+ }
+ }
+}
+
+void dependency_default_audio_set_recording_session(unsigned int session)
+{
+ LOGD("Current recording session : [%s]",
+ (MAS_RECORDING_SESSION_WAKE_WORD == session) ? "wake word detecting" :
+ (MAS_RECORDING_SESSION_UTTERANCE == session) ? "utterance recording" :
+ (MAS_RECORDING_SESSION_FOLLOW_UP == session) ? "follow-up speech recording" :
+ "ERROR - Invalid recording session information"
+ );
+}
+
+void dependency_default_audio_voice_key_pressed_set(bool pressed)
+{
+ g_voice_key_pressed = pressed;
+}
+
+void dependency_default_audio_set_background_volume(double ratio)
+{
+ LOGD("[ENTER]");
+ int ret;
+
+ if (ratio >= 0.5) {
+ if (g_virtual_sound_stream) {
+ ret = sound_manager_stop_virtual_stream(g_virtual_sound_stream);
+ if (0 != ret) {
+ LOGD("[Audio ERROR] Fail to stop virtual stream, ret(%d)", ret);
+ }
+ ret = sound_manager_destroy_virtual_stream(g_virtual_sound_stream);
+ if (0 != ret) {
+ LOGD("[Audio ERROR] Fail to destroy virtual stream, ret(%d)", ret);
+ return;
+ }
+ g_virtual_sound_stream = NULL;
+ }
+
+ if (g_volume_stream) {
+ ret = sound_manager_destroy_stream_information(g_volume_stream);
+ if (0 != ret) {
+ LOGD("[Audio ERROR] Fail to destroy stream information, ret(%d)", ret);
+ return;
+ }
+ g_volume_stream = NULL;
+ }
+ } else {
+ if (!g_volume_stream) {
+ ret = sound_manager_create_stream_information_internal(SOUND_STREAM_TYPE_VOICE_RECOGNITION_SERVICE, NULL, NULL, &g_volume_stream);
+ if (0 != ret) {
+ LOGD("[Audio] Fail to create stream information, ret(%d)", ret);
+ return;
+ }
+ }
+
+ if (!g_virtual_sound_stream) {
+ ret = sound_manager_create_virtual_stream(g_volume_stream, &g_virtual_sound_stream);
+ if (0 != ret) {
+ LOGD("[Audio ERROR] Fail to create virtual stream, ret(%d)", ret);
+ return;
+ }
+ }
+ if (g_virtual_sound_stream) {
+ ret = sound_manager_start_virtual_stream(g_virtual_sound_stream);
+ if (0 != ret) {
+ LOGD("[Audio ERROR] Fail to start virtual stream, ret(%d)", ret);
+ return;
+ }
+ }
+ }
+ LOGD("[EXIT]");
+}
+
+void dependency_default_audio_get_audio_format(int* rate, int* channel, int* audio_type)
+{
+ if (!audio_type || !rate || !channel) {
+ return;
+ }
+ *rate = 16000;
+ *channel = 0;
+ *audio_type = 0;
+}
+
+void dependency_default_audio_get_audio_source_type(char** type)
+{
+ static char source_type[] = "default_audio";
+ if (!type) {
+ return;
+ }
+ *type = source_type;
+}
--- /dev/null
+#include "dependency_default_button.h"
+
+#include <chrono>
+
+using namespace std;
+
+#define EFL_BETA_API_SUPPORT
+
+#include <dlog.h>
+#include <Ecore.h>
+#include <Ecore_Input.h>
+#include <Ecore_Wl2.h>
+
+static mas_dependency_plugin_proxy_interface g_proxy_interface;
+
+static Ecore_Event_Handler* g_key_down_handler = NULL;
+static Ecore_Event_Handler* g_key_up_handler = NULL;
+
+static Ecore_Wl2_Display *g_ecore_wl2_display = NULL;
+
+static chrono::time_point<chrono::system_clock> g_last_key_pressed;
+static bool g_voice_key_pressed = false;
+const float DEFAULT_KEY_TAP_DURATION = 0.3f * 1000;
+static float g_voice_key_tap_duration = DEFAULT_KEY_TAP_DURATION;
+
+#define VOICE_KEY "XF86AudioPlayPause"
+
+static Eina_Bool _key_down_cb(void* data, int type, void* event)
+{
+ Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
+ if (ev) {
+ LOGD("KEY[%s], type[%d]", ev->keyname, type);
+
+ if (ev->keyname && strncmp(ev->keyname, VOICE_KEY, strlen(VOICE_KEY)) == 0 ) {
+ chrono::time_point<chrono::system_clock> current_time_point;
+ current_time_point = chrono::system_clock::now();
+ auto diff = current_time_point - g_last_key_pressed;
+ auto milliseconds = chrono::duration_cast<chrono::milliseconds>(diff).count();
+ /* If double click detected within 500 msec */
+ if (milliseconds < 500) {
+ if (g_proxy_interface.process_event) {
+ g_proxy_interface.process_event(MAS_PLUGIN_EVENT_VOICE_KEY_PRESSED, NULL, 0);
+ g_voice_key_pressed = true;
+ }
+ }
+ g_last_key_pressed = current_time_point;
+ }
+ }
+
+ return ECORE_CALLBACK_DONE;
+}
+
+static Eina_Bool _key_up_cb(void* data, int type, void* event)
+{
+ Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
+ if (ev) {
+ LOGD("KEY[%s], type[%d]", ev->keyname, type);
+
+ if (g_voice_key_pressed &&
+ ev->keyname && strncmp(ev->keyname, VOICE_KEY, strlen(VOICE_KEY)) == 0) {
+ chrono::time_point<chrono::system_clock> current_time_point;
+ current_time_point = chrono::system_clock::now();
+ auto diff = current_time_point - g_last_key_pressed;
+ long long int milliseconds = chrono::duration_cast<chrono::milliseconds>(diff).count();
+ LOGD("milliseconds : %lld", milliseconds);
+ mas_plugin_event_e plugin_event;
+ if (milliseconds < g_voice_key_tap_duration) {
+ plugin_event = MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_TAP;
+ } else {
+ plugin_event = MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_PUSH;
+ }
+ if (g_proxy_interface.process_event) {
+ g_proxy_interface.process_event(plugin_event, NULL, 0);
+ }
+ }
+ }
+ return ECORE_CALLBACK_DONE;
+}
+
+static bool _grab_voice_key(void)
+{
+ Eina_Bool ret = true;
+ ret = ecore_wl2_window_keygrab_set(NULL, VOICE_KEY, 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_SHARED);
+ LOGD("ecore_wl2_window_keygrab_set ret[%d] [%s]", ret, VOICE_KEY);
+
+ return ret;
+}
+
+static bool _ungrab_voice_key(void)
+{
+ Eina_Bool ret = true;
+ ret = ecore_wl2_window_keygrab_unset(NULL, VOICE_KEY, 0, 0);
+ LOGD("ecore_wl2_window_keygrab_unset ret[%d] [%s]", ret, VOICE_KEY);
+
+ return ret;
+}
+
+static bool _add_key_cb()
+{
+ if (g_key_down_handler == NULL) {
+ LOGE("_key_down_handler");
+ g_key_down_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _key_down_cb, NULL);
+ if(g_key_down_handler == NULL) {
+ LOGE("_key_down_handler == NULL ");
+ }
+ }
+
+ if (g_key_up_handler == NULL) {
+ LOGE("_key_down_handler");
+ g_key_up_handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _key_up_cb, NULL);
+ if(g_key_up_handler == NULL) {
+ LOGE("_key_up_handler == NULL ");
+ }
+ }
+ return true;
+}
+
+static bool _delete_key_cb(void)
+{
+ LOGE("start");
+ if (NULL != g_key_down_handler) {
+ ecore_event_handler_del(g_key_down_handler);
+ g_key_down_handler = NULL;
+ }
+
+ if (NULL != g_key_up_handler) {
+ ecore_event_handler_del(g_key_up_handler);
+ g_key_up_handler = NULL;
+ }
+ LOGE("end");
+ return true;
+}
+
+void dependency_default_button_initialize(mas_dependency_plugin_proxy_interface interface)
+{
+ g_proxy_interface = interface;
+
+ Eina_Bool ret = ecore_wl2_init();
+ LOGD("ecore_wl2_init: %d", ret);
+
+ g_ecore_wl2_display = ecore_wl2_display_connect(NULL);
+ LOGD("g_ecore_wl2_display: %p", g_ecore_wl2_display);
+
+ g_last_key_pressed = chrono::system_clock::now();
+ _grab_voice_key();
+ _add_key_cb();
+}
+
+void dependency_default_button_deinitialize()
+{
+ if (g_ecore_wl2_display) {
+ ecore_wl2_display_disconnect(g_ecore_wl2_display);
+ g_ecore_wl2_display = NULL;
+ }
+ _delete_key_cb();
+ _ungrab_voice_key();
+}
+
+void dependency_default_button_set_voice_key_tap_duration(float duration)
+{
+ g_voice_key_tap_duration = duration * 1000.0f; // in milliseconds
+}
+
+void dependency_default_button_unset_voice_key_tap_duration(void)
+{
+ g_voice_key_tap_duration = DEFAULT_KEY_TAP_DURATION;
+}
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(ma-wakeup-manager)
-
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-SET(PACKAGE ${PROJECT_NAME})
-
-SET(CMAKE_SKIP_BUILD_RPATH TRUE)
-
-INCLUDE_DIRECTORIES(
- ${CMAKE_SOURCE_DIR}/inc
- ./inc
- )
-
-SET(WMPKG_CHECK_MODULES
- ecore
- dlog
- capi-appfw-preference
- capi-media-audio-io
- capi-media-sound-manager
- eina
- vconf
- pkgmgr-info
- multi-assistant
- jsoncpp
-)
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(wmpkgs REQUIRED ${WMPKG_CHECK_MODULES})
-MESSAGE("Modules : ${WMPKG_CHECK_MODULES}")
-
-IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
- SET(CMAKE_BUILD_TYPE "Release")
-ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
-MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
-
-SET(SRCS
- src/wakeup_manager.cpp
- src/wakeup_settings.cpp
- src/wakeup_policy.cpp
- src/wakeup_policy_default.cpp
- src/wakeup_policy_external.cpp
- src/wakeup_audio_manager.cpp
- src/wakeup_engine_manager.cpp
- src/wakeup_manager_wrapper.cpp
- src/dependency_resolver.cpp
- src/heap_tracer.cpp
- src/assistant_config_manager.cpp
-)
-
-FOREACH(flag ${wmpkgs_CFLAGS})
- SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-
-
-SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} -fPIC -Wall" )
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fstack-protector-strong -D_FORTIFY_SOURCE=2 -Wl,-z,relro -fPIC -std=c++11 -fvisibility=hidden")
-SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
-
-ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS} )
-
-# Install libraries
-TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${wmpkgs_LDFLAGS} -ldl ${EXTRA_LDFLAGS})
-MESSAGE("LDFLAG : ${wmpkgs_LDFLAGS}")
-INSTALL(FILES ${CMAKE_SOURCE_DIR}/plugins/wakeup-manager/libma-wakeup-manager.so DESTINATION ${TZ_SYS_RO_SHARE}/multiassistant/)
-
-ADD_SUBDIRECTORY(dependency-default)
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(ma-dependency-default)
-
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-SET(PACKAGE ${PROJECT_NAME})
-
-SET(CMAKE_SKIP_BUILD_RPATH TRUE)
-
-INCLUDE_DIRECTORIES(
- ${CMAKE_SOURCE_DIR}/inc
- ./inc
- )
-
-SET(DDPKG_CHECK_MODULES
- ecore
- ecore-wl2
- dlog
- capi-media-audio-io
- capi-media-sound-manager
- eina
- vconf
- pkgmgr-info
- multi-assistant
-)
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(ddpkgs REQUIRED ${DDPKG_CHECK_MODULES})
-MESSAGE("Modules : ${DDPKG_CHECK_MODULES}")
-
-IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
- SET(CMAKE_BUILD_TYPE "Release")
-ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
-MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
-
-SET(SRCS
- src/dependency_default.cpp
- src/dependency_default_audio.cpp
- src/dependency_default_button.cpp
-)
-
-FOREACH(flag ${ddpkgs_CFLAGS})
- SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-
-
-SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} -fPIC -Wall" )
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fstack-protector-strong -D_FORTIFY_SOURCE=2 -Wl,-z,relro -fPIC -std=c++11 -fvisibility=hidden")
-SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
-
-ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS} )
-
-# Install libraries
-TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${ddpkgs_LDFLAGS} -ldl ${EXTRA_LDFLAGS})
-MESSAGE("LDFLAG : ${ddpkgs_LDFLAGS}")
-INSTALL(FILES ${CMAKE_SOURCE_DIR}/plugins/wakeup-manager/dependency-default/lib${PACKAGE}.so DESTINATION ${TZ_SYS_RO_SHARE}/multiassistant/)
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef _DEPENDENCY_DEFAULT_H_
-#define _DEPENDENCY_DEFAULT_H_
-
-#include <tizen.h>
-
-#include <multi_assistant_service.h>
-
-#ifndef LOG_TAG
-#define LOG_TAG "dependency_default"
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-EXPORT_API int mas_dependency_initialize(mas_dependency_plugin_proxy_interface interfaces, int *dependency_version);
-EXPORT_API int mas_dependency_deinitialize(void);
-EXPORT_API int mas_dependency_set_error_callback(mas_error_cb callback, void* user_data);
-EXPORT_API int mas_dependency_start_recording(void);
-EXPORT_API int mas_dependency_stop_recording(void);
-EXPORT_API int mas_dependency_set_recording_session(unsigned int session);
-EXPORT_API int mas_dependency_set_background_volume(double ratio);
-EXPORT_API int mas_dependency_get_audio_format(int* rate, int* channel, int* audio_type);
-EXPORT_API int mas_dependency_get_audio_source_type(char** type);
-EXPORT_API int mas_dependency_process_wakeup_engine_command(const char* engine_name, const char* command);
-EXPORT_API int mas_dependency_set_voice_key_tap_duration(float duration);
-EXPORT_API int mas_dependency_unset_voice_key_tap_duration(void);
-EXPORT_API int mas_dependency_set_voice_key_support_mode(const char* support_mode);
-EXPORT_API int mas_dependency_get_custom_vconf_key(const char* default_key, char** custom_key);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _DEPENDENCY_DEFAULT_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _DEPENDENCY_DEFAULT_AUDIO_H_
-#define _DEPENDENCY_DEFAULT_AUDIO_H_
-
-#include "dependency_default.h"
-
-void dependency_default_audio_initialize(mas_dependency_plugin_proxy_interface interface);
-void dependency_default_audio_deinitialize();
-
-void dependency_default_audio_start_recording();
-void dependency_default_audio_stop_recording();
-
-void dependency_default_audio_set_recording_session(unsigned int session);
-
-void dependency_default_audio_voice_key_pressed_set(bool pressed);
-
-void dependency_default_audio_set_background_volume(double ratio);
-
-void dependency_default_audio_get_audio_format(int* rate, int* channel, int* audio_type);
-void dependency_default_audio_get_audio_source_type(char** type);
-
-#endif //_DEPENDENCY_DEFAULT_AUDIO_H_
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _DEPENDENCY_DEFAULT_BUTTON_H_
-#define _DEPENDENCY_DEFAULT_BUTTON_H_
-
-#include "dependency_default.h"
-
-void dependency_default_button_initialize(mas_dependency_plugin_proxy_interface interface);
-void dependency_default_button_deinitialize();
-void dependency_default_button_set_voice_key_tap_duration(float duration);
-void dependency_default_button_unset_voice_key_tap_duration(void);
-
-#endif //_DEPENDENCY_DEFAULT_BUTTON_H_
+++ /dev/null
-#include "dependency_default.h"
-#include "dependency_default_audio.h"
-#include "dependency_default_button.h"
-
-#include <dlog.h>
-#include <service_app_extension.h>
-
-#include <thread>
-
-static mas_dependency_plugin_proxy_interface g_proxy_interface;
-const int g_dependency_version = 1;
-
-static bool g_should_exit = false;
-
-int mas_dependency_initialize(mas_dependency_plugin_proxy_interface interface, int *dependency_version)
-{
- g_proxy_interface = interface;
-
- dependency_default_audio_initialize(interface);
- dependency_default_button_initialize(interface);
-
- if (dependency_version) {
- *dependency_version = g_dependency_version;
- }
-
- /* If the service process has to terminate in certain circumstances,
- set g_should_exit variable to true as below. */
- // g_should_exit = true;
-
- if (g_should_exit) {
- LOGE("g_should_exit value contains positive value, registering timer");
- std::thread([]() {
- std::this_thread::sleep_for(std::chrono::milliseconds(1000));
- LOGE("Now trying to exit");
- mas_dependency_deinitialize();
- service_app_exit_without_restart();
- }).detach();
- }
-
- return 0;
-}
-
-int mas_dependency_deinitialize(void)
-{
- dependency_default_audio_deinitialize();
- dependency_default_button_deinitialize();
-
- return 0;
-}
-
-int mas_dependency_set_error_callback(mas_error_cb callback, void* user_data)
-{
- return 0;
-}
-
-int mas_dependency_start_recording(void)
-{
- dependency_default_audio_start_recording();
- return 0;
-}
-
-int mas_dependency_stop_recording(void)
-{
- dependency_default_audio_stop_recording();
- return 0;
-}
-
-int mas_dependency_set_recording_session(unsigned int session)
-{
- dependency_default_audio_set_recording_session(session);
- return 0;
-}
-
-int mas_dependency_set_background_volume(double ratio)
-{
- dependency_default_audio_set_background_volume(ratio);
- return 0;
-}
-
-int mas_dependency_get_audio_format(int* rate, int* channel, int* audio_type)
-{
- dependency_default_audio_get_audio_format(rate, channel, audio_type);
- return 0;
-}
-
-int mas_dependency_get_audio_source_type(char** type)
-{
- dependency_default_audio_get_audio_source_type(type);
- return 0;
-}
-
-int mas_dependency_process_wakeup_engine_command(const char* engine_name, const char* command)
-{
- LOGD("Wakeup Engine %s has sent a command : %s", engine_name, command);
- return 0;
-}
-
-int mas_dependency_set_voice_key_tap_duration(float duration)
-{
- dependency_default_button_set_voice_key_tap_duration(duration);
- return 0;
-}
-
-int mas_dependency_unset_voice_key_tap_duration(void)
-{
- dependency_default_button_unset_voice_key_tap_duration();
- return 0;
-}
-
-int mas_dependency_set_voice_key_support_mode(const char* support_mode)
-{
- LOGD("support_mode : %s", support_mode);
- return 0;
-}
-
-int mas_dependency_get_custom_vconf_key(const char* default_key, char** custom_key)
-{
- return 0;
-}
\ No newline at end of file
+++ /dev/null
-#include "dependency_default_audio.h"
-
-static bool g_voice_key_pressed = false;
-static mas_dependency_plugin_proxy_interface g_proxy_interface;
-
-#include <stdlib.h>
-#include <thread>
-#include <atomic>
-#include <chrono>
-
-#include <dlog.h>
-#include <audio_io.h>
-#include <sound_manager.h>
-#include <sound_manager_internal.h>
-
-using namespace std;
-
-static audio_in_h g_audio_in = NULL;
-static audio_io_state_e g_audio_io_state = AUDIO_IO_STATE_IDLE;
-
-static sound_stream_info_h g_volume_stream = NULL;
-static virtual_sound_stream_h g_virtual_sound_stream = NULL;
-
-static int g_device_id = -1;
-static sound_stream_info_h g_stream_info = NULL;
-
-static thread g_recorder_thread;
-static atomic_bool g_stop_recorder_thread{false};
-
-static long long get_current_milliseconds_after_epoch()
-{
- auto now = chrono::steady_clock::now();
- auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
- /* number of milliseconds since the epoch of system_clock */
- auto value = now_ms.time_since_epoch();
-
- return value.count();
-}
-
-static int _apply_device_for_stream_routing(void *user_data)
-{
- sound_device_list_h deviceList = NULL;
- sound_device_h device = NULL;
- sound_device_type_e type;
- sound_device_io_direction_e ioDirection;
-
- if (0 != sound_manager_get_device_list(SOUND_DEVICE_IO_DIRECTION_IN_MASK, &deviceList)) {
- LOGE("[Recorder ERROR] Fail to get current device list");
- return -1;
- }
-
- bool isFound = false;
- while (0 == sound_manager_get_next_device(deviceList, &device)) {
- if (0 != sound_manager_get_device_type(device, &type)) {
- LOGE("[Recorder ERROR] Fail to get device type");
- continue;
- }
- if (0 != sound_manager_get_device_io_direction(device, &ioDirection)) {
- LOGE("[Recorder ERROR] Fail to get device io direction");
- continue;
- }
-
- if (SOUND_DEVICE_USB_AUDIO == type && SOUND_DEVICE_IO_DIRECTION_IN == ioDirection) {
- if (0 != sound_manager_add_device_for_stream_routing(g_stream_info, device)) {
- LOGE("[Recorder ERROR] Fail to add device");
- continue;
- }
- if (0 != sound_manager_apply_stream_routing(g_stream_info)) {
- LOGE("[Recorder ERROR] Fail to apply stream routing");
- continue;
- }
- isFound = true;
- break;
- }
- }
-
- sound_manager_free_device_list(deviceList);
- deviceList = NULL;
-
- if (true != isFound) {
- LOGI("[Recorder] No USB device");
- } else {
- LOGD("[Recorder] Apply device for stream routing");
- }
- return 0;
-}
-
-static void _device_connection_changed_cb(sound_device_h device, bool isConnected, void *user_data)
-{
- sound_device_type_e type;
- if (isConnected) {
- if (0 != sound_manager_get_device_type(device, &type)) {
- LOGE("[Recorder ERROR] Fail to get device type");
- return;
- }
- if (type == SOUND_DEVICE_USB_AUDIO) {
- if (0 != sound_manager_remove_device_for_stream_routing(g_stream_info, device))
- LOGE("[Recorder ERROR] Fail to remove device");
-
- if (0 != sound_manager_add_device_for_stream_routing(g_stream_info, device)) {
- LOGE("[Recorder ERROR] Fail to add device");
- return;
- }
- if (0 != sound_manager_apply_stream_routing(g_stream_info)) {
- LOGE("[Recorder ERROR} Fail to apply stream routing");
- return;
- }
- LOGD("[Recorder] Apply device for stream routing");
- }
- }
- return;
-}
-
-static void _audio_in_state_changed_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
-{
- if (handle == g_audio_in) {
- g_audio_io_state = current;
- }
-}
-
-void dependency_default_audio_initialize(mas_dependency_plugin_proxy_interface interfaces)
-{
- const int rate = 16000;
- const audio_channel_e channel = AUDIO_CHANNEL_MONO;
- const audio_sample_type_e type = AUDIO_SAMPLE_TYPE_S16_LE;
-
- g_proxy_interface = interfaces;
-
- int ret = audio_in_create(rate, channel, type, &g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGE("[Recorder ERROR] Rate(%d) Channel(%d) Type(%d)", rate, channel, type);
- LOGE("[Recorder ERROR] Fail to create audio handle : %d", ret);
- return;
- }
-
- ret = sound_manager_add_device_connection_changed_cb(SOUND_DEVICE_IO_DIRECTION_IN_MASK, _device_connection_changed_cb, NULL, &g_device_id);
- if (0 != ret) {
- LOGE("[Recorder ERROR] Fail to add device connection changed callback");
- audio_in_destroy(g_audio_in);
- g_audio_in = NULL;
- return;
- }
-
- ret = sound_manager_create_stream_information_internal(
- SOUND_STREAM_TYPE_VOICE_RECOGNITION_SERVICE, NULL, NULL, &g_stream_info);
- if (0 != ret) {
- LOGE("[Recorder ERROR] Fail to create stream info");
- sound_manager_remove_device_connection_changed_cb(g_device_id);
- audio_in_destroy(g_audio_in);
- g_audio_in = NULL;
- return;
- }
-
- ret = _apply_device_for_stream_routing(NULL);
- if (0 != ret) {
- LOGE("[Recorder ERROR] Fail to apply device for stream routing: %d", ret);
- }
-
- ret = audio_in_set_state_changed_cb(g_audio_in, _audio_in_state_changed_cb, NULL);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGE("[Recorder ERROR] Fail to set state changed callback : %d", ret);
- sound_manager_remove_device_connection_changed_cb(g_device_id);
- sound_manager_destroy_stream_information(g_stream_info);
- g_stream_info = NULL;
- audio_in_destroy(g_audio_in);
- g_audio_in = NULL;
- return;
- }
-
- ret = audio_in_set_sound_stream_info(g_audio_in, g_stream_info);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGE("[Recorder ERROR] Fail to set stream info : %d", ret);
- sound_manager_remove_device_connection_changed_cb(g_device_id);
- sound_manager_destroy_stream_information(g_stream_info);
- g_stream_info = NULL;
- audio_in_unset_state_changed_cb(g_audio_in);
- audio_in_destroy(g_audio_in);
- g_audio_in = NULL;
- return;
- }
-
- ret = audio_in_prepare(g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- if (AUDIO_IO_ERROR_SOUND_POLICY == ret)
- {
- LOGE("[Recorder ERROR] Audio is busy.");
- } else {
- LOGE("[Recorder ERROR] Fail to start audio : %d", ret);
- }
- sound_manager_remove_device_connection_changed_cb(g_device_id);
- sound_manager_destroy_stream_information(g_stream_info);
- g_stream_info = NULL;
- audio_in_unset_state_changed_cb(g_audio_in);
- audio_in_destroy(g_audio_in);
- g_audio_in = NULL;
- return;
- }
-
- ret = audio_in_pause(g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGE("[Recorder ERROR] Fail to pause audio in : %d", ret);
- }
-}
-
-void dependency_default_audio_deinitialize()
-{
- dependency_default_audio_stop_recording();
-
- int ret = 0;
- if (g_virtual_sound_stream) {
- sound_manager_stop_virtual_stream(g_virtual_sound_stream);
- ret = sound_manager_destroy_virtual_stream(g_virtual_sound_stream);
- if (0 != ret) {
- LOGE("[Audio ERROR] Fail to destroy virtual stream, ret(%d)", ret);
- }
- g_virtual_sound_stream = NULL;
- }
-
- if (g_device_id) {
- ret = sound_manager_remove_device_connection_changed_cb(g_device_id);
- if (0 != ret)
- LOGE("[Audio ERROR] Fail to remove device connection changed callback, ret(%d)", ret);
- }
-
- if (g_volume_stream) {
- ret = sound_manager_destroy_stream_information(g_volume_stream);
- if (0 != ret) {
- LOGE("[Audio ERROR] Fail to destroy stream information, ret(%d)", ret);
- }
- g_volume_stream = NULL;
- }
-
- if (g_audio_in) {
- ret = audio_in_unprepare(g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGD("[Recorder ERROR] Fail to stop audio : %d", ret);
- }
- }
-
- if (g_stream_info) {
- if (0 != sound_manager_destroy_stream_information(g_stream_info)) {
- LOGD("[Recorder ERROR] Fail to destroy stream info");
- }
- g_stream_info = NULL;
- }
-
- if (g_audio_in) {
- ret = audio_in_unset_state_changed_cb(g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGD("[Recorder ERROR] Fail to unset state changed callback : %d", ret);
- }
-
- ret = audio_in_destroy(g_audio_in);
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGD("[Recorder ERROR] Fail to destroy audio : %d", ret);
- }
- g_audio_in = NULL;
- }
-}
-
-static void recorder_thread_func()
-{
- const int FRAME_LENGTH = 160;
- const int BUFFER_LENGTH = FRAME_LENGTH * 2;
-
- static int buffer_count = 0;
-
- while (!(g_stop_recorder_thread.load())) {
- unsigned char buffer[BUFFER_LENGTH];
- memset(buffer, '\0', BUFFER_LENGTH);
-
- int read_bytes = audio_in_read(g_audio_in, buffer, BUFFER_LENGTH);
- if (0 > read_bytes) {
- LOGE("[Recorder WARNING] Fail to read audio : %d", read_bytes);
- break;
- }
-
- g_proxy_interface.feed_audio_data(MAS_SPEECH_STREAMING_EVENT_CONTINUE,
- buffer, read_bytes);
-
- /* Audio read log */
- if (0 == buffer_count % 300) {
- LOGD("[Recorder][%d] Recording... : read_size(%d)", buffer_count, read_bytes);
- }
-
- buffer_count++;
- }
-}
-
-void dependency_default_audio_start_recording()
-{
- if (g_audio_in) {
- int ret = AUDIO_IO_ERROR_NONE;
- if (AUDIO_IO_STATE_RUNNING != g_audio_io_state) {
- ret = audio_in_resume(g_audio_in);
- }
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGD("[Recorder ERROR] Fail to resume audio in : %d", ret);
- }
- g_stop_recorder_thread.store(false);
- LOGD("Starting recorder thread");
- g_recorder_thread = thread(recorder_thread_func);
- }
-}
-
-void dependency_default_audio_stop_recording()
-{
- if (g_recorder_thread.joinable()) {
- LOGD("g_recorder_thread is joinable, trying join()");
- g_stop_recorder_thread.store(true);
- g_recorder_thread.join();
- }
- if (g_audio_in) {
- int ret = AUDIO_IO_ERROR_NONE;
- if (AUDIO_IO_STATE_RUNNING == g_audio_io_state) {
- ret = audio_in_pause(g_audio_in);
- }
- if (AUDIO_IO_ERROR_NONE != ret) {
- LOGD("[Recorder ERROR] Fail to pause audio in : %d", ret);
- }
- }
-}
-
-void dependency_default_audio_set_recording_session(unsigned int session)
-{
- LOGD("Current recording session : [%s]",
- (MAS_RECORDING_SESSION_WAKE_WORD == session) ? "wake word detecting" :
- (MAS_RECORDING_SESSION_UTTERANCE == session) ? "utterance recording" :
- (MAS_RECORDING_SESSION_FOLLOW_UP == session) ? "follow-up speech recording" :
- "ERROR - Invalid recording session information"
- );
-}
-
-void dependency_default_audio_voice_key_pressed_set(bool pressed)
-{
- g_voice_key_pressed = pressed;
-}
-
-void dependency_default_audio_set_background_volume(double ratio)
-{
- LOGD("[ENTER]");
- int ret;
-
- if (ratio >= 0.5) {
- if (g_virtual_sound_stream) {
- ret = sound_manager_stop_virtual_stream(g_virtual_sound_stream);
- if (0 != ret) {
- LOGD("[Audio ERROR] Fail to stop virtual stream, ret(%d)", ret);
- }
- ret = sound_manager_destroy_virtual_stream(g_virtual_sound_stream);
- if (0 != ret) {
- LOGD("[Audio ERROR] Fail to destroy virtual stream, ret(%d)", ret);
- return;
- }
- g_virtual_sound_stream = NULL;
- }
-
- if (g_volume_stream) {
- ret = sound_manager_destroy_stream_information(g_volume_stream);
- if (0 != ret) {
- LOGD("[Audio ERROR] Fail to destroy stream information, ret(%d)", ret);
- return;
- }
- g_volume_stream = NULL;
- }
- } else {
- if (!g_volume_stream) {
- ret = sound_manager_create_stream_information_internal(SOUND_STREAM_TYPE_VOICE_RECOGNITION_SERVICE, NULL, NULL, &g_volume_stream);
- if (0 != ret) {
- LOGD("[Audio] Fail to create stream information, ret(%d)", ret);
- return;
- }
- }
-
- if (!g_virtual_sound_stream) {
- ret = sound_manager_create_virtual_stream(g_volume_stream, &g_virtual_sound_stream);
- if (0 != ret) {
- LOGD("[Audio ERROR] Fail to create virtual stream, ret(%d)", ret);
- return;
- }
- }
- if (g_virtual_sound_stream) {
- ret = sound_manager_start_virtual_stream(g_virtual_sound_stream);
- if (0 != ret) {
- LOGD("[Audio ERROR] Fail to start virtual stream, ret(%d)", ret);
- return;
- }
- }
- }
- LOGD("[EXIT]");
-}
-
-void dependency_default_audio_get_audio_format(int* rate, int* channel, int* audio_type)
-{
- if (!audio_type || !rate || !channel) {
- return;
- }
- *rate = 16000;
- *channel = 0;
- *audio_type = 0;
-}
-
-void dependency_default_audio_get_audio_source_type(char** type)
-{
- static char source_type[] = "default_audio";
- if (!type) {
- return;
- }
- *type = source_type;
-}
+++ /dev/null
-#include "dependency_default_button.h"
-
-#include <chrono>
-
-using namespace std;
-
-#define EFL_BETA_API_SUPPORT
-
-#include <dlog.h>
-#include <Ecore.h>
-#include <Ecore_Input.h>
-#include <Ecore_Wl2.h>
-
-static mas_dependency_plugin_proxy_interface g_proxy_interface;
-
-static Ecore_Event_Handler* g_key_down_handler = NULL;
-static Ecore_Event_Handler* g_key_up_handler = NULL;
-
-static Ecore_Wl2_Display *g_ecore_wl2_display = NULL;
-
-static chrono::time_point<chrono::system_clock> g_last_key_pressed;
-static bool g_voice_key_pressed = false;
-const float DEFAULT_KEY_TAP_DURATION = 0.3f * 1000;
-static float g_voice_key_tap_duration = DEFAULT_KEY_TAP_DURATION;
-
-#define VOICE_KEY "XF86AudioPlayPause"
-
-static Eina_Bool _key_down_cb(void* data, int type, void* event)
-{
- Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
- if (ev) {
- LOGD("KEY[%s], type[%d]", ev->keyname, type);
-
- if (ev->keyname && strncmp(ev->keyname, VOICE_KEY, strlen(VOICE_KEY)) == 0 ) {
- chrono::time_point<chrono::system_clock> current_time_point;
- current_time_point = chrono::system_clock::now();
- auto diff = current_time_point - g_last_key_pressed;
- auto milliseconds = chrono::duration_cast<chrono::milliseconds>(diff).count();
- /* If double click detected within 500 msec */
- if (milliseconds < 500) {
- if (g_proxy_interface.process_event) {
- g_proxy_interface.process_event(MAS_PLUGIN_EVENT_VOICE_KEY_PRESSED, NULL, 0);
- g_voice_key_pressed = true;
- }
- }
- g_last_key_pressed = current_time_point;
- }
- }
-
- return ECORE_CALLBACK_DONE;
-}
-
-static Eina_Bool _key_up_cb(void* data, int type, void* event)
-{
- Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
- if (ev) {
- LOGD("KEY[%s], type[%d]", ev->keyname, type);
-
- if (g_voice_key_pressed &&
- ev->keyname && strncmp(ev->keyname, VOICE_KEY, strlen(VOICE_KEY)) == 0) {
- chrono::time_point<chrono::system_clock> current_time_point;
- current_time_point = chrono::system_clock::now();
- auto diff = current_time_point - g_last_key_pressed;
- long long int milliseconds = chrono::duration_cast<chrono::milliseconds>(diff).count();
- LOGD("milliseconds : %lld", milliseconds);
- mas_plugin_event_e plugin_event;
- if (milliseconds < g_voice_key_tap_duration) {
- plugin_event = MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_TAP;
- } else {
- plugin_event = MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_PUSH;
- }
- if (g_proxy_interface.process_event) {
- g_proxy_interface.process_event(plugin_event, NULL, 0);
- }
- }
- }
- return ECORE_CALLBACK_DONE;
-}
-
-static bool _grab_voice_key(void)
-{
- Eina_Bool ret = true;
- ret = ecore_wl2_window_keygrab_set(NULL, VOICE_KEY, 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_SHARED);
- LOGD("ecore_wl2_window_keygrab_set ret[%d] [%s]", ret, VOICE_KEY);
-
- return ret;
-}
-
-static bool _ungrab_voice_key(void)
-{
- Eina_Bool ret = true;
- ret = ecore_wl2_window_keygrab_unset(NULL, VOICE_KEY, 0, 0);
- LOGD("ecore_wl2_window_keygrab_unset ret[%d] [%s]", ret, VOICE_KEY);
-
- return ret;
-}
-
-static bool _add_key_cb()
-{
- if (g_key_down_handler == NULL) {
- LOGE("_key_down_handler");
- g_key_down_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _key_down_cb, NULL);
- if(g_key_down_handler == NULL) {
- LOGE("_key_down_handler == NULL ");
- }
- }
-
- if (g_key_up_handler == NULL) {
- LOGE("_key_down_handler");
- g_key_up_handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _key_up_cb, NULL);
- if(g_key_up_handler == NULL) {
- LOGE("_key_up_handler == NULL ");
- }
- }
- return true;
-}
-
-static bool _delete_key_cb(void)
-{
- LOGE("start");
- if (NULL != g_key_down_handler) {
- ecore_event_handler_del(g_key_down_handler);
- g_key_down_handler = NULL;
- }
-
- if (NULL != g_key_up_handler) {
- ecore_event_handler_del(g_key_up_handler);
- g_key_up_handler = NULL;
- }
- LOGE("end");
- return true;
-}
-
-void dependency_default_button_initialize(mas_dependency_plugin_proxy_interface interface)
-{
- g_proxy_interface = interface;
-
- Eina_Bool ret = ecore_wl2_init();
- LOGD("ecore_wl2_init: %d", ret);
-
- g_ecore_wl2_display = ecore_wl2_display_connect(NULL);
- LOGD("g_ecore_wl2_display: %p", g_ecore_wl2_display);
-
- g_last_key_pressed = chrono::system_clock::now();
- _grab_voice_key();
- _add_key_cb();
-}
-
-void dependency_default_button_deinitialize()
-{
- if (g_ecore_wl2_display) {
- ecore_wl2_display_disconnect(g_ecore_wl2_display);
- g_ecore_wl2_display = NULL;
- }
- _delete_key_cb();
- _ungrab_voice_key();
-}
-
-void dependency_default_button_set_voice_key_tap_duration(float duration)
-{
- g_voice_key_tap_duration = duration * 1000.0f; // in milliseconds
-}
-
-void dependency_default_button_unset_voice_key_tap_duration(void)
-{
- g_voice_key_tap_duration = DEFAULT_KEY_TAP_DURATION;
-}
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _ASSISTANT_CONFIG_MANAGER_H_
-#define _ASSISTANT_CONFIG_MANAGER_H_
-
-#include <string>
-#include <functional>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-constexpr char LANGUAGE_PREFIX[] = "LANGUAGE_";
-
-typedef void (*foreach_assistant_language_cb)(const char* appid, const char* language, void* user_data);
-
-class CAssistantConfigManager
-{
-public:
- CAssistantConfigManager();
- virtual ~CAssistantConfigManager();
-
- CAssistantConfigManager(const CAssistantConfigManager&) = delete;
- CAssistantConfigManager& operator=(const CAssistantConfigManager&) = delete;
-
- void initialize();
- void deinitialize();
-
- int set_assistant_language(string assistant, string language);
- int get_assistant_language(string assistant, string& language);
-
- void foreach_assistant_language(foreach_assistant_language_cb callback, void* user_data);
-private:
-};
-
-} // wakeup
-} // multiassistant
-
-#endif _ASSISTANT_CONFIG_MANAGER_H_
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef _DEPENDENCY_RESOLVER_H_
-#define _DEPENDENCY_RESOLVER_H_
-
-#include <tzplatform_config.h>
-#include <multi_assistant_service.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**************************************************************************************
- *** Definitions for dependencies
- *************************************************************************************/
-#define MAS_DEPENDENCY_DEFAULT_PATH tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_SHARE"), "multiassistant/")
-#define MAS_DEPENDENCY_DEFAULT_FILENAME "libma-dependency-default.so"
-#define MAS_DEPENDENCY_MODULE_PATH "db/multi-assistant/dependency_module_path"
-
-#define MAS_DEPENDENCY_FUNC_INITIALIZE "mas_dependency_initialize"
-typedef int (*mas_dependency_initialize)(mas_dependency_plugin_proxy_interface interface, int *dependency_version);
-#define MAS_DEPENDENCY_FUNC_DEINITIALIZE "mas_dependency_deinitialize"
-typedef int (*mas_dependency_deinitialize)(void);
-#define MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK "mas_dependency_set_error_callback"
-typedef int (*mas_dependency_set_error_callback)(mas_error_cb callback, void* user_data);
-#define MAS_DEPENDENCY_FUNC_START_RECORDING "mas_dependency_start_recording"
-typedef int (*mas_dependency_start_recording)(void);
-#define MAS_DEPENDENCY_FUNC_STOP_RECORDING "mas_dependency_stop_recording"
-typedef int (*mas_dependency_stop_recording)(void);
-#define MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION "mas_dependency_set_recording_session"
-typedef int (*mas_dependency_set_recording_session)(unsigned int);
-#define MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME "mas_dependency_set_background_volume"
-typedef int (*mas_dependency_set_background_volume)(double ratio);
-#define MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT "mas_dependency_get_audio_format"
-typedef int (*mas_dependency_get_audio_format)(int* rate, int* channel, int* audio_type);
-#define MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE "mas_dependency_get_audio_source_type"
-typedef int (*mas_dependency_get_audio_source_type)(char** type);
-#define MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND "mas_dependency_process_wakeup_engine_command"
-typedef int (*mas_dependency_process_wakeup_engine_command)(const char* engine_name, const char* command);
-#define MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE "mas_dependency_process_wakeup_candidate"
-typedef int (*mas_dependency_process_wakeup_candidate)(const mas_wakeup_event_info* info);
-#define MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION "mas_dependency_set_voice_key_tap_duration"
-typedef int (*mas_dependency_set_voice_key_tap_duration)(float duration);
-#define MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION "mas_dependency_unset_voice_key_tap_duration"
-typedef int (*mas_dependency_unset_voice_key_tap_duration)(void);
-#define MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE "mas_dependency_set_voice_key_support_mode"
-typedef int (*mas_dependency_set_voice_key_support_mode)(const char* support_mode);
-#define MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY "mas_dependency_get_custom_vconf_key"
-typedef int (*mas_dependency_get_custom_vconf_key)(const char* default_key, char** custom_key);
-
-
-typedef struct {
- mas_dependency_initialize initialize;
- mas_dependency_deinitialize deinitialize;
- mas_dependency_set_error_callback set_error_callback;
- mas_dependency_start_recording start_recording;
- mas_dependency_stop_recording stop_recording;
- mas_dependency_set_recording_session set_recording_session;
- mas_dependency_set_background_volume set_background_volume;
- mas_dependency_get_audio_format get_audio_format;
- mas_dependency_get_audio_source_type get_audio_source_type;
- mas_dependency_process_wakeup_engine_command process_wakeup_engine_command;
- mas_dependency_process_wakeup_candidate process_wakeup_candidate;
- mas_dependency_set_voice_key_tap_duration set_voice_key_tap_duration;
- mas_dependency_unset_voice_key_tap_duration unset_voice_key_tap_duration;
- mas_dependency_set_voice_key_support_mode set_voice_key_support_mode;
- mas_dependency_get_custom_vconf_key get_custom_vconf_key;
-} mas_dependency_module_interface;
-
-int dependency_resolver_initialize(mas_dependency_plugin_proxy_interface interface);
-int dependency_resolver_deinitialize(void);
-int dependency_resolver_set_error_callback(mas_error_cb callback, void* user_data);
-int dependency_resolver_start_recording();
-int dependency_resolver_stop_recording();
-int dependency_resolver_set_recording_session(unsigned int);
-int dependency_resolver_set_background_volume(double ratio);
-int dependency_resolver_get_audio_format(int* rate, int* channel, int* audio_type);
-int dependency_resolver_get_audio_source_type(char** type);
-int dependency_resolver_process_wakeup_engine_command(const char* engine, const char* command);
-int dependency_resolver_process_wakeup_candidate(mas_wakeup_event_info* info);
-int dependency_resolver_set_voice_key_tap_duration(float duration);
-int dependency_resolver_unset_voice_key_tap_duration();
-int dependency_resolver_set_voice_key_support_mode(const char* support_mode);
-int dependency_resolver_get_custom_vconf_key(const char* default_key, char** custom_key);
-
-mas_dependency_module_interface* dependency_resolver_get_interface();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _DEPENDENCY_RESOLVER_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __HEAP_TRACER_H__
-#define __HEAP_TRACER_H__
-
-#include <list>
-#include <mutex>
-#include <unordered_map>
-#include <string>
-#include <set>
-
-#ifndef __MODULE__
-#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-#endif
-
-#define vm_calloc_simple(nmemb, size) vm_calloc(nmemb, size, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
-#define vm_malloc_simple(size) vm_malloc(size, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
-#define vm_free_simple(ptr) vm_free(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
-#define vm_strdup_simple(ptr) vm_strdup(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
-#define vm_mark_unmanaged_simple(ptr) vm_mark_unmanaged(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
-
-void *vm_calloc(size_t nmemb, size_t size, const char *fmt, ...);
-void *vm_malloc(size_t size, const char *fmt, ...);
-void vm_free(void *ptr, const char *fmt, ...);
-char *vm_strdup(const char *s, const char *fmt, ...);
-void *vm_mark_unmanaged(void *ptr, const char *fmt, ...);
-
-class HeapTracer {
-public:
- HeapTracer();
- virtual ~HeapTracer();
-
- bool Insert(void *ptr, std::string description, size_t size = 0);
- bool Delete(void *ptr, std::string description);
- std::string Find(void *ptr);
-
- void MarkUnmanaged(void *ptr, std::string description);
-
- bool Empty();
- void Trace();
-protected:
- typedef struct {
- void *ptr{nullptr};
- std::string description;
- int size{0};
- } AllocationEntry;
-
- std::mutex mManagedTableMutex;
- std::unordered_map<void*, AllocationEntry> mManagedTable;
-
- std::mutex mUnmanagedRecordsMutex;
- std::list<AllocationEntry> mUnmanagedRecords;
- size_t mUnmanagedRecordsSize{0};
-
- enum class EntryOperation {
- INSERT,
- DELETE,
- };
- typedef struct {
- AllocationEntry entry;
- EntryOperation operation;
- struct timespec ts;
- } EntryHistory;
- std::list<EntryHistory> mEntryHistory;
-};
-
-#endif /* __HEAP_TRACER_H__ */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef _WAKEUP_AUDIO_MANAGER_H_
-#define _WAKEUP_AUDIO_MANAGER_H_
-
-#include "service_common.h"
-
-#include <atomic>
-#include <list>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-#include <multi_assistant_service.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-class IAudioEventObserver
-{
-public:
- virtual ~IAudioEventObserver() = default;
- virtual bool on_recording_audio_data(long time, void* data, int len) = 0;
- virtual bool on_streaming_audio_data(
- mas_speech_streaming_event_e event, void* buffer, unsigned int len) = 0;
-};
-
-typedef enum
-{
- RECORDING_SESSION_WAKE_WORD,
- RECORDING_SESSION_UTTERANCE,
- RECORDING_SESSION_FOLLOW_UP,
-} recording_session;
-
-class CAudioManager
-{
-public:
- CAudioManager();
- CAudioManager(IAudioEventObserver *observer);
- ~CAudioManager();
-
- CAudioManager(const CAudioManager&) = delete;
- CAudioManager& operator=(const CAudioManager&) = delete;
-
- int initialize();
- int deinitialize();
-
- void sound_focus_changed();
-
- /* NOTE : The observer that is being passed to this subscribe() function
- * must not be deleted before the call to CAudioManager::deinitialize(),
- * since the observer's callback can be called even after unsubscribe() */
- void subscribe(IAudioEventObserver *observer);
- void unsubscribe(IAudioEventObserver *observer);
-
- void start_recording(bool proactive);
- void stop_recording(bool proactive);
-
- void set_recording_session(recording_session session);
-
- void feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
- void finalize_audio_data();
- void clear_audio_data();
-
- void start_streaming_current_utterance_data(long long start_time = 0);
- void stop_streaming_current_utterance_data();
-
- void start_streaming_previous_utterance_data();
- void stop_streaming_previous_utterance_data();
-
- void start_streaming_follow_up_data();
- void stop_streaming_follow_up_data();
-
- void set_background_volume(double ratio);
-conditional_public:
- void add_audio_data(mas_speech_data& data, long long time);
- void notify_audio_data_recording(long time, void* data, int len);
-
- void streaming_previous_audio_data_thread_func();
- void streaming_audio_data_thread_func(long long start_time);
-
-private:
- int mSoundFocusWatchId{0};
- bool mRecordingRequired{false};
- bool mIsRecording{false};
-
- vector<IAudioEventObserver*> mObservers;
-
- thread mStreamingThread;
- atomic_bool mStopStreamingThread{false};
- atomic_bool mStreamingThreadActive{false};
-
- thread mStreamingPreviousThread;
- atomic_bool mStopStreamingPreviousThread{false};
-
- static constexpr long long mAudioRecordingDurationMilliseconds = 10 * 1000;
- typedef struct {
- long long time;
- mas_speech_data data;
- } mas_speech_data_with_time;
- vector<mas_speech_data_with_time> mPreviousAudioData;
- list<mas_speech_data_with_time> mAudioData;
-
- mutex mMutex;
- bool mVoiceKeyPressed{false};
-
- thread mBackgroundVolumeThread;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_AUDIO_MANAGER_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_ENGINE_MANAGER_H_
-#define _WAKEUP_ENGINE_MANAGER_H_
-
-#include "wakeup_manager_wrapper.h"
-
-#include <atomic>
-#include <string>
-#include <thread>
-#include <vector>
-#include <set>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-/**************************************************************************************
- *** Definitions for wakeup engine interface
- *************************************************************************************/
-#define MA_WAKEUP_ENGINE_PATH tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_SHARE"), "multiassistant/engines")
-/* Need to check whether this dedicated engine path also needs to be configurable */
-#define MA_WAKEUP_DEDICATED_ENGINE_PATH "shared/lib/libwakeup-engine.so"
-
-/* Interfaces without version information */
-#define MA_WAKEUP_ENGINE_FUNC_INITIALIZE "wakeup_engine_initialize"
-typedef int (*wakeup_engine_initialize)(void);
-#define MA_WAKEUP_ENGINE_FUNC_DEINITIALIZE "wakeup_engine_deinitialize"
-typedef int (*wakeup_engine_deinitialize)(void);
-#define MA_WAKEUP_ENGINE_FUNC_ACTIVATE "wakeup_engine_activate"
-typedef int (*wakeup_engine_activate)(void);
-#define MA_WAKEUP_ENGINE_FUNC_DEACTIVATE "wakeup_engine_deactivate"
-typedef int (*wakeup_engine_deactivate)(void);
-#define MA_WAKEUP_ENGINE_FUNC_ADD_WAKEUP_WORD "wakeup_engine_add_wakeup_word"
-typedef int (*wakeup_engine_add_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
-#define MA_WAKEUP_ENGINE_FUNC_REMOVE_WAKEUP_WORD "wakeup_engine_remove_wakeup_word"
-typedef int (*wakeup_engine_remove_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
-#define MA_WAKEUP_ENGINE_FUNC_ADD_LANGUAGE "wakeup_engine_add_language"
-typedef int (*wakeup_engine_add_language)(const char* appid, const char* language);
-#define MA_WAKEUP_ENGINE_FUNC_SET_LANGUAGE "wakeup_engine_set_language"
-typedef int (*wakeup_engine_set_language)(const char* language);
-#define MA_WAKEUP_ENGINE_FUNC_UPDATE_MANAGER_STATE "wakeup_engine_update_manager_state"
-typedef int (*wakeup_engine_update_manager_state)(wakeup_manager_state_e state);
-#define MA_WAKEUP_ENGINE_FUNC_UPDATE_RECOGNITION_RESULT "wakeup_engine_update_recognition_result"
-typedef int (*wakeup_engine_update_recognition_result)(const char* appid, int result);
-#define MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_FORMAT "wakeup_engine_set_audio_format"
-typedef int (*wakeup_engine_set_audio_format)(int rate, int channel, int audio_type);
-#define MA_WAKEUP_ENGINE_FUNC_GET_AUDIO_FORMAT "wakeup_engine_get_audio_format"
-typedef int (*wakeup_engine_get_audio_format)(int* rate, int* channel, int* audio_type);
-#define MA_WAKEUP_ENGINE_FUNC_FEED_AUDIO_DATA "wakeup_engine_feed_audio_data"
-typedef int (*wakeup_engine_feed_audio_data)(long time, void* data, int len);
-#define MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA_COUNT "wakeup_engine_get_utterance_data_count"
-typedef int (*wakeup_engine_get_utterance_data_count)(void);
-#define MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA "wakeup_engine_get_utterance_data"
-typedef int (*wakeup_engine_get_utterance_data)(int index, mas_speech_data *data);
-#define MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA_COUNT "wakeup_engine_get_wake_word_data_count"
-typedef int (*wakeup_engine_get_wake_word_data_count)(void);
-#define MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA "wakeup_engine_get_wake_word_data"
-typedef int (*wakeup_engine_get_wake_word_data)(int index, mas_speech_data *data);
-#define MA_WAKEUP_ENGINE_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND "wakeup_engine_set_assistant_specific_command"
-typedef int (*wakeup_engine_set_assistant_specific_command)(const char* appid, const char* command);
-#define MA_WAKEUP_ENGINE_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG "wakeup_engine_set_wake_word_audio_require_flag"
-typedef int (*wakeup_engine_set_wake_word_audio_require_flag)(bool require);
-#define MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_EVENT_CALLBACK "wakeup_engine_set_wakeup_event_callback"
-typedef int (*wakeup_engine_set_wakeup_event_callback)(wakeup_service_wakeup_event_cb callback, void* user_data);
-#define MA_WAKEUP_ENGINE_FUNC_SET_SPEECH_STATUS_CALLBACK "wakeup_engine_set_speech_status_callback"
-typedef int (*wakeup_engine_set_speech_status_callback)(wakeup_service_speech_status_cb callback, void* user_data);
-#define MA_WAKEUP_ENGINE_FUNC_SET_ERROR_CALLBACK "wakeup_engine_set_error_callback"
-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"
-typedef int (*wakeup_engine_get_version)(int* version);
-#define MA_WAKEUP_ENGINE_FUNC_SET_DEPENDENCY_MODULE_COMMAND "wakeup_engine_set_dependency_module_command"
-typedef int (*wakeup_engine_set_dependency_module_command)(const char* command);
-
-typedef struct {
- wakeup_engine_initialize initialize;
- wakeup_engine_deinitialize deinitialize;
- wakeup_engine_activate activate;
- wakeup_engine_deactivate deactivate;
- wakeup_engine_add_wakeup_word add_wakeup_word;
- wakeup_engine_remove_wakeup_word remove_wakeup_word;
- wakeup_engine_add_language add_language;
- wakeup_engine_set_language set_language;
- wakeup_engine_update_manager_state update_manager_state;
- wakeup_engine_update_recognition_result update_recognition_result;
- wakeup_engine_set_audio_format set_audio_format;
- wakeup_engine_get_audio_format get_audio_format;
- wakeup_engine_feed_audio_data feed_audio_data;
- wakeup_engine_get_utterance_data_count get_utterance_data_count;
- wakeup_engine_get_utterance_data get_utterance_data;
- wakeup_engine_get_wake_word_data_count get_wake_word_data_count;
- wakeup_engine_get_wake_word_data get_wake_word_data;
- wakeup_engine_get_version get_version;
- wakeup_engine_set_assistant_specific_command set_assistant_specific_command;
- wakeup_engine_set_wake_word_audio_require_flag set_wake_word_audio_require_flag;
- wakeup_engine_set_dependency_module_command set_dependency_module_command;
- wakeup_engine_set_wakeup_event_callback set_wakeup_event_callback;
- 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
-{
-public:
- virtual ~IEngineEventObserver() = default;
- virtual bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info) = 0;
- virtual bool on_speech_status(string engine_name, mas_speech_status_e status) = 0;
- virtual bool on_error(string engine_name, int error_code, string error_message) = 0;
- virtual bool on_audio_data_require_status(string engine_name, bool require) = 0;
-
- virtual bool on_streaming_audio_data(
- mas_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(
- mas_wakeup_engine_command_target_e target, string engine_name, string assistant_name, string command) = 0;
-};
-
-class CWakeupEngineManager
-{
-public:
- CWakeupEngineManager();
- CWakeupEngineManager(IEngineEventObserver *observer);
- virtual ~CWakeupEngineManager();
-
- CWakeupEngineManager(const CWakeupEngineManager&) = delete;
- CWakeupEngineManager& operator=(const CWakeupEngineManager&) = delete;
-
- void initialize();
- void deinitialize();
-
- void subscribe(IEngineEventObserver *observer);
- void unsubscribe(IEngineEventObserver *observer);
-
- bool get_audio_data_required();
- void set_selected_wakeup_info(mas_wakeup_event_info wakeup_info);
-
- bool set_language(string language);
- bool set_assistant_language(string appid, string language);
- void set_assistant_activated(string appid, bool activated);
- bool get_assistant_activated(string appid);
- void set_wake_word_audio_require_flag(bool require);
-
- void start_streaming_current_utterance_data();
- void stop_streaming_current_utterance_data();
-
- void update_manager_state(wakeup_manager_state_e state);
- void update_recognition_result(string appid, int result);
-
- void engine_add_target_assistant(string engine_name, string appid);
- void engine_add_wakeup_word(string appid, string wakeup_word, string language);
- void engine_remove_wakeup_word(string appid, string wakeup_word, string language);
- void engine_set_assistant_specific_command(string appid, string command);
- void engine_set_dependency_module_command(string engine_name, string command);
- void engine_feed_audio_data(long time, void* data, int len);
-
- bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info);
- bool on_speech_status(string engine_name, mas_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,
- mas_wakeup_engine_command_target_e target, string assistant_name, string command);
-private:
- typedef struct {
- int version;
- string engine_name;
- bool activated{false};
- bool audio_data_require_status{false};
- string engine_path;
- wakeup_engine_interface interface{nullptr, };
- vector<string> assistant_list;
- set<string> activated_assistants;
- void *engine_handle{nullptr};
- } EngineInfo;
-
- void add_engine_directory(string name, string path);
- void add_engine(string name, string path);
-
- vector<IEngineEventObserver*> mObservers;
-
- void streaming_speech_data_thread_func();
-
- vector<EngineInfo> mEngineInfo;
- const EngineInfo* mSelectedEngine{nullptr};
- bool mAudioDataRequired{false};
-
- thread mStreamingThread;
- atomic_bool mStopStreamingThread{false};
- wakeup_manager_state_e mWakeupManagerState{WAKEUP_MANAGER_STATE_INACTIVE};
-
- bool mWakeWordAudioRequired{false};
-
- typedef struct {
- atomic_llong last_audio_fetched{0};
- atomic_llong last_count_fetched{0};
- atomic_llong last_audio_sent{0};
- } StreamingHistory;
-
- StreamingHistory mStreamingHistory;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_ENGINE_MANAGER_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef _WAKEUP_MANAGER_H_
-#define _WAKEUP_MANAGER_H_
-
-#include "service_config.h"
-#include "wakeup_manager_wrapper.h"
-#include "wakeup_settings.h"
-#include "wakeup_engine_manager.h"
-#include "wakeup_audio_manager.h"
-#include "wakeup_policy_default.h"
-#include "assistant_config_manager.h"
-
-#include <memory>
-#include <map>
-#include <mutex>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-#define WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID "db/multi-assistant/default_assistant_appid"
-#define WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS "db/multi-assistant/enabled_assistants"
-#define WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED "db/multi-assistant/wake_word_detection_enabled"
-
-enum class STREAMING_MODE {
- NONE,
- UTTERANCE,
- PREVIOUS_UTTERANCE,
- FOLLOW_UP,
-};
-
-class IWakeupEventObserver {
-public:
- virtual ~IWakeupEventObserver() = default;
- virtual void on_wakeup(mas_wakeup_event_info wakeup_info) = 0;
- virtual void on_streaming_audio_data(
- mas_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(
- mas_wakeup_engine_command_target_e target, const char* name, const char* command) = 0;
- virtual void on_wakeup_service_state_changed(ma_service_state_e state) = 0;
- virtual void on_voice_key_status_changed(ma_voice_key_status_e status) = 0;
-};
-
-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,
- the wakeup_engine attribute of wakeup_event_info will have the following value */
-#define WAKEUP_ENGINE_VOICE_KEY "voice_key"
-
-class CWakeupManager
-{
-public:
- CWakeupManager(IWakeupEventObserver* wakeup_observer, ISettingValueObserver* setting_observer);
- virtual ~CWakeupManager();
-
- CWakeupManager(const CWakeupManager&) = delete;
- CWakeupManager& operator=(const CWakeupManager&) = delete;
-
- bool initialize();
- bool deinitialize();
-
- void subscribe_wakeup_observer(IWakeupEventObserver* observer);
- void unsubscribe_wakeup_observer(IWakeupEventObserver* observer);
-
- void subscribe_setting_observer(ISettingValueObserver* observer);
- void unsubscribe_setting_observer(ISettingValueObserver* observer);
-
- bool activate();
- bool deactivate();
-
- bool add_assistant_language(string appid, string language);
- bool add_assistant_wakeup_word(string appid, string wakeup_word, string language);
- bool remove_assistant_wakeup_word(string appid, string wakeup_word, string language);
- bool add_assistant_wakeup_engine(string appid, string engine);
- bool set_assistant_language(string appid, string language);
-
- bool set_assistant_enabled(string appid, bool enabled);
- bool get_assistant_enabled(string appid);
- bool set_default_assistant(string appid);
- bool process_default_assistant_changed(string appid, bool expected);
- string get_default_assistant();
-
- bool update_voice_feedback_state(string appid, bool state);
- bool set_assistant_specific_command(string appid, string command);
- bool set_background_volume(string appid, double ratio);
- bool update_recognition_result(string appid, int result);
- bool process_plugin_event(mas_plugin_event_e event, void* data, int len);
- bool get_audio_format(int* rate, int* channel, int* audio_type);
- bool get_audio_source_type(char** type);
- bool set_language(string language);
- bool get_recording_by_voice_key();
- void set_recording_by_voice_key(bool recording);
- bool set_voice_key_tap_duration(float duration);
- bool unset_voice_key_tap_duration();
- bool set_voice_key_support_mode(VOICE_KEY_SUPPORT_MODE mode);
- bool set_wake_word_audio_require_flag(bool require);
-
- STREAMING_MODE get_streaming_mode();
- bool set_streaming_mode(STREAMING_MODE mode);
-
- bool start_streaming_utterance_data();
- bool stop_streaming_utterance_data();
- bool start_streaming_follow_up_data();
- bool stop_streaming_follow_up_data();
- bool start_streaming_previous_utterance_data();
- bool stop_streaming_previous_utterance_data();
-
- CWakeupPolicy* get_wakeup_policy();
- CWakeupEngineManager* get_engine_manager();
- CAudioManager* get_audio_manager();
- CWakeupSettings* get_wakeup_settings();
-
- vector<IWakeupEventObserver*> get_wakeup_observers();
- void set_last_wakeup_event_info(mas_wakeup_event_info wakeup_info);
-
- vector<ISettingValueObserver*> get_setting_observers();
-
- bool change_manager_state(wakeup_manager_state_e state);
- wakeup_manager_state_e get_manager_state();
-
- void feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
- void set_dependency_module_command(string engine_name, string command);
-
- void start_streaming_duration_timer();
- void stop_streaming_duration_timer();
-
- void set_streaming_duration_timer(Ecore_Timer* timer);
- Ecore_Timer* get_streaming_duration_timer();
-
- void start_periodic_monitor_timer();
- void stop_periodic_monitor_timer();
-
- void update_voice_key_status(ma_voice_key_status_e status);
- void update_pending_voice_key_status();
-
- void start_voice_key_status_update_timer();
- void set_streaming_completed(bool completed);
-private:
- class CEngineEventObserver : public IEngineEventObserver
- {
- public:
- bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info) override;
- bool on_speech_status(string engine_name, mas_speech_status_e status) override;
- bool on_error(string engine_name, int error_code, string error_message) override;
- bool on_audio_data_require_status(string engine_name, bool require) override;
-
- bool on_streaming_audio_data(
- mas_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(
- mas_wakeup_engine_command_target_e target, string engine, string name, string command) override;
-
- void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
- private:
- CWakeupManager *mWakeupManager{nullptr};
- };
-
- class CPolicyEventObserver : public IPolicyEventObserver
- {
- public:
- void on_wakeup(mas_wakeup_event_info wakeup_info) override;
-
- void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
- private:
- CWakeupManager *mWakeupManager{nullptr};
- };
-
- class CAudioEventObserver : public IAudioEventObserver
- {
- public:
- bool on_recording_audio_data(long time, void* data, int len) override;
- bool on_streaming_audio_data(
- mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
-
- void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
- void set_wakeup_engine_manager(CWakeupEngineManager *manager) { mEngineManager = manager; }
- private:
- CWakeupManager *mWakeupManager{nullptr};
- CWakeupEngineManager *mEngineManager{nullptr};
- };
-
- class CSettingsEventObserver : public ISettingsEventObserver
- {
- public:
- 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;
- bool on_wake_word_detection_enabled_info_changed() override;
-
- void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
- private:
- CWakeupManager *mWakeupManager{nullptr};
- };
-
- void initialize_wakeup_policy();
-
- typedef struct {
- string appid;
- vector<string> languageList;
- } AssistantLanguageInfo;
- vector<AssistantLanguageInfo> mAssistantLanguageInfo;
- map<string, bool> mAssistantSupportsCurrentLanguage;
- map<string, bool> mAssistantEnabled;
-
- vector<IWakeupEventObserver*> mWakeupObservers;
- vector<ISettingValueObserver*> mSettingObservers;
-
- unique_ptr<CWakeupPolicy> mWakeupPolicy;
-
- CAudioManager mAudioManager;
- CWakeupEngineManager mWakeupEngineManager;
- CWakeupSettings mWakeupSettings;
- CAssistantConfigManager mAssistantConfigManager;
-
- CAudioEventObserver mAudioEventObserver;
- CEngineEventObserver mEngineEventObserver;
- CPolicyEventObserver mPolicyEventObserver;
- CSettingsEventObserver mSettingsEventObserver;
-
- thread mEngineDataThread;
- atomic_bool mStopEngineDataThread{false};
-
- bool mRecordingByVoiceKey{false};
-
- string mCurrentLanguage;
- string mCurrentDefaultAssistant;
- /* Assume Push-to-talk is the default mode */
- VOICE_KEY_SUPPORT_MODE mCurrentVoiceKeySupportMode{VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK};
-
- STREAMING_MODE mStreamingMode{STREAMING_MODE::NONE};
- Ecore_Timer* mStreamingDurationTimer{nullptr};
- Ecore_Timer* mPeriodicMonitorTimer{nullptr};
-
- wakeup_manager_state_e mWakeupManagerState{WAKEUP_MANAGER_STATE_INACTIVE};
-
- mas_wakeup_event_info mLastWakeupEventInfo;
-
- unsigned int mLastWakeupEventID{0};
- unsigned int mCurrentStreamingSessionID{0};
-
- boost::optional<ma_voice_key_status_e> mPendingVoiceKeyStatus;
- atomic_bool mStreamingCompleted{false};
- Ecore_Timer *mVoiceKeyStatusUpdateTimer{nullptr};
- mutex mVoiceKeyStatusUpdateMutex;
-
- mutex mMutex;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_MANAGER_H_ */
+++ /dev/null
-#ifndef __MUTLI_WAKEUP_MAIN_H__
-#define __MUTLI_WAKEUP_MAIN_H__
-
-#include <dlog.h>
-#include <glib.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "multi-assistant"
-
-#ifdef __MODULE__
-#undef __MODULE__
-#endif
-#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-
-#define MWR_SECURE_LOG_(id, prio, tag, fmt, arg...) \
- ({ do { \
- __dlog_print(id, prio, tag, "%s: %s(%d) > [SECURE_LOG] " fmt, __MODULE__, __func__, __LINE__, ##arg); \
- } while (0); })
-
-#define MWR_LOG_(prio, tag, fmt, arg...) \
- ({ do { \
- dlog_print(prio, tag, "%s: %s(%d) > " fmt, __MODULE__, __func__, __LINE__, ##arg); \
- } while (0); })
-
-#define MWR_LOGD(fmt, args...) MWR_LOG_(DLOG_DEBUG, LOG_TAG, fmt, ##args)
-#define MWR_LOGI(fmt, args...) MWR_LOG_(DLOG_INFO, LOG_TAG, fmt, ##args)
-#define MWR_LOGW(fmt, args...) MWR_LOG_(DLOG_WARN, LOG_TAG, fmt, ##args)
-#define MWR_LOGE(fmt, args...) MWR_LOG_(DLOG_ERROR, LOG_TAG, fmt, ##args)
-
-#define MWR_SLOGD(fmt, args...) MWR_SECURE_LOG_(DLOG_DEBUG, LOG_TAG, fmt, ##args)
-#define MWR_SLOGI(fmt, args...) MWR_SECURE_LOG_(DLOG_INFO, LOG_TAG, fmt, ##args)
-#define MWR_SLOGW(fmt, args...) MWR_SECURE_LOG_(DLOG_WARN, LOG_TAG, fmt, ##args)
-#define MWR_SLOGE(fmt, args...) MWR_SECURE_LOG_(DLOG_ERROR, LOG_TAG, fmt, ##args)
-
-#endif /* __MUTLI_WAKEUP_MAIN_H__ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef _WAKEUP_MANAGER_WRAPPER_H_
-#define _WAKEUP_MANAGER_WRAPPER_H_
-
-#include <dlog.h>
-#include <stdbool.h>
-#include <tizen.h>
-#include <tzplatform_config.h>
-
-#include <multi_assistant_service.h>
-#include <multi_assistant_internal.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
- WAKEUP_MANAGER_STATE_INACTIVE = 0,
- WAKEUP_MANAGER_STATE_LISTENING = 1,
- WAKEUP_MANAGER_STATE_UTTERANCE = 2,
- WAKEUP_MANAGER_STATE_PROCESSING = 3,
- WAKEUP_MANAGER_STATE_VOICE_FEEDBACK = 4
-} wakeup_manager_state_e;
-
-typedef void (*ma_audio_streaming_data_section_changed_cb)(ma_audio_streaming_data_section_e section, void* user_data);
-
-typedef void (*wakeup_service_wakeup_event_cb)(mas_wakeup_event_info wakeup_info, void* user_data);
-
-typedef void (*wakeup_service_speech_streaming_cb)(mas_speech_streaming_event_e event, void* buffer, int len, void *user_data);
-
-typedef void (*wakeup_service_speech_status_cb)(mas_speech_status_e status, void *user_data);
-
-typedef void (*wakeup_service_setting_changed_cb)( void *user_data);
-
-typedef void (*wakeup_service_error_cb)(int error, const char* err_msg, void* user_data);
-
-typedef void (*wakeup_service_audio_data_require_status_cb)(bool require, void* user_data);
-
-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)(mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command, void* user_data);
-
-typedef void (*wakeup_service_state_changed_cb)(ma_service_state_e state, void* user_data);
-
-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;
-} ma_plugin_settings;
-
-EXPORT_API int wakeup_manager_initialize(void);
-
-EXPORT_API int wakeup_manager_deinitialize(void);
-
-EXPORT_API int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size);
-
-EXPORT_API int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language);
-
-EXPORT_API int wakeup_manager_remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language);
-
-EXPORT_API int wakeup_manager_add_assistant_language(const char* appid, const char* language);
-
-EXPORT_API int wakeup_manager_add_assistant_wakeup_engine(const char* appid, const char *engine);
-
-EXPORT_API int wakeup_manager_set_default_assistant(const char* appid);
-
-EXPORT_API int wakeup_manager_get_default_assistant(const char** appid);
-
-EXPORT_API int wakeup_manager_set_language(const char* language);
-
-EXPORT_API int wakeup_manager_activate(void);
-
-EXPORT_API int wakeup_manager_deactivate(void);
-
-EXPORT_API int wakeup_manager_update_voice_feedback_state(const char *appid, int state);
-
-EXPORT_API int wakeup_manager_set_assistant_specific_command(const char* appid, const char* command);
-
-EXPORT_API int wakeup_manager_set_background_volume(const char *appid, double ratio);
-
-EXPORT_API int wakeup_manager_update_recognition_result(const char *appid, int result);
-
-EXPORT_API int wakeup_manager_process_plugin_event(mas_plugin_event_e event, void* data, int len);
-
-EXPORT_API int wakeup_manager_start_streaming_utterance_data(void);
-
-EXPORT_API int wakeup_manager_stop_streaming_utterance_data(void);
-
-EXPORT_API int wakeup_manager_start_streaming_previous_utterance_data(void);
-
-EXPORT_API int wakeup_manager_stop_streaming_previous_utterance_data(void);
-
-EXPORT_API int wakeup_manager_start_streaming_follow_up_data(void);
-
-EXPORT_API int wakeup_manager_stop_streaming_follow_up_data(void);
-
-EXPORT_API int wakeup_manager_get_audio_format(int *rate, int *channel, int *audio_type);
-
-EXPORT_API int wakeup_manager_get_audio_source_type(char** type);
-
-EXPORT_API int wakeup_manager_set_voice_key_tap_duration(float duration);
-
-EXPORT_API int wakeup_manager_unset_voice_key_tap_duration();
-
-EXPORT_API int wakeup_manager_set_voice_key_support_mode(int mode);
-
-EXPORT_API int wakeup_manager_set_wake_word_audio_require_flag(bool require);
-
-EXPORT_API int wakeup_manager_set_assistant_language(const char* appid, const char *language);
-
-EXPORT_API int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data);
-
-EXPORT_API int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data);
-
-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);
-
-EXPORT_API int wakeup_manager_set_wakeup_service_state_changed_callback(wakeup_service_state_changed_cb callback, void* user_data);
-
-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);
-
-int wakeup_manager_set_dependency_module_command(const char* engine_name, const char* command);
-
-int wakeup_manager_wakeup_assistant(const mas_wakeup_event_info* wakeup_info);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _WAKEUP_MANAGER_WRAPPER_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_POLICY_H_
-#define _WAKEUP_POLICY_H_
-
-#include <string>
-#include <memory>
-
-#include <multi_assistant_service.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-class IPolicyEventObserver
-{
-public:
- virtual ~IPolicyEventObserver() = default;
- virtual void on_wakeup(mas_wakeup_event_info wakeup_info) = 0;
-};
-
-class CWakeupPolicyImpl;
-
-class CWakeupPolicy
-{
-public:
- CWakeupPolicy();
- CWakeupPolicy(IPolicyEventObserver *observer);
- virtual ~CWakeupPolicy();
-
- CWakeupPolicy(const CWakeupPolicy&) = delete;
- CWakeupPolicy& operator=(const CWakeupPolicy&) = delete;
-
- virtual bool valid() = 0;
-
- void subscribe(IPolicyEventObserver *observer);
- void unsubscribe(IPolicyEventObserver *observer);
-
- virtual void wakeup_candidate(mas_wakeup_event_info wakeup_info) = 0;
- virtual void select_candidate(mas_wakeup_event_info wakeup_info) = 0;
-protected:
- unique_ptr<CWakeupPolicyImpl> mImpl;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_POLICY_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_POLICY_DEFAULT_H_
-#define _WAKEUP_POLICY_DEFAULT_H_
-
-#include "wakeup_policy.h"
-
-#include <vector>
-#include <string>
-
-#include <Ecore.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-typedef struct {
- std::string wakeup_appid;
- std::string wakeup_word;
- std::string wakeup_language;
- 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;
-
-
-using namespace std;
-
-class CWakeupPolicyDefault : public CWakeupPolicy
-{
-public:
- CWakeupPolicyDefault(IPolicyEventObserver *observer);
- ~CWakeupPolicyDefault();
-
- bool valid() override;
-
- void set_assistant_priority(string appid, int priority);
-
- void wakeup_candidate(mas_wakeup_event_info wakeup_info) override;
- void select_candidate(mas_wakeup_event_info wakeup_info) override;
-
- void timer_expired();
-
- void set_delay(float seconds);
- float get_delay();
-
- void set_timer(Ecore_Timer* timer);
- Ecore_Timer* get_timer();
-
-private:
- typedef struct {
- string appid;
- int priority{0};
- } PRIORITY_INFO;
-
- float mDelaySeconds{0.0f};
- vector<PRIORITY_INFO> mPriorityInfos;
- vector<mas_wakeup_event_info_wrapper> mWakeupInfos;
-
- Ecore_Timer *mTimer{nullptr};
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_POLICY_H_ */
+++ /dev/null
-/*
- * Copyright 2018 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_POLICY_EXTERNAL_H_
-#define _WAKEUP_POLICY_EXTERNAL_H_
-
-#include "wakeup_policy.h"
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-class CWakeupPolicyExternal : public CWakeupPolicy
-{
-public:
- CWakeupPolicyExternal(IPolicyEventObserver *observer);
- ~CWakeupPolicyExternal();
-
- bool valid() override;
-
- void wakeup_candidate(mas_wakeup_event_info wakeup_info) override;
- void select_candidate(mas_wakeup_event_info wakeup_info) override;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_POLICY_EXTERNAL_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_POLICY_IMPL_H_
-#define _WAKEUP_POLICY_IMPL_H_
-
-#include "wakeup_policy.h"
-#include <string>
-#include <vector>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-class CWakeupPolicyImpl
-{
-public:
- CWakeupPolicyImpl() {}
- ~CWakeupPolicyImpl() {}
-
- void subscribe(IPolicyEventObserver *observer);
- void unsubscribe(IPolicyEventObserver *observer);
-
- void wakeup(mas_wakeup_event_info wakeup_info);
-private:
- vector<IPolicyEventObserver*> mObservers;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_POLICY_IMPL_H_ */
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _WAKEUP_SETTINGS_H_
-#define _WAKEUP_SETTINGS_H_
-
-#include <string>
-#include <vector>
-#include <vconf.h>
-#include <map>
-
-//#define ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
-
-typedef void (*input_language_changed_cb)(void* data);
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-using namespace std;
-
-#define WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID "db/multi-assistant/default_assistant_appid"
-#define WAKEUP_SETTINGS_KEY_UI_PANEL_ENABLED "db/multi-assistant/ui_panel_enabled"
-#define WAKEUP_SETTINGS_KEY_CONVERSATION_TIMEOUT "db/multi-assistant/conversation_timeout"
-#define WAKEUP_SETTINGS_KEY_MULTIPLE_MODE "db/multi-assistant/multiple_mode"
-#define WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS "db/multi-assistant/enabled_assistants"
-#define WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_DELAY "db/multi-assistant/wakeup_policy_delay"
-#define WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_PRIORITY "db/multi-assistant/wakeup_policy_priority"
-#define WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX "db/multi-assistant/streaming_duration_max"
-#define WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE "db/multi-assistant/voice_input_language"
-#define WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED "db/multi-assistant/wake_word_detection_enabled"
-
-class ISettingsEventObserver
-{
-public:
- virtual ~ISettingsEventObserver() = default;
- 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;
- virtual bool on_wake_word_detection_enabled_info_changed() = 0;
-};
-
-class CWakeupSettings
-{
-public:
- CWakeupSettings();
- virtual ~CWakeupSettings();
-
- CWakeupSettings(const CWakeupSettings&) = delete;
- CWakeupSettings& operator=(const CWakeupSettings&) = delete;
-
- void initialize(map<string, string> custom_keys);
- void deinitialize();
-
- void subscribe(ISettingsEventObserver *observer);
- void unsubscribe(ISettingsEventObserver *observer);
- const vector<ISettingsEventObserver*>& get_observers();
-
- string get_default_assistant_appid();
- void set_default_assistant_appid(std::string appid);
-
- bool get_ui_panel_enabled();
- float get_conversation_timeout();
- bool get_multiple_mode();
- vector<string> get_enabled_assistants();
- float get_wakeup_policy_delay();
- vector<string> get_wakeup_policy_priority();
- float get_streaming_duration_max();
- void set_streaming_duration_max(float duration);
- string get_current_language(void);
- vector<string> get_wake_word_disabled_assistants();
-private:
- vector<ISettingsEventObserver*> mObservers;
-
- string mDefaultAssistantAppid;
- bool mUiPanelEnabled{true};
- float mConversationTimeout{5.0};
- bool mMultipleMode{false};
- vector<string> mEnabledAssistants;
- float mWakeupPolicyDelay{0.0};
- vector<string> mWakeupPolicyPriority; // No priority by default
- float mStreamingDurationMax{15.0};
- string mVoiceInputLanguage;
- map<string, string> mCustomVconfKeys;
- vector<string> mWakeWordDisabledAssistants;
-};
-
-} // wakeup
-} // multiassistant
-
-#endif /* _WAKEUP_SETTINGS_H_ */
+++ /dev/null
-#include "wakeup_manager_main.h"
-#include "assistant_config_manager.h"
-
-#include <string.h>
-
-#include <app_preference.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-CAssistantConfigManager::CAssistantConfigManager()
-{
-}
-
-CAssistantConfigManager::~CAssistantConfigManager()
-{
-}
-
-void CAssistantConfigManager::initialize()
-{
-}
-
-void CAssistantConfigManager::deinitialize()
-{
-}
-
-int CAssistantConfigManager::set_assistant_language(string assistant, string language)
-{
- string key = string{LANGUAGE_PREFIX} + assistant;
-
- preference_set_string(key.c_str(), language.c_str());
- MWR_LOGE("Set assistant language : %s %s", key.c_str(), language.c_str());
-
- return 0;
-}
-
-int CAssistantConfigManager::get_assistant_language(string assistant, string& language)
-{
- string key = string{LANGUAGE_PREFIX} + assistant;
-
- bool existing = false;
- preference_is_existing(key.c_str(), &existing);
- if (!existing) return -1;
-
- char* value = nullptr;
- preference_get_string(key.c_str(), &value);
- if (nullptr == value) return -1;
-
- language = value;
- MWR_LOGE("Got assistant language : %s %s", key.c_str(), language.c_str());
- free(value);
-
- return 0;
-}
-
-void CAssistantConfigManager::foreach_assistant_language(foreach_assistant_language_cb callback, void* user_data)
-{
- typedef struct {
- foreach_assistant_language_cb callback;
- void* user_data;
- } foreach_assistant_language_cb_closure;
-
- foreach_assistant_language_cb_closure closure;
- closure.callback = callback;
- closure.user_data = user_data;
-
- preference_foreach_item(
- [](const char *key, void *data) {
- string prefix = string{LANGUAGE_PREFIX};
- foreach_assistant_language_cb_closure* closure =
- static_cast<foreach_assistant_language_cb_closure*>(data);
- if (key && strlen(key) > prefix.length() &&
- 0 == prefix.compare(0, prefix.length(), key, prefix.length())) {
- char* value = nullptr;
- preference_get_string(key, &value);
- if (value) {
- if (closure) {
- closure->callback(key + prefix.length(), value, closure->user_data);
- }
- free(value);
- }
- }
- return true;
- }, static_cast<void*>(&closure)
- );
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <tizen.h>
-#include <dlfcn.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <vconf.h>
-
-#include <stdexcept>
-
-#include "service_common.h"
-#include "dependency_resolver.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "dependency-resolver"
-
-static void *g_handle = NULL;
-static mas_dependency_module_interface g_mas_dependency = { NULL, };
-
-mas_dependency_module_interface* dependency_resolver_get_interface()
-{
- return &g_mas_dependency;
-}
-
-int dependency_resolver_initialize(mas_dependency_plugin_proxy_interface interface)
-{
- MAS_LOGD("[Enter]");
-
- const int FILEPATH_LEN = 512;
- char filepath[FILEPATH_LEN] = {'\0', };
- char *vconf_str = vconf_get_str(MAS_DEPENDENCY_MODULE_PATH);
- if (vconf_str) {
- snprintf(filepath, FILEPATH_LEN - 1, "%s", vconf_str);
- free(vconf_str);
- } else {
- const char *default_path = MAS_DEPENDENCY_DEFAULT_PATH;
- snprintf(filepath, FILEPATH_LEN - 1, "%s/%s", default_path, MAS_DEPENDENCY_DEFAULT_FILENAME);
- }
- filepath[FILEPATH_LEN - 1] = '\0';
-
- char *error;
- g_handle = NULL;
- g_handle = dlopen(filepath, RTLD_LAZY);
- if (NULL != (error = dlerror())) {
- MAS_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", filepath, error);
- return -1; //MAS_ERROR_OPERATION_FAILED;
- }
-
- g_mas_dependency.initialize =
- (mas_dependency_initialize)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_INITIALIZE);
- g_mas_dependency.deinitialize =
- (mas_dependency_deinitialize)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_DEINITIALIZE);
- g_mas_dependency.set_error_callback =
- (mas_dependency_set_error_callback)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK);
- g_mas_dependency.start_recording =
- (mas_dependency_start_recording)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_START_RECORDING);
- g_mas_dependency.stop_recording =
- (mas_dependency_stop_recording)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_STOP_RECORDING);
- g_mas_dependency.set_recording_session =
- (mas_dependency_set_recording_session)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION);
- g_mas_dependency.set_background_volume =
- (mas_dependency_set_background_volume)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME);
- g_mas_dependency.get_audio_format =
- (mas_dependency_get_audio_format)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT);
- g_mas_dependency.get_audio_source_type =
- (mas_dependency_get_audio_source_type)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
- g_mas_dependency.process_wakeup_engine_command =
- (mas_dependency_process_wakeup_engine_command)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND);
- g_mas_dependency.process_wakeup_candidate =
- (mas_dependency_process_wakeup_candidate)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE);
- g_mas_dependency.set_voice_key_tap_duration =
- (mas_dependency_set_voice_key_tap_duration)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION);
- g_mas_dependency.unset_voice_key_tap_duration =
- (mas_dependency_unset_voice_key_tap_duration)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
- g_mas_dependency.set_voice_key_support_mode =
- (mas_dependency_set_voice_key_support_mode)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
- g_mas_dependency.get_custom_vconf_key =
- (mas_dependency_get_custom_vconf_key)dlsym(g_handle,
- MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY);
-
- int ret = -1;
- int dependency_version = 0;
- if (NULL != g_handle) {
- mas_dependency_initialize func = g_mas_dependency.initialize;
-
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_INITIALIZE);
- } else {
- 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);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
- MAS_LOGD("g_handle : %p, dependency_version %d", g_handle, dependency_version);
- return ret;
-}
-
-int dependency_resolver_deinitialize(void)
-{
- MAS_LOGD("g_handle : %p", g_handle);
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_deinitialize func = g_mas_dependency.deinitialize;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_DEINITIALIZE);
- } else {
- 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);
- }
- }
-
- dlclose(g_handle);
- g_handle = NULL;
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_set_error_callback(mas_error_cb callback, void* user_data)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_set_error_callback func = g_mas_dependency.set_error_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK);
- } else {
- try {
- ret = func(callback, user_data);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set error callback(%p, %p), ret(%d)", callback, user_data, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
- return ret;
-}
-
-int dependency_resolver_start_recording(void)
-{
- int ret = -1;
- MAS_LOGD("g_handle : %p", g_handle);
- if (NULL != g_handle) {
- mas_dependency_start_recording func = g_mas_dependency.start_recording;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_START_RECORDING);
- } else {
- try {
- ret = func();
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_START_RECORDING, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to start recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_stop_recording(void)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_stop_recording func = g_mas_dependency.stop_recording;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_STOP_RECORDING);
- } else {
- try {
- ret = func();
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_STOP_RECORDING, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_set_recording_session(unsigned int session)
-{
- int ret = -1;
- MAS_LOGD("g_handle : %p", g_handle);
- if (NULL != g_handle) {
- mas_dependency_set_recording_session func = g_mas_dependency.set_recording_session;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION);
- } else {
- try {
- ret = func(session);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set recording session, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_set_background_volume(double ratio)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_set_background_volume func = g_mas_dependency.set_background_volume;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME);
- } else {
- try {
- ret = func(ratio);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set background volume to %f, ret(%d)", ratio, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_get_audio_format(int* rate, int* channel, int* audio_type)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_get_audio_format func = g_mas_dependency.get_audio_format;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT);
- } else {
- 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_GET_AUDIO_FORMAT, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get audio format, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_get_audio_source_type(char** type)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_get_audio_source_type func = g_mas_dependency.get_audio_source_type;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
- } else {
- try {
- ret = func(type);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get audio source type, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_process_wakeup_engine_command(const char* engine, const char* command)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_process_wakeup_engine_command func = g_mas_dependency.process_wakeup_engine_command;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND);
- } else {
- try {
- ret = func(engine, command);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to process wakeup engine command, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_process_wakeup_candidate(mas_wakeup_event_info* info)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_process_wakeup_candidate func = g_mas_dependency.process_wakeup_candidate;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE);
- } else {
- try {
- ret = func(info);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to process wakeup candidate, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_set_voice_key_tap_duration(float duration)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_set_voice_key_tap_duration func = g_mas_dependency.set_voice_key_tap_duration;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION);
- } else {
- try {
- ret = func(duration);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set voice key tap duration to %f, ret(%d)", duration, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_unset_voice_key_tap_duration()
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_unset_voice_key_tap_duration func = g_mas_dependency.unset_voice_key_tap_duration;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
- } else {
- try {
- ret = func();
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_set_voice_key_support_mode(const char* support_mode)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_set_voice_key_support_mode func = g_mas_dependency.set_voice_key_support_mode;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
- } else {
- try {
- ret = func(support_mode);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
-
-int dependency_resolver_get_custom_vconf_key(const char* default_key, char** custom_key)
-{
- int ret = -1;
- if (NULL != g_handle) {
- mas_dependency_get_custom_vconf_key func = g_mas_dependency.get_custom_vconf_key;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY);
- } else {
- try {
- ret = func(default_key, custom_key);
- } catch (const std::exception& e) {
- MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
- MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY, e.what());
- }
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get custom vconf key, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] g_handle is not valid");
- }
-
- return ret;
-}
+++ /dev/null
-#include "heap_tracer.h"
-
-#include <stdlib.h>
-#include <stdarg.h>
-
-#include <dlog.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "ma_heap_tracer"
-
-static HeapTracer _tracer;
-
-const bool RECORD_UNMANAGED_CHUNKS = true;
-const int MAX_UNMANAGED_RECORDS = 128;
-const bool HEAP_TRACER_LOG_ENABLED = false
-;
-
-#define DESCRIPTION_LENGTH 255
-#define USE_HEAP_TRACER
-//#define ALLOW_FREE_UNMANAGED
-//#define RECORD_ALL_HISTORY
-
-void* vm_calloc(size_t nmemb, size_t size, const char *fmt, ...)
-{
- void *ptr = calloc(nmemb, size);
-#ifdef USE_HEAP_TRACER
- va_list argptr;
- va_start(argptr, fmt);
-
- char description[DESCRIPTION_LENGTH];
- vsnprintf(description, sizeof(description), fmt, argptr);
- _tracer.Insert(ptr, description, nmemb * size);
-
- va_end(argptr);
-#endif
- return ptr;
-}
-
-void* vm_malloc(size_t size, const char *fmt, ...)
-{
- void *ptr = malloc(size);
-#ifdef USE_HEAP_TRACER
- va_list argptr;
- va_start(argptr, fmt);
-
- char description[DESCRIPTION_LENGTH];
- vsnprintf(description, sizeof(description), fmt, argptr);
- _tracer.Insert(ptr, description, size);
-
- va_end(argptr);
-#endif
- return ptr;
-}
-
-void vm_free(void *ptr, const char *fmt, ...)
-{
- if (ptr) {
-#ifdef USE_HEAP_TRACER
- va_list argptr;
- va_start(argptr, fmt);
-
- bool managed = true;
- char description[DESCRIPTION_LENGTH];
- vsnprintf(description, sizeof(description), fmt, argptr);
- if (false == _tracer.Delete(ptr, description)) {
- managed = false;
- _tracer.Find(ptr);
- }
-#ifdef ALLOW_FREE_UNMANAGED
- free(ptr);
-#else
- if (managed) {
- free(ptr);
- }
-#endif
- va_end(argptr);
-#else
- free(ptr);
-#endif
- } else {
- LOGD("Trying to free a null pointer");
- }
-}
-
-char* vm_strdup(const char *s, const char *fmt, ...)
-{
- char *ptr = nullptr;
- if (s) {
- ptr = strdup(s);
-#ifdef USE_HEAP_TRACER
- va_list argptr;
- va_start(argptr, fmt);
-
- char description[DESCRIPTION_LENGTH];
- vsnprintf(description, sizeof(description), fmt, argptr);
- _tracer.Insert(ptr, description, strlen(s) + 1);
-
- va_end(argptr);
-#endif
- } else {
- LOGD("Trying to duplicate a null pointer");
- }
- return ptr;
-}
-
-void *vm_mark_unmanaged(void *ptr, const char *fmt, ...)
-{
-#ifdef USE_HEAP_TRACER
- va_list argptr;
- va_start(argptr, fmt);
-
- char description[DESCRIPTION_LENGTH];
- vsnprintf(description, sizeof(description), fmt, argptr);
- _tracer.MarkUnmanaged(ptr, description);
-
- va_end(argptr);
-#endif
- return ptr;
-}
-
-HeapTracer::HeapTracer()
-{
- LOGD("HeapTracer()");
-}
-
-HeapTracer::~HeapTracer()
-{
- LOGD("~HeapTracer()");
-
- Trace();
-}
-
-bool HeapTracer::Insert(void *ptr, std::string description, size_t size)
-{
- if (HEAP_TRACER_LOG_ENABLED) {
- LOGD("Heap allocated %p [size %zu] : %s", ptr, size, description.c_str());
- }
-
- AllocationEntry entry;
- entry.ptr = ptr;
- entry.description = description;
- entry.size = size;
-
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
- mManagedTable[ptr] = entry;
-
-#ifdef RECORD_ALL_HISTORY
- EntryHistory history;
- history.entry = entry;
- history.operation = EntryOperation::INSERT;
- clock_gettime(CLOCK_REALTIME, &(history.ts));
- mEntryHistory.push_back(history);
-#endif
- return true;
-}
-
-bool HeapTracer::Delete(void *ptr, std::string description)
-{
- if (HEAP_TRACER_LOG_ENABLED) {
- LOGD("Heap deallocated %p : %s", ptr, description.c_str());
- }
-
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
- if (mManagedTable.find(ptr) != mManagedTable.end()) {
-#ifdef RECORD_ALL_HISTORY
- EntryHistory history;
- history.entry = mManagedTable[ptr];
- history.entry.description = description;
- history.operation = EntryOperation::DELETE;
- clock_gettime(CLOCK_REALTIME, &(history.ts));
- mEntryHistory.push_back(history);
-#endif
- mManagedTable.erase(ptr);
- } else {
- LOGE("Heap Trace Error : Trying to delete an entry that does not exist : %p, %s",
- ptr, description.c_str());
- return false;
- }
- return true;
-}
-
-std::string HeapTracer::Find(void *ptr)
-{
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
-#ifdef RECORD_ALL_HISTORY
- for (auto& entry : mEntryHistory) {
- if (entry.entry.ptr == ptr) {
- LOGD("Heap history record for %p : %s, %lld.%.9ld, %s",
- ptr,
- (entry.operation == EntryOperation::INSERT ? "INSERT" : "DELETE"),
- (long long)(entry.ts.tv_sec), entry.ts.tv_nsec,
- entry.entry.description.c_str());
- }
- }
-#endif
- if (mManagedTable.find(ptr) != mManagedTable.end()) {
- return mManagedTable[ptr].description;
- }
- return std::string("Not found");
-}
-
-void HeapTracer::MarkUnmanaged(void *ptr, std::string description)
-{
- LOGD("Marking as unmanaged : %p %s", ptr, description.c_str());
-
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
- auto iter = mManagedTable.find(ptr);
- if (iter != mManagedTable.end()) {
- if (RECORD_UNMANAGED_CHUNKS) {
- std::lock_guard<std::mutex> lock(mUnmanagedRecordsMutex);
- if (mUnmanagedRecordsSize >= MAX_UNMANAGED_RECORDS) {
- mUnmanagedRecords.pop_front();
- mUnmanagedRecordsSize--;
- }
- mUnmanagedRecords.push_back(iter->second);
- mUnmanagedRecordsSize++;
- }
- mManagedTable.erase(ptr);
- } else {
- LOGE("Heap Trace Error : Trying to mark an entry that does not exist as unmanaged : %p", ptr);
- }
-}
-
-bool HeapTracer::Empty()
-{
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
- return mManagedTable.empty();
-}
-
-void HeapTracer::Trace()
-{
- LOGD("Heap Trace Start");
-
- std::lock_guard<std::mutex> lock(mManagedTableMutex);
- for (auto& item : mManagedTable) {
- LOGD("No dealloc information exists for %p [size %d] : %s", item.first, item.second.size, item.second.description.c_str());
- }
- LOGD("Heap Trace End");
-}
+++ /dev/null
-#define _GNU_SOURCE
-
-#include "wakeup_audio_manager.h"
-#include "wakeup_manager_main.h"
-#include "dependency_resolver.h"
-#include "heap_tracer.h"
-
-#include <sys/time.h>
-#include <sys/resource.h>
-
-#include <algorithm>
-#include <map>
-
-#include <Ecore.h>
-#include <audio_io.h>
-#include <sound_manager.h>
-#include <sound_manager_internal.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-/* Need to check whether this value needs to be configurable */
-static int g_speech_pcm_wait_count = 800;
-
-#ifdef PRINT_DETAILED_TIMEINFO
-static atomic_int g_mutex_wait_index{0};
-static map<int, long long int> g_mutex_wait_time;
-#endif
-
-static long long get_current_milliseconds_after_epoch()
-{
- auto now = chrono::steady_clock::now();
- auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
- /* number of milliseconds since the epoch of system_clock */
- auto value = now_ms.time_since_epoch();
-
- return value.count();
-}
-
-#ifdef PRINT_DETAILED_TIMEINFO
-static std::string get_current_milliseconds_after_epoch(chrono::time_point<chrono::steady_clock> point)
-{
- auto now_ms = chrono::time_point_cast<chrono::milliseconds>(point);
- /* number of milliseconds since the epoch of system_clock */
- auto value = now_ms.time_since_epoch();
-
- return std::to_string(value.count());
-}
-#endif
-
-CAudioManager::CAudioManager()
-{
-}
-
-CAudioManager::~CAudioManager()
-{
- deinitialize();
-}
-
-CAudioManager::CAudioManager(IAudioEventObserver *observer) : CAudioManager()
-{
- subscribe(observer);
-}
-
-void recording_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask,
- sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason,
- const char *extra_info, void *user_data)
-{
- MWR_LOGD("[Recorder] focus_mask : %d, focus_state : %d, reason : %d, [%s]",
- focus_mask, focus_state, reason, extra_info);
-
- if (nullptr == user_data) return;
-
- /* The API description states that calling sound_manager_get_current_recording_focus()
- function inside sound_stream_focus_state_watch_cb() function is prohibited */
- ecore_main_loop_thread_safe_call_async(
- [](void* data) {
- CAudioManager *manager = static_cast<CAudioManager*>(data);
- if (manager) {
- manager->sound_focus_changed();
- }
- }, user_data);
-}
-
-int CAudioManager::initialize(void)
-{
- sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_RECORDING,
- recording_focus_state_watch_cb, this, &mSoundFocusWatchId);
- return 0;
-}
-
-int CAudioManager::deinitialize(void)
-{
- clear_audio_data();
- if (mStreamingThread.joinable()) {
- MWR_LOGD("mStreamingThread is joinable, trying join()");
- mStopStreamingThread.store(true);
- try {
- mStreamingThread.join();
- } catch (std::exception &e) {
- MWR_LOGE("Exception thrown : %s", e.what());
- }
- }
- mStopStreamingThread.store(false);
-
- if (mBackgroundVolumeThread.joinable()) {
- MWR_LOGD("mBackgroundVolumeThread is joinable, trying join()");
- try {
- mBackgroundVolumeThread.join();
- } catch (std::exception &e) {
- MWR_LOGE("Exception thrown : %s", e.what());
- }
- }
-
- sound_manager_remove_focus_state_watch_cb(mSoundFocusWatchId);
-
- return 0;
-}
-
-void CAudioManager::sound_focus_changed()
-{
- sound_stream_focus_change_reason_e acquired_by;
- int sound_behavior;
- char* extra_info = NULL;
- int focus = sound_manager_get_current_recording_focus(&acquired_by, &sound_behavior, &extra_info);
- MWR_LOGD("[Recorder] sound focus has changed : %d %d %d %s", focus,
- (SOUND_MANAGER_ERROR_NO_DATA != focus ? acquired_by : -1),
- (SOUND_MANAGER_ERROR_NO_DATA != focus ? sound_behavior : -1),
- (SOUND_MANAGER_ERROR_NO_DATA != focus ? extra_info : ""));
- if (SOUND_MANAGER_ERROR_NO_DATA == focus) {
- if (mRecordingRequired && !mIsRecording) {
- MWR_LOGD("[Recorder] Currently no other process has acquired sound focus, start recording");
- start_recording(false);
- }
- } else {
- if (mIsRecording) {
- MWR_LOGW("[Recorder] Sound focus acquired by other process, stop recording");
- stop_recording(false);
- }
- }
- if (extra_info) {
- free(extra_info);
- extra_info = NULL;
- }
-}
-
-void CAudioManager::subscribe(IAudioEventObserver *observer)
-{
- lock_guard<mutex> lock(mMutex);
- if (observer) {
- mObservers.push_back(observer);
- }
-}
-
-void CAudioManager::unsubscribe(IAudioEventObserver *observer)
-{
- lock_guard<mutex> lock(mMutex);
- auto iter = find(mObservers.begin(), mObservers.end(), observer);
- if (iter != mObservers.end()) {
- mObservers.erase(iter);
- }
-}
-
-void CAudioManager::stop_recording(bool proactive)
-{
- dependency_resolver_stop_recording();
- if (proactive) {
- mRecordingRequired = false;
- }
- mIsRecording = false;
-}
-
-void CAudioManager::start_recording(bool proactive)
-{
- if (mIsRecording) {
- stop_recording(false);
- }
- if (proactive) {
- mRecordingRequired = true;
- }
-
- sound_stream_focus_change_reason_e acquired_by;
- int sound_behavior;
- char* extra_info = NULL;
- if (SOUND_MANAGER_ERROR_NO_DATA == sound_manager_get_current_recording_focus(&acquired_by, &sound_behavior, &extra_info)) {
- MWR_LOGD("[Recorder] Currently no other process has acquired sound focus, start recording");
- dependency_resolver_start_recording();
- mIsRecording = true;
- } else {
- MWR_LOGW("[Recorder] Currently sound focus is acquired by other process, skip recording");
- }
- if (extra_info) {
- free(extra_info);
- extra_info = NULL;
- }
-}
-
-void CAudioManager::set_recording_session(recording_session session)
-{
- dependency_resolver_set_recording_session((unsigned int)session);
-}
-
-/* Need to consider adapting conventional producer-consumer model */
-void CAudioManager::streaming_previous_audio_data_thread_func()
-{
- MWR_LOGI("[ENTER]");
-
- unique_lock<mutex> lock(mMutex, defer_lock);
-
- /* get feedback data */
- size_t audio_data_size = 0;
- lock.lock();
- audio_data_size = mPreviousAudioData.size();
- for (int index = 0; index < audio_data_size; index++) {
- mas_speech_data& speech_data = mPreviousAudioData.at(index).data;
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_streaming_audio_data(
- speech_data.event, speech_data.buffer, speech_data.len)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
-
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
- MWR_LOGI("[INFO] Finish to send previous speech data");
- return;
- }
- }
-
- if (mStopStreamingThread.load()) {
- MWR_LOGI("[INFO] Stop Streaming Requested, returning");
- return;
- }
- }
- lock.unlock();
-
- MWR_LOGI("[EXIT]");
-}
-
-static void validate_audio_data_event_field(const mas_speech_data &data)
-{
- if (data.event == MAS_SPEECH_STREAMING_EVENT_CONTINUE ||
- data.event == MAS_SPEECH_STREAMING_EVENT_START ||
- data.event == MAS_SPEECH_STREAMING_EVENT_FINISH ||
- data.event == MAS_SPEECH_STREAMING_EVENT_FAIL) {
- return;
- }
- MWR_LOGE("mas_speech_data has event field : %d", data.event);
-}
-
-void CAudioManager::streaming_audio_data_thread_func(long long start_time)
-{
- MWR_LOGI("[ENTER]");
-
- mStreamingThreadActive.store(true);
-
- unique_lock<mutex> lock(mMutex, defer_lock);
- bool finish_event_sent = false;
-
- lock.lock();
- auto lead = mAudioData.begin();
- auto iter = lead;
- while (lead != mAudioData.end() && lead->time < start_time) {
- iter = lead;
- advance(lead, 1);
- }
- MWR_LOGE("data_count : %zu", mAudioData.size());
- lock.unlock();
-
- while (!(mStopStreamingThread.load())) {
- const size_t SEND_BUFFER_SIZE = 4096;
- unsigned char send_buffer[SEND_BUFFER_SIZE];
-
- int ret = -1;
- int cnt = 0;
-
- /* get feedback data */
- lock.lock();
- auto end = mAudioData.end();
- lock.unlock();
- if (lead == end) {
- /* empty queue */
- MWR_LOGD("[DEBUG] No feedback data. Waiting mode : %d", ret);
-
- /* waiting */
- while (!(mStopStreamingThread.load())) {
- this_thread::sleep_for(chrono::milliseconds(10));
- lock.lock();
- end = mAudioData.end();
- auto begin = mAudioData.begin();
- vector<IAudioEventObserver*> observers = mObservers;
- lock.unlock();
- if (iter == end) {
- lead = begin;
- } else {
- lead = iter;
- if (lead != end) {
- advance(lead, 1);
- }
- }
- if (lead != end) {
- MWR_LOGD("[INFO] Resume thread");
- break;
- }
- if (g_speech_pcm_wait_count < cnt) {
- unsigned char final_buffer[2] = {'\0', };
- MWR_LOGE("[ERROR] Wrong request, there's no pcm data");
- for (const auto& observer : observers) {
- if (observer) {
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FAIL, NULL, 0)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- mStreamingThreadActive.store(false);
- return;
- }
- cnt++;
- }
- MWR_LOGD("[INFO] Finish to wait for new feedback data come");
-
- /* resume feedback thread */
- continue;
- }
-
- /* FIXME : Extracted audio data here should be used as previous audio data*/
-
- lock.lock();
- end = mAudioData.end();
- vector<IAudioEventObserver*> observers = mObservers;
-
- if (lead != end) {
- iter = lead;
-
- mas_speech_data speech_data = iter->data;
- size_t len = speech_data.len;
- if (len > SEND_BUFFER_SIZE) {
- LOGE("ERROR : SPEECH DATA contains data bigger than the buffer size : %d, truncating", len);
- len = SEND_BUFFER_SIZE;
- }
- memcpy(send_buffer, speech_data.buffer, len);
- speech_data.buffer = send_buffer;
- speech_data.len = len;
- lock.unlock();
-
- for (const auto& observer : observers) {
- if (observer) {
- validate_audio_data_event_field(speech_data);
-
-#ifdef PRINT_DETAILED_TIMEINFO
- auto started = std::chrono::steady_clock::now();
-#endif
- if (!observer->on_streaming_audio_data(
- speech_data.event, speech_data.buffer, speech_data.len)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
-#ifdef PRINT_DETAILED_TIMEINFO
- auto finished = std::chrono::steady_clock::now();
- auto interval = finished - started;
- long long int count = static_cast<long long int>(
- chrono::duration_cast<chrono::milliseconds>(interval).count());
- int index = g_mutex_wait_index;
- g_mutex_wait_time[index] += count;
-#endif
- }
- }
-
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
- MWR_LOGE("[INFO] Finish to get and send speech data");
- finish_event_sent = true;
- break;
- }
-
- advance(lead, 1);
- } else {
- lock.unlock();
- }
- }
-
- if (true != finish_event_sent) {
- unsigned char final_buffer[2] = {'\0', };
- lock.lock();
- vector<IAudioEventObserver*> observers = mObservers;
- lock.unlock();
- for (const auto& observer : observers) {
- if (observer) {
- MWR_LOGE("No FINISH event sent yet, adding to finalize streaming session");
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- }
- mStreamingThreadActive.store(false);
- MWR_LOGE("[EXIT]");
-}
-
-#ifdef PRINT_DETAILED_TIMEINFO
-static void print_duration(std::chrono::time_point<std::chrono::steady_clock> started)
-{
- const std::chrono::milliseconds threshold(100);
- auto finished = std::chrono::steady_clock::now();
- auto interval = finished - started;
- if (interval > threshold) {
- long long int count = static_cast<long long int>(
- std::chrono::duration_cast<std::chrono::milliseconds>(interval).count());
- int index = g_mutex_wait_index;
- MAS_LOGE("Mutex wait time : %d %lld %lld, [%s~]", index, count,
- g_mutex_wait_time[index],
- get_current_milliseconds_after_epoch(started).c_str());
- }
-}
-#endif
-
-void CAudioManager::add_audio_data(mas_speech_data& data, long long time)
-{
-#ifdef PRINT_DETAILED_TIMEINFO
- ++g_mutex_wait_index;
-#endif
-
- long long delta = mAudioRecordingDurationMilliseconds;
-
- bool print_log = false;
- static unsigned int num = 0;
- const std::chrono::seconds interval(3);
- static auto last = std::chrono::steady_clock::now();
- auto now = std::chrono::steady_clock::now();
-
- struct rusage process_usage_before;
- struct rusage thread_usage_before;
-
- if (now - last > interval) {
- print_log = true;
- last = now;
- getrusage(RUSAGE_SELF, &process_usage_before);
- getrusage(RUSAGE_THREAD, &thread_usage_before);
- }
- num++;
-
- notify_audio_data_recording(time, data.buffer, data.len);
-
- if (print_log) {
- struct rusage process_usage_after;
- struct rusage thread_usage_after;
-
- getrusage(RUSAGE_SELF, &process_usage_after);
- getrusage(RUSAGE_THREAD, &thread_usage_after);
-
- MWR_LOGE("Feeding audio data : num(%d), now(%" PRId64 "), %d %zu ([%ld,%ld,%ld,%ld] -> [%ld,%ld,%ld,%ld]) ([%ld,%ld,%ld,%ld] -> [%ld,%ld,%ld,%ld])",
- num, now.time_since_epoch().count(),
- mStreamingThreadActive.load(), mAudioData.size(),
- process_usage_before.ru_maxrss,
- process_usage_before.ru_ixrss,
- process_usage_before.ru_idrss,
- process_usage_before.ru_isrss,
- process_usage_after.ru_maxrss,
- process_usage_after.ru_ixrss,
- process_usage_after.ru_idrss,
- process_usage_after.ru_isrss,
- thread_usage_before.ru_maxrss,
- thread_usage_before.ru_ixrss,
- thread_usage_before.ru_idrss,
- thread_usage_before.ru_isrss,
- thread_usage_after.ru_maxrss,
- thread_usage_after.ru_ixrss,
- thread_usage_after.ru_idrss,
- thread_usage_after.ru_isrss);
- }
-
- mas_speech_data_with_time data_with_time;
- data_with_time.data = data;
- data_with_time.time = time;
-
- lock_guard<mutex> lock(mMutex);
-
-#ifdef PRINT_DETAILED_TIMEINFO
- print_duration(now);
-#endif
-
- /* Pop items only when the streaming is not activated */
- if (!mStreamingThreadActive.load()) {
- while(false == mAudioData.empty() && mAudioData.front().time < time - delta) {
- const auto &front = mAudioData.front();
- if (front.data.buffer) {
- vm_free_simple(front.data.buffer);
- }
- mAudioData.pop_front();
- }
- }
- validate_audio_data_event_field(data);
- mAudioData.push_back(data_with_time);
-}
-
-void CAudioManager::feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
-{
- if (NULL == buffer || 0 == len) return;
-
- mas_speech_data speech_data;
- speech_data.buffer = vm_malloc_simple(len);
- if (speech_data.buffer) {
- long long time = get_current_milliseconds_after_epoch();
-
- speech_data.event = event;
- speech_data.len = len;
- memcpy(speech_data.buffer, buffer, len);
- add_audio_data(speech_data, time);
- }
-}
-
-void CAudioManager::finalize_audio_data()
-{
- MWR_LOGI("Adding FINISH event to audio data list");
- unsigned char final_buffer[2] = {'\0', };
- mas_speech_data speech_data;
- speech_data.event = MAS_SPEECH_STREAMING_EVENT_FINISH;
- speech_data.len = sizeof(final_buffer);
- speech_data.buffer = vm_malloc_simple(speech_data.len);
- if (speech_data.buffer) {
- long long time = get_current_milliseconds_after_epoch();
-
- memcpy(speech_data.buffer, final_buffer, speech_data.len);
- add_audio_data(speech_data, time);
- }
-}
-
-void CAudioManager::clear_audio_data()
-{
- lock_guard<mutex> lock(mMutex);
- while(!mAudioData.empty()) {
- const auto &front = mAudioData.front();
- if (front.data.buffer) {
- vm_free_simple(front.data.buffer);
- }
- mAudioData.pop_front();
- }
- mAudioData.clear();
-}
-
-void CAudioManager::notify_audio_data_recording(long time, void* data, int len)
-{
- unique_lock<mutex> lock(mMutex, defer_lock);
- lock.lock();
- vector<IAudioEventObserver*> observers = mObservers;
- lock.unlock();
- for (const auto& observer : observers) {
- if (observer) {
- observer->on_recording_audio_data(time, data, len);
- }
- }
-}
-
-void CAudioManager::start_streaming_current_utterance_data(long long start_time)
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
- return;
- }
- lock_guard<mutex> lock(mMutex);
- mStreamingThread = thread(&CAudioManager::streaming_audio_data_thread_func, this, start_time);
-}
-
-void CAudioManager::stop_streaming_current_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGD("mStreamingThread is joinable, trying join()");
- mStopStreamingThread.store(true);
- try {
- mStreamingThread.join();
- } catch (std::exception &e) {
- MWR_LOGE("Exception thrown : %s", e.what());
- }
- }
- mStopStreamingThread.store(false);
-
- /* FIXME : Need to move all the speech data to previous speech data for later use */
-}
-
-void CAudioManager::start_streaming_previous_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingPreviousThread.joinable()) {
- MWR_LOGE("ERROR : mStreamingPreviousThread is joinable, will not start a new thread");
- return;
- }
- lock_guard<mutex> lock(mMutex);
- mStreamingPreviousThread = thread(&CAudioManager::streaming_previous_audio_data_thread_func, this);
-}
-
-void CAudioManager::stop_streaming_previous_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingPreviousThread.joinable()) {
- MWR_LOGD("mStreamingPreviousThread is joinable, trying join()");
- mStopStreamingPreviousThread.store(true);
- try {
- mStreamingPreviousThread.join();
- } catch (std::exception &e) {
- MWR_LOGE("Exception thrown : %s", e.what());
- }
- }
- mStopStreamingThread.store(false);
-}
-
-void CAudioManager::start_streaming_follow_up_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
- return;
- }
-
- mStreamingThread = thread(&CAudioManager::streaming_audio_data_thread_func, this, 0);
-}
-
-void CAudioManager::stop_streaming_follow_up_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGD("mStreamingThread is joinable, trying join()");
- mStopStreamingThread.store(true);
- mStreamingThread.join();
- }
- mStopStreamingThread.store(false);
-}
-
-static void set_background_volume_thread_func(double ratio)
-{
- MWR_LOGI("[ENTER]");
- dependency_resolver_set_background_volume(ratio);
-}
-
-void CAudioManager::set_background_volume(double ratio)
-{
- if (mBackgroundVolumeThread.joinable()) {
- mBackgroundVolumeThread.join();
- }
- mBackgroundVolumeThread = thread(&set_background_volume_thread_func, ratio);
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-#include <multi_assistant_service.h>
-
-#include "wakeup_engine_manager.h"
-#include "wakeup_manager_main.h"
-
-#include <dlfcn.h>
-#include <algorithm>
-#include <pkgmgr-info.h>
-#include <deque>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-/* Sound buf save for test */
-#if 0
-#define BUF_SAVE_MODE
-#endif
-
-#ifdef BUF_SAVE_MODE
-static char g_temp_file_name[128] = {'\0', };
-
-static FILE* g_pFile = NULL;
-
-static int g_count = 1;
-#endif
-
-/* Need to check whether this value needs to be configurable */
-static int g_speech_pcm_wait_count = 800;
-
-/* Utility function for checking if an element exists in a container */
-template<class C, class T>
-static auto contains(const C& v, const T& x) -> decltype(end(v), true)
-{
- return end(v) != find(begin(v), end(v), x);
-}
-
-static long long get_current_milliseconds_after_epoch()
-{
- auto now = chrono::steady_clock::now();
- auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
- /* number of milliseconds since the epoch of system_clock */
- auto value = now_ms.time_since_epoch();
-
- return value.count();
-}
-
-CWakeupEngineManager::CWakeupEngineManager()
-{
-}
-
-CWakeupEngineManager::~CWakeupEngineManager()
-{
- MWR_LOGI("Wakeup Engine Manager is now being destroyed");
-}
-
-CWakeupEngineManager::CWakeupEngineManager(IEngineEventObserver *observer) : CWakeupEngineManager()
-{
- subscribe(observer);
-}
-
-void CWakeupEngineManager::initialize()
-{
- DIR* dp = opendir(MA_WAKEUP_ENGINE_PATH);
- if (nullptr == dp) {
- MWR_LOGD("Failed opening directory : %s", (const char*)MA_WAKEUP_ENGINE_PATH);
- } else {
- struct dirent *dirp = nullptr;
- char dirpath[_POSIX_PATH_MAX];
- do {
- dirp = readdir(dp);
-
- if (nullptr != dirp) {
- const string current_directory{"."};
- const string parent_directory{".."};
- if (0 == current_directory.compare(dirp->d_name) ||
- 0 == parent_directory.compare(dirp->d_name))
- continue;
-
- if (DT_DIR != dirp->d_type) /* If not a directory */
- continue;
-
- int dirpath_len = strlen(MA_WAKEUP_ENGINE_PATH) + strlen(dirp->d_name) + 1;
- if (dirpath_len >= _POSIX_PATH_MAX) {
- MWR_LOGD("File path is too long : %s", dirp->d_name);
- closedir(dp);
- return;
- }
-
- memset(dirpath, '\0', _POSIX_PATH_MAX);
- snprintf(dirpath, _POSIX_PATH_MAX, "%s/%s",
- (const char*)(MA_WAKEUP_ENGINE_PATH), dirp->d_name);
-
- add_engine_directory(string{dirp->d_name}, dirpath);
- }
- } while (nullptr != dirp);
-
- closedir(dp);
- }
-}
-
-void CWakeupEngineManager::deinitialize()
-{
- MWR_LOGI("[START]");
- if (mStreamingThread.joinable()) {
- MWR_LOGD("mStreamingThread is joinable, trying join()");
- mStopStreamingThread.store(true);
- mStreamingThread.join();
- }
- mStopStreamingThread.store(false);
-
- for (auto& info : mEngineInfo) {
- 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.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();
- MWR_LOGI("Deinitialization [%s] returned %d", info.engine_name.c_str(), ret);
- }
- } 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) {
- int ret = dlclose(info.engine_handle);
- MWR_LOGI("Closing [%s] returned %d, [%s]", info.engine_name.c_str(), ret,
- ((0 == ret) ? "" : dlerror()));
- info.engine_handle = nullptr;
- }
- }
- mSelectedEngine = nullptr;
- mEngineInfo.clear();
- MWR_LOGI("[END]");
-}
-
-void CWakeupEngineManager::subscribe(IEngineEventObserver *observer)
-{
- mObservers.push_back(observer);
- MWR_LOGD("Added Observer : %p %zu", observer, mObservers.size());
-}
-
-void CWakeupEngineManager::unsubscribe(IEngineEventObserver *observer)
-{
- auto iter = find(mObservers.begin(), mObservers.end(), observer);
- if (iter != mObservers.end()) {
- mObservers.erase(iter);
- }
-}
-
-bool CWakeupEngineManager::get_audio_data_required()
-{
- return mAudioDataRequired;
-}
-
-void CWakeupEngineManager::set_selected_wakeup_info(mas_wakeup_event_info wakeup_info)
-{
- mSelectedEngine = nullptr;
-
- const auto& iter = find_if(mEngineInfo.begin(), mEngineInfo.end(),
- [wakeup_info](const EngineInfo& info) {
- if (nullptr == wakeup_info.wakeup_engine)
- return false;
-
- return (0 == info.engine_name.compare(wakeup_info.wakeup_engine));
- });
-
- if (iter != mEngineInfo.end()) {
- mSelectedEngine = &(*iter);
- MWR_LOGD("Selected : %s", iter->engine_name.c_str());
- }
-}
-
-bool CWakeupEngineManager::set_language(string language)
-{
- for (const auto& info : mEngineInfo) {
- if (info.interface.set_language) {
- 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;
-}
-
-bool CWakeupEngineManager::set_assistant_language(string appid, string language)
-{
- for (auto& info : mEngineInfo) {
- const auto& iter = find_if(info.assistant_list.begin(), info.assistant_list.end(),
- [appid](const string& assistant) {
- return (0 == assistant.compare(appid));
- });
-
- /* If the appid is in the assistant list */
- if (info.assistant_list.end() != iter) {
- try {
- int ret = info.interface.set_language(language.c_str());
- MWR_LOGI("set_language returned %d : %s %s %s",
- ret, appid.c_str(), info.engine_name.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());
- }
- }
- }
- return true;
-}
-
-void CWakeupEngineManager::set_assistant_activated(string appid, bool activated)
-{
- MWR_LOGE("[ENTER] : %s %d", appid.c_str(), activated);
- for (auto& info : mEngineInfo) {
- const auto& iter = find_if(info.assistant_list.begin(), info.assistant_list.end(),
- [appid](const string& assistant) {
- return (0 == assistant.compare(appid));
- });
-
- /* If the appid is in the assistant list */
- if (info.assistant_list.end() != iter) {
- MWR_LOGI("%s has %s", info.engine_name.c_str(), appid.c_str());
- bool previously_activated = info.activated;
- if (activated) {
- info.activated_assistants.insert(appid);
- } else {
- info.activated_assistants.erase(appid);
- }
- info.activated = (info.activated_assistants.size() > 0);
- if (previously_activated != info.activated) {
- if (info.activated) {
- try {
- info.interface.activate();
- MWR_LOGW("Activating wakeup engine : %s", 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());
- }
- } else {
- try {
- info.interface.deactivate();
- MWR_LOGW("Deactivating wakeup engine : %s", 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());
- }
- }
- /* Activated status changed, need to update audio_data_require_status too */
- on_audio_data_require_status(info.engine_name, info.audio_data_require_status);
- }
- } else {
- MWR_LOGI("%s does not have %s", info.engine_name.c_str(), appid.c_str());
- }
- }
-}
-
-void CWakeupEngineManager::set_wake_word_audio_require_flag(bool require)
-{
- MWR_LOGD("[ENTER]");
- mWakeWordAudioRequired = require;
- for (const auto& info : mEngineInfo) {
- if (info.interface.set_wake_word_audio_require_flag) {
- 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());
- }
- }
- }
-}
-
-void CWakeupEngineManager::streaming_speech_data_thread_func()
-{
- MWR_LOGE("[ENTER]");
-
- if (nullptr == mSelectedEngine) {
- MWR_LOGE("No Engine Selected");
- return;
- }
-
- const wakeup_engine_interface *interface = &(mSelectedEngine->interface);
-
- if (NULL == interface ||
- NULL == interface->get_utterance_data ||
- NULL == interface->get_utterance_data_count)
- return;
-
- MWR_LOGE("data_count : %s, %d",
- mSelectedEngine->engine_name.c_str(),
- interface->get_utterance_data_count());
-
-#ifdef BUF_SAVE_MODE
- if (g_pFile) {
- fclose(g_pFile);
- g_pFile = NULL;
- } else {
- MWR_LOGD("[Recorder Info] File not found!");
- }
-
- while (1) {
- snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/ma_wue_%d_%d", getpid(), g_count);
- int ret = access(g_temp_file_name, 0);
-
- if (0 == ret) {
- MWR_LOGD("[Recorder ERROR] File is already exist");
- if (0 == remove(g_temp_file_name)) {
- MWR_LOGD("[Recorder] Remove file");
- break;
- } else {
- g_count++;
- }
- } else {
- break;
- }
- }
-
- MWR_LOGD("[Recorder] Temp file name=[%s]", g_temp_file_name);
-
- /* open test file */
- g_pFile = fopen(g_temp_file_name, "wb+x");
- if (!g_pFile) {
- MWR_LOGD("[Recorder ERROR] File not found!");
- return;
- }
- g_count++;
-#endif
-
- mas_speech_data speech_data;
- int index = 0;
- bool finish_event_sent = false;
-
- if (mWakeWordAudioRequired &&
- NULL != interface->get_wake_word_data &&
- NULL != interface->get_wake_word_data_count) {
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_audio_streaming_data_section(MA_AUDIO_STREAMING_DATA_SECTION_WAKE_WORD)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- int count = interface->get_wake_word_data_count();
- while (!(mStopStreamingThread.load()) && index < count) {
- int ret = interface->get_wake_word_data(index, &speech_data);
- if (0 == ret) {
-#ifdef BUF_SAVE_MODE
- if (g_pFile)
- fwrite(speech_data.buffer, 1, speech_data.len, g_pFile);
-#endif
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_streaming_audio_data(
- speech_data.event, speech_data.buffer, speech_data.len)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- } else {
- break;
- }
- index++;
- }
- index = 0;
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_audio_streaming_data_section(MA_AUDIO_STREAMING_DATA_SECTION_UTTERANCE)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- }
-
- int burst_count = 0;
- int sleep_count = 0;
-
- while (!(mStopStreamingThread.load())) {
- int ret = -1;
- int cnt = 0;
-
- /* get feedback data */
- if (interface && interface->get_utterance_data) {
- ret = interface->get_utterance_data(index, &speech_data);
- mStreamingHistory.last_audio_fetched.store(get_current_milliseconds_after_epoch());
-
- if (0 != ret) {
- /* empty queue */
- MWR_LOGI("[DEBUG] No feedback data. Waiting mode : %d %d", ret, cnt);
-
- sleep_count = 0;
- /* waiting */
- while (!(mStopStreamingThread.load())) {
- burst_count = 0;
- if (++sleep_count >= 100) {
- MWR_LOGI("Still waiting : %d %p %p", sleep_count,
- interface->get_utterance_data,
- interface->get_utterance_data_count);
- sleep_count = 0;
- }
- this_thread::sleep_for(chrono::milliseconds(10));
- if (index < interface->get_utterance_data_count()) {
- MWR_LOGI("[INFO] Resume thread, %d", cnt);
- break;
- }
- mStreamingHistory.last_count_fetched.store(get_current_milliseconds_after_epoch());
- if (g_speech_pcm_wait_count < cnt) {
- unsigned char final_buffer[2] = {'\0', };
- MWR_LOGE("[ERROR] Wrong request, there's no pcm data : %d", cnt);
-#ifdef BUF_SAVE_MODE
- if (g_pFile) {
- fwrite(final_buffer, 1, sizeof(final_buffer), g_pFile);
- MWR_LOGE("[Recorder SUCCESS] File Close");
- fclose(g_pFile);
- g_pFile = NULL;
- }
-#endif
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FAIL, NULL, 0)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
- }
- }
- return;
- }
- cnt++;
- }
- MWR_LOGD("[INFO] Finish to wait for new feedback data come");
-
- /* resume feedback thread */
- continue;
- }
-
-#ifdef BUF_SAVE_MODE
- if (g_pFile)
- fwrite(speech_data.buffer, 1, speech_data.len, g_pFile);
-
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
- if (g_pFile) {
- MWR_LOGE("[Recorder SUCCESS] File Close");
- fclose(g_pFile);
- g_pFile = NULL;
- } else {
- MWR_LOGE("[Recorder ERROR] File not found!");
- }
- }
-#endif
- const int sleep_duration_in_millis = 10;
- const int max_burst_count = 3;
- if (++burst_count >= max_burst_count) {
- burst_count = 0;
- MWR_LOGI("[INFO] Streaming data burst transmission detected, forcing sleep");
- this_thread::sleep_for(chrono::milliseconds(sleep_duration_in_millis));
- }
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_streaming_audio_data(
- speech_data.event, speech_data.buffer, speech_data.len)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
- }
- }
-
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
- MWR_LOGE("[INFO] Finish to get and send speech data");
- finish_event_sent = true;
- break;
- }
-
- index++;
- }
- }
- MWR_LOGE("[INFO] Streaming loop exit");
-
- if (true != finish_event_sent) {
- unsigned char final_buffer[2] = {'\0', };
- for (const auto& observer : mObservers) {
- if (observer) {
- MWR_LOGE("No FINISH event sent yet, adding to finalize streaming session");
- if (!observer->on_streaming_audio_data(
- MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
- }
- }
-#ifdef BUF_SAVE_MODE
- if (g_pFile) {
- fwrite(final_buffer, 1, sizeof(final_buffer), g_pFile);
- MWR_LOGE("[Recorder SUCCESS] File Close");
- fclose(g_pFile);
- g_pFile = NULL;
- }
-#endif
- }
-
- MWR_LOGE("[EXIT]");
-}
-
-void CWakeupEngineManager::start_streaming_current_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
- return;
- }
- mStreamingThread = thread(&CWakeupEngineManager::streaming_speech_data_thread_func, this);
-}
-
-void CWakeupEngineManager::stop_streaming_current_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (mStreamingThread.joinable()) {
- MWR_LOGE("mStreamingThread is joinable, trying join() %lld %lld %lld %lld",
- get_current_milliseconds_after_epoch(),
- mStreamingHistory.last_audio_fetched.load(),
- mStreamingHistory.last_count_fetched.load(),
- mStreamingHistory.last_audio_sent.load());
- mStopStreamingThread.store(true);
- mStreamingThread.join();
- }
- mStopStreamingThread.store(false);
-}
-
-void CWakeupEngineManager::update_manager_state(wakeup_manager_state_e state)
-{
- for (const auto& info : mEngineInfo) {
- if (info.interface.update_manager_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());
- }
- }
- }
- mWakeupManagerState = state;
-}
-
-void CWakeupEngineManager::update_recognition_result(string appid, int result)
-{
- if (mSelectedEngine) {
- if (mSelectedEngine->interface.update_recognition_result) {
- mSelectedEngine->interface.update_recognition_result(appid.c_str(), result);
- }
- }
-}
-
-void CWakeupEngineManager::engine_add_target_assistant(string engine_name, string appid)
-{
- 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) {
- /* Not found, add new library */
- pkgmgrinfo_appinfo_h handle;
- int ret = pkgmgrinfo_appinfo_get_appinfo(engine_name.c_str(), &handle);
- if (PMINFO_R_OK == ret) {
- char *root_path = nullptr;
- ret = pkgmgrinfo_appinfo_get_root_path(handle, &root_path);
- if (PMINFO_R_OK == ret && nullptr != root_path) {
- string path = root_path;
- path += "/";
- path += MA_WAKEUP_DEDICATED_ENGINE_PATH;
- add_engine(engine_name, path);
- }
- pkgmgrinfo_appinfo_destroy_appinfo(handle);
- }
- /* Find again to add appid to the newly created engine's assistant list */
- const auto &new_iter = find_if(mEngineInfo.begin(), mEngineInfo.end(),
- [engine_name](const EngineInfo& info) {
- return (0 == info.engine_name.compare(engine_name));
- });
- if (mEngineInfo.end() != new_iter) {
- new_iter->assistant_list.push_back(appid);
- for (const auto& assistant : new_iter->assistant_list) {
- MWR_LOGI("Assistant List : %s %s", assistant.c_str(), new_iter->engine_name.c_str());
- }
- }
- } else {
- /* If the engine already exists, simply add the appid to the assistant list */
- iter->assistant_list.push_back(appid);
- for (const auto& assistant : iter->assistant_list) {
- MWR_LOGI("Assistant List : %s %s", assistant.c_str(), iter->engine_name.c_str());
- }
- }
-}
-
-void CWakeupEngineManager::engine_add_wakeup_word(string appid, string wakeup_word, string language)
-{
- for (const auto& info : mEngineInfo) {
- bool found = contains(info.assistant_list, appid);
- if (found) {
- if (info.interface.add_wakeup_word) {
- 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());
- }
- } else {
- MWR_LOGE("Wakeup Engine does not provide add_wakeup_word");
- }
- }
- }
-}
-
-void CWakeupEngineManager::engine_remove_wakeup_word(string appid, string wakeup_word, string language)
-{
- for (const auto& info : mEngineInfo) {
- bool found = contains(info.assistant_list, appid);
- if (found) {
- if (info.interface.remove_wakeup_word) {
- try {
- info.interface.remove_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());
- }
- } else {
- MWR_LOGE("Wakeup Engine does not provide remove_wakeup_word");
- }
- }
- }
-}
-
-void CWakeupEngineManager::engine_set_assistant_specific_command(string appid, string command)
-{
- for (const auto& info : mEngineInfo) {
- bool found = contains(info.assistant_list, appid);
- if (found) {
- if (info.interface.set_assistant_specific_command) {
- 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());
- }
- }
- }
- }
-}
-
-void CWakeupEngineManager::engine_feed_audio_data(long time, void* data, int len)
-{
- bool print = false;
- const std::chrono::seconds interval(3);
- static auto last = std::chrono::steady_clock::now();
- auto now = std::chrono::steady_clock::now();
- if (now - last > interval) {
- print = true;
- last = now;
- }
- for (const auto& info : mEngineInfo) {
- bool filtered_out = false;
- if (info.activated &&
- info.audio_data_require_status &&
- info.interface.feed_audio_data) {
- try {
- /* After a wakeup event, wakeup engines other than the selected one
- does not need to receive audio data. */
- if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
- if (mSelectedEngine && &info != mSelectedEngine) {
- filtered_out = true;
- }
- }
- if (!filtered_out) {
- int ret = info.interface.feed_audio_data(time, data, len);
- if (ret != 0 || print) {
- LOGE("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());
- }
- }
- if (print) {
- MWR_LOGE("Feeding audio data to %s : %d %d %p %d",
- info.engine_name.c_str(),
- info.activated, info.audio_data_require_status,
- info.interface.feed_audio_data, filtered_out);
- }
- }
-}
-
-void CWakeupEngineManager::engine_set_dependency_module_command(string engine_name, string command)
-{
- 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) {
- if (iter->activated &&
- iter->interface.set_dependency_module_command) {
- try {
- int ret = iter->interface.set_dependency_module_command(command.c_str());
- if (0 != ret) {
- LOGE("[ERROR] Fail to set dependency module command, ret(%d) : %s",
- ret, iter->engine_name.c_str());
- }
- } catch (const std::exception& e) {
- MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
- iter->engine_name.c_str(), e.what());
- }
- }
- }
-}
-
-bool CWakeupEngineManager::on_wakeup_event(string engine_name, mas_wakeup_event_info info)
-{
- MWR_LOGD("[ENTER]");
-
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_wakeup_event(engine_name, info)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
-
- return true;
-}
-
-bool CWakeupEngineManager::on_speech_status(string engine_name, mas_speech_status_e status)
-{
- MWR_LOGD("[ENTER]");
-
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_speech_status(engine_name, status)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
-
- return true;
-}
-
-bool CWakeupEngineManager::on_error(string engine_name, int error_code, string error_message)
-{
- MWR_LOGD("[ENTER]");
-
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_error(engine_name, error_code, error_message)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
-
- return true;
-}
-
-bool CWakeupEngineManager::on_audio_data_require_status(string engine_name, bool require)
-{
- MWR_LOGI("[ENTER] %s, %d", engine_name.c_str(), require);
-
- bool found = false;
- // LOCK REQUIRED
- int count = 0;
- for (auto& info : mEngineInfo) {
- if (info.engine_name.compare(engine_name) == 0) {
- found = true;
- info.audio_data_require_status = require;
- }
- if (info.activated && info.audio_data_require_status) {
- count++;
- }
- }
- MWR_LOGD("count : %d", count);
- if (count > 0) {
- mAudioDataRequired = true;
- } else {
- mAudioDataRequired = false;
- }
-
- if (found) {
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_audio_data_require_status(engine_name, require)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- }
- // UNLOCK REQUIRED
- return true;
-}
-
-bool CWakeupEngineManager::on_wakeup_engine_command(string engine_name, mas_wakeup_engine_command_target_e target, string assistant_name, string command)
-{
- MWR_LOGI("[ENTER] : %s %d %s %s",
- engine_name.c_str(), target, assistant_name.c_str(), command.c_str());
-
- for (const auto& observer : mObservers) {
- if (observer) {
- if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_DEPENDENCY_MODULE == target) {
- if (!observer->on_wakeup_engine_command(target, engine_name, assistant_name, command)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- } else {
- 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) ||
- MAS_WAKEUP_ENGINE_COMMAND_TARGET_ALL_ASSISTANTS == target) {
- MWR_LOGI("Calling on_wakeup_engine_command for %s", assistant.c_str());
- if (!observer->on_wakeup_engine_command(target, engine_name, assistant, command)) {
- LOGE("[Recorder WARNING] One of the observer returned false");
- }
- }
- }
- }
- }
- }
- }
-
- return true;
-}
-
-void CWakeupEngineManager::add_engine(string name, string path)
-{
- MWR_LOGE("Name (%s), Filepath(%s)", name.c_str(), path.c_str());
-
- char* error = NULL;
- EngineInfo info;
- info.engine_handle = dlopen(path.c_str(), RTLD_LAZY);
- if (nullptr != (error = dlerror()) || nullptr == info.engine_handle) {
- MWR_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", path.c_str(), error);
- if (info.engine_handle) dlclose(info.engine_handle);
- info.engine_handle = nullptr;
- return;
- }
-
- /* Interfaces without version information */
- info.interface.initialize =
- (wakeup_engine_initialize)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_INITIALIZE);
- info.interface.deinitialize =
- (wakeup_engine_deinitialize)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_DEINITIALIZE);
- info.interface.activate =
- (wakeup_engine_activate)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_ACTIVATE);
- info.interface.deactivate =
- (wakeup_engine_deactivate)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_DEACTIVATE);
- info.interface.add_wakeup_word =
- (wakeup_engine_add_wakeup_word)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_ADD_WAKEUP_WORD);
- info.interface.remove_wakeup_word =
- (wakeup_engine_remove_wakeup_word)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_REMOVE_WAKEUP_WORD);
- info.interface.add_language =
- (wakeup_engine_add_language)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_ADD_LANGUAGE);
- info.interface.set_language =
- (wakeup_engine_set_language)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_LANGUAGE);
- info.interface.update_manager_state =
- (wakeup_engine_update_manager_state)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_UPDATE_MANAGER_STATE);
- info.interface.update_recognition_result =
- (wakeup_engine_update_recognition_result)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_UPDATE_RECOGNITION_RESULT);
- info.interface.set_audio_format =
- (wakeup_engine_set_audio_format)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_FORMAT);
- info.interface.get_audio_format =
- (wakeup_engine_get_audio_format)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_AUDIO_FORMAT);
- info.interface.feed_audio_data =
- (wakeup_engine_feed_audio_data)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_FEED_AUDIO_DATA);
- info.interface.get_utterance_data_count =
- (wakeup_engine_get_utterance_data_count)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA_COUNT);
- info.interface.get_utterance_data =
- (wakeup_engine_get_utterance_data)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA);
- info.interface.get_wake_word_data_count =
- (wakeup_engine_get_wake_word_data_count)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA_COUNT);
- info.interface.get_wake_word_data =
- (wakeup_engine_get_wake_word_data)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA);
- info.interface.set_assistant_specific_command =
- (wakeup_engine_set_assistant_specific_command)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND);
- info.interface.set_wake_word_audio_require_flag =
- (wakeup_engine_set_wake_word_audio_require_flag)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG);
- info.interface.set_wakeup_event_callback =
- (wakeup_engine_set_wakeup_event_callback)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_EVENT_CALLBACK);
- info.interface.set_speech_status_callback =
- (wakeup_engine_set_speech_status_callback)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_SPEECH_STATUS_CALLBACK);
- info.interface.set_error_callback =
- (wakeup_engine_set_error_callback)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_ERROR_CALLBACK);
- 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 =
- (wakeup_engine_get_version)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_GET_VERSION);
- info.interface.set_dependency_module_command =
- (wakeup_engine_set_dependency_module_command)dlsym(info.engine_handle,
- MA_WAKEUP_ENGINE_FUNC_SET_DEPENDENCY_MODULE_COMMAND);
-
- if (info.interface.initialize == nullptr) {
- MWR_LOGE("[ERROR] Initialize interface does not exist, skipping %s", path.c_str());
- if (info.engine_handle) dlclose(info.engine_handle);
- info.engine_handle = nullptr;
- return;
- }
-
- info.version = 0;
- info.engine_path = path;
- info.engine_name = name;
-
- info.activated = false;
- info.audio_data_require_status = false;
-
- /* All the necessary information has already been set properly */
- mEngineInfo.push_back(info);
-
- /* Workaround for registering C-style callbacks */
- typedef struct {
- CWakeupEngineManager *manager;
- string engine_name;
- } CallbackUserData;
-
- static deque<CallbackUserData> callback_user_data;
-
- CallbackUserData user_data;
- user_data.manager = this;
- user_data.engine_name = info.engine_name;
- callback_user_data.push_back(user_data);
-
- MWR_LOGI("Initializing wakeup engine : %s %p %p",
- info.engine_path.c_str(),
- info.interface.initialize,
- &callback_user_data.back());
-
- try {
- if (info.interface.set_wakeup_event_callback) {
- info.interface.set_wakeup_event_callback(
- [](mas_wakeup_event_info info, void* user_data) {
- MWR_LOGI("user_data : %p", 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) {
- MWR_LOGI("user_data : %p", 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_wakeup_engine_command_callback) {
- info.interface.set_wakeup_engine_command_callback(
- [](mas_wakeup_engine_command_target_e target,
- const char* assistant_name, const char* command, void* user_data) {
- MWR_LOGI("user_data : %p", 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, target, (assistant_name ? assistant_name : ""), command);
- }, &(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;
- }
- }
- } catch (const std::exception& e) {
- MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
- info.engine_name.c_str(), e.what());
- }
-}
-
-void CWakeupEngineManager::add_engine_directory(string name, string path)
-{
- if (0 == path.size()) return;
-
- DIR* dp = opendir(path.c_str());
- if (NULL == dp) {
- MWR_LOGD("Failed opening directory : %s", path.c_str());
- } else {
- struct dirent *dirp = NULL;
- string filepath;
- do {
- dirp = readdir(dp);
-
- if (NULL != dirp) {
- if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
- continue;
-
- if (DT_REG != dirp->d_type) /* If not a regular file */
- continue;
-
- filepath = path;
- filepath += "/";
- filepath += dirp->d_name;
-
- if (filepath.length() >= _POSIX_PATH_MAX) {
- MWR_LOGD("File path is too long : %s", filepath.c_str());
- closedir(dp);
- return;
- }
- add_engine(name, filepath);
- }
- } while (NULL != dirp);
-
- closedir(dp);
- }
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wakeup_manager.h"
-#include "wakeup_manager_main.h"
-#include "wakeup_policy_default.h"
-#include "wakeup_policy_external.h"
-#include "dependency_resolver.h"
-
-#include <algorithm>
-#include <iostream>
-#include <map>
-
-#include <boost/optional.hpp>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-static bool check_language_valid(string language)
-{
- bool valid = true;
- if (0 == language.length()) {
- valid = false;
- }
- return valid;
-}
-
-static bool initialize_wakeup_event_info(mas_wakeup_event_info* wakeup_info)
-{
- bool ret = false;
- if (wakeup_info) {
- ret = true;
-
- wakeup_info->wakeup_appid = nullptr;
- wakeup_info->wakeup_word = nullptr;
- wakeup_info->wakeup_language = nullptr;
- wakeup_info->wakeup_voice_id = nullptr;
- wakeup_info->wakeup_engine = nullptr;
- wakeup_info->wakeup_confidence_score = 0.0f;
-
- wakeup_info->wakeup_start_time = 0;
- wakeup_info->wakeup_end_time = 0L;
- wakeup_info->wakeup_time_valid = false;
-
- wakeup_info->extra_data = nullptr;
- wakeup_info->extra_data_length = 0;
- wakeup_info->extra_data_description = nullptr;
- }
- return ret;
-}
-
-static map<string, string> get_custom_vconf_keys()
-{
- map<string, string> vconf_keys;
- char* custom_key = NULL;
-
- vconf_keys.clear();
- dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID, &custom_key);
- vconf_keys.insert({WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID, custom_key ? custom_key : WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID});
-
- if (custom_key) {
- free(custom_key);
- custom_key = nullptr;
- }
-
- dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS, &custom_key);
- vconf_keys.insert({WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS, custom_key ? custom_key : WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS});
-
- if (custom_key) {
- free(custom_key);
- custom_key = nullptr;
- }
-
- dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED, &custom_key);
- vconf_keys.insert({WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED, custom_key ? custom_key : WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED});
-
- if (custom_key) {
- free(custom_key);
- custom_key = nullptr;
- }
-
- return vconf_keys;
-}
-
-CWakeupManager::CWakeupManager(IWakeupEventObserver* wakeup_observer, ISettingValueObserver* setting_observer)
-{
- initialize_wakeup_event_info(&mLastWakeupEventInfo);
-
- if (wakeup_observer) {
- subscribe_wakeup_observer(wakeup_observer);
- }
- if (setting_observer) {
- subscribe_setting_observer(setting_observer);
- }
-}
-
-CWakeupManager::~CWakeupManager()
-{
- MWR_LOGI("Wakeup Manager is now being destroyed");
-}
-
-void CWakeupManager::initialize_wakeup_policy()
-{
- mWakeupPolicy.reset(new CWakeupPolicyExternal{&mPolicyEventObserver});
- if (nullptr == mWakeupPolicy || !(mWakeupPolicy->valid())) {
- mWakeupPolicy.reset(new CWakeupPolicyDefault{&mPolicyEventObserver});
-
- /* Default Policy specific initialization */
- CWakeupPolicyDefault *policy =
- dynamic_cast<CWakeupPolicyDefault*>(mWakeupPolicy.get());
- if (policy) {
- int priority = 0;
-
- policy->set_delay(mWakeupSettings.get_wakeup_policy_delay());
- MWR_LOGD("Setting Delay : %f", mWakeupSettings.get_wakeup_policy_delay());
- for (const auto& assistant : mWakeupSettings.get_wakeup_policy_priority()) {
- policy->set_assistant_priority(assistant, ++priority);
- MWR_LOGD("Setting Priority : %d %s", priority, assistant.c_str());
- }
- }
- }
-}
-
-bool CWakeupManager::initialize()
-{
- MWR_LOGE("[ENTER]");
- std::cerr << "WakeupManager Initialize" << std::endl;
-
- mPolicyEventObserver.set_wakeup_manager(this);
- mEngineEventObserver.set_wakeup_manager(this);
- mAudioEventObserver.set_wakeup_manager(this);
- mSettingsEventObserver.set_wakeup_manager(this);
-
- mas_dependency_plugin_proxy_interface interface;
- interface.process_event = wakeup_manager_process_plugin_event;
- interface.feed_audio_data = wakeup_manager_feed_audio_data;
- interface.send_command = wakeup_manager_set_dependency_module_command;
- interface.wakeup_assistant = wakeup_manager_wakeup_assistant;
-
- dependency_resolver_initialize(interface);
-
- mWakeupSettings.subscribe(&mSettingsEventObserver);
- mWakeupSettings.initialize(get_custom_vconf_keys());
-
- mAudioEventObserver.set_wakeup_engine_manager(&mWakeupEngineManager);
- mAudioManager.subscribe(&mAudioEventObserver);
- mAudioManager.initialize();
-
- mWakeupEngineManager.subscribe(&mEngineEventObserver);
- mWakeupEngineManager.initialize();
-
- mAssistantConfigManager.initialize();
-
- initialize_wakeup_policy();
- start_periodic_monitor_timer();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::deinitialize()
-{
- MWR_LOGE("[ENTER]");
- std::cerr << "WakeupManager Deinitialize" << std::endl;
-
- stop_periodic_monitor_timer();
- stop_streaming_duration_timer();
-
- dependency_resolver_deinitialize();
-
- mAssistantConfigManager.deinitialize();
-
- mWakeupEngineManager.unsubscribe(&mEngineEventObserver);
- mWakeupEngineManager.deinitialize();
-
- mAudioManager.unsubscribe(&mAudioEventObserver);
- mAudioManager.deinitialize();
-
- mWakeupSettings.deinitialize();
- mAssistantLanguageInfo.clear();
-
- MWR_LOGE("[END]");
- return true;
-}
-
-void CWakeupManager::subscribe_wakeup_observer(IWakeupEventObserver *observer)
-{
- mWakeupObservers.push_back(observer);
-}
-
-void CWakeupManager::unsubscribe_wakeup_observer(IWakeupEventObserver *observer)
-{
- auto iter = find(mWakeupObservers.begin(), mWakeupObservers.end(), observer);
- if (iter != mWakeupObservers.end()) {
- mWakeupObservers.erase(iter);
- }
-}
-
-void CWakeupManager::subscribe_setting_observer(ISettingValueObserver* observer)
-{
- mSettingObservers.push_back(observer);
-}
-
-void CWakeupManager::unsubscribe_setting_observer(ISettingValueObserver* observer)
-{
- auto iter = find(mSettingObservers.begin(), mSettingObservers.end(), observer);
- if (iter != mSettingObservers.end()) {
- mSettingObservers.erase(iter);
- }
-}
-
-bool CWakeupManager::activate(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (WAKEUP_MANAGER_STATE_INACTIVE != mWakeupManagerState)
- return false;
-
- /* Activate assistants that supports current voice input language */
- set_language(mWakeupSettings.get_current_language());
-
- change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
- if (mWakeupEngineManager.get_audio_data_required()) {
- mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
- mAudioManager.start_recording(true);
- }
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::deactivate(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManagerState)
- return false;
-
- mAudioManager.stop_recording(true);
- mRecordingByVoiceKey = false;
- change_manager_state(WAKEUP_MANAGER_STATE_INACTIVE);
-
- stop_streaming_utterance_data();
- stop_streaming_previous_utterance_data();
- stop_streaming_follow_up_data();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::add_assistant_language(string appid, string language)
-{
- MWR_LOGI("[ENTER]");
- bool found = false;
- for (auto& info : mAssistantLanguageInfo) {
- if(0 == info.appid.compare(appid)) {
- info.languageList.push_back(language);
- found = true;
- }
- }
- if(false == found) {
- AssistantLanguageInfo info;
- info.appid = appid;
- info.languageList.push_back(language);
- mAssistantLanguageInfo.push_back(info);
- }
- if (0 == mCurrentLanguage.compare(language)) {
- mAssistantSupportsCurrentLanguage[appid] = true;
- if (true == mAssistantEnabled[appid]) {
- mWakeupEngineManager.set_assistant_activated(appid, true);
- }
- }
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::add_assistant_wakeup_word(string appid, string wakeup_word, string language)
-{
- MWR_LOGI("[ENTER]");
-
- mWakeupEngineManager.engine_add_wakeup_word(appid, wakeup_word, language);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::remove_assistant_wakeup_word(string appid, string wakeup_word, string language)
-{
- MWR_LOGI("[ENTER]");
-
- mWakeupEngineManager.engine_remove_wakeup_word(appid, wakeup_word, language);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::add_assistant_wakeup_engine(string appid, string engine)
-{
- MWR_LOGI("[ENTER] %s %s", appid.c_str(), engine.c_str());
-
- vector<string> disabled_assistants = mWakeupSettings.get_wake_word_disabled_assistants();
- auto iter = find(disabled_assistants.begin(), disabled_assistants.end(), appid);
- if (iter != disabled_assistants.end())
- return true;
-
- bool found = false;
- if (mWakeupSettings.get_multiple_mode()) {
- vector<string> assistants = mWakeupSettings.get_enabled_assistants();
- 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;
-}
-
-bool CWakeupManager::set_assistant_language(string appid, string language)
-{
- MWR_LOGI("[ENTER] : %s, %s", appid.c_str(), language.c_str());
-
- mWakeupEngineManager.set_assistant_language(appid, language);
- mAssistantConfigManager.set_assistant_language(appid, language);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_assistant_enabled(string appid, bool enabled)
-{
- MWR_LOGI("[ENTER]");
-
- mAssistantEnabled[appid] = enabled;
- bool activated = enabled;
- if (false == mAssistantSupportsCurrentLanguage[appid]) {
- activated = false;
- }
- if (0 == appid.compare(mWakeupSettings.get_default_assistant_appid())) {
- activated = true;
- }
- mWakeupEngineManager.set_assistant_activated(appid, activated);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_default_assistant(string appid)
-{
- MWR_LOGE("[ENTER] %s %s", appid.c_str(), mCurrentDefaultAssistant.c_str());
-
- /* Passing 'expected' as true since MAS is changing the default assistant config */
- process_default_assistant_changed(appid, true);
-
- mWakeupSettings.set_default_assistant_appid(appid);
-
- return true;
-}
-
-bool CWakeupManager::process_default_assistant_changed(string appid, bool expected)
-{
- MWR_LOGE("[ENTER] %s %s", appid.c_str(), mCurrentDefaultAssistant.c_str());
-
- if (mCurrentDefaultAssistant.compare(appid) == 0) {
- MWR_LOGE("Default assistant appid not changed, ignoring...");
- return false;
- }
-
- if (mWakeupManagerState == WAKEUP_MANAGER_STATE_UTTERANCE ||
- mWakeupManagerState == WAKEUP_MANAGER_STATE_PROCESSING) {
- if (expected) {
- stop_streaming_utterance_data();
- stop_streaming_previous_utterance_data();
- stop_streaming_follow_up_data();
-
- mWakeupEngineManager.update_recognition_result(appid, MA_RECOGNITION_RESULT_EVENT_ERROR);
- } else {
- /* If this is an unexpected change, invalidate previous recognition process */
- update_recognition_result(mCurrentDefaultAssistant, MA_RECOGNITION_RESULT_EVENT_ERROR);
- }
- }
-
- /* Check if previous default assistant has to be deactivated */
- bool activated = true;
- if (false == mAssistantSupportsCurrentLanguage[mCurrentDefaultAssistant]) {
- activated = false;
- }
- if (false == mAssistantEnabled[mCurrentDefaultAssistant]) {
- activated = false;
- }
- mWakeupEngineManager.set_assistant_activated(mCurrentDefaultAssistant, activated);
-
- /* New default assistant has to be activated no matter what */
- mWakeupEngineManager.set_assistant_activated(appid, true);
-
- mCurrentDefaultAssistant = appid;
-
- MWR_LOGD("[END]");
- return true;
-}
-
-string CWakeupManager::get_default_assistant()
-{
- return mWakeupSettings.get_default_assistant_appid();
-}
-
-bool CWakeupManager::get_assistant_enabled(string appid)
-{
- return mAssistantEnabled[appid];
-}
-
-bool CWakeupManager::set_language(string language)
-{
- bool valid = false;
- MWR_LOGI("[ENTER] : %s", language.c_str());
-
- if (check_language_valid(language)) {
- mCurrentLanguage = language;
- valid = true;
- } else {
- MWR_LOGE("[ERROR] Invalid language (%s)", language.c_str());
- }
-
- for (auto& info : mAssistantLanguageInfo) {
- bool disable = false;
- if (valid) {
- bool supported = false;
- if (info.languageList.end() !=
- find(info.languageList.begin(), info.languageList.end(), language)) {
- supported = true;
- }
- mAssistantSupportsCurrentLanguage[info.appid] = supported;
- /* Disable this assistant if language not supported */
- if (!supported) disable = true;
- } else {
- /* If current language is not valid, assume all languages support it */
- mAssistantSupportsCurrentLanguage[info.appid] = true;
- }
-
- if (false == mAssistantEnabled[info.appid]) {
- disable = true;
- }
- if (0 == info.appid.compare(mWakeupSettings.get_default_assistant_appid())) {
- /* Default Assistant should be activated no matter what */
- disable = false;
- }
- mWakeupEngineManager.set_assistant_activated(info.appid, !disable);
- std::string assistant_language;
- int ret = mAssistantConfigManager.get_assistant_language(info.appid, assistant_language);
- if (0 != ret || !check_language_valid(assistant_language)) {
- mWakeupEngineManager.set_assistant_language(info.appid, language);
- } else {
- mWakeupEngineManager.set_assistant_language(info.appid, assistant_language);
- }
- }
-
- MWR_LOGD("[END]");
- return valid;
-}
-
-bool CWakeupManager::get_recording_by_voice_key()
-{
- return mRecordingByVoiceKey;
-}
-
-void CWakeupManager::set_recording_by_voice_key(bool recording)
-{
- mRecordingByVoiceKey = recording;
-}
-
-STREAMING_MODE CWakeupManager::get_streaming_mode()
-{
- return mStreamingMode;
-}
-
-bool CWakeupManager::set_streaming_mode(STREAMING_MODE mode)
-{
- lock_guard<mutex> lock(mMutex);
- mStreamingMode = mode;
- return true;
-}
-
-bool CWakeupManager::change_manager_state(wakeup_manager_state_e state)
-{
- MWR_LOGI("[ENTER] : %d", state);
- mWakeupManagerState = state;
- mWakeupEngineManager.update_manager_state(state);
- for (const auto& observer : mWakeupObservers) {
- observer->on_wakeup_service_state_changed((ma_service_state_e)state);
- }
- return true;
-}
-
-wakeup_manager_state_e CWakeupManager::get_manager_state()
-{
- return mWakeupManagerState;
-}
-
-bool CWakeupManager::update_voice_feedback_state(string appid, bool state)
-{
- MWR_LOGI("[ENTER]");
-
- if (state) {
- if (WAKEUP_MANAGER_STATE_LISTENING == mWakeupManagerState ||
- WAKEUP_MANAGER_STATE_PROCESSING == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_VOICE_FEEDBACK);
- }
- } else {
- if (WAKEUP_MANAGER_STATE_VOICE_FEEDBACK == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
- }
- }
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_assistant_specific_command(string appid, string command)
-{
- MWR_LOGI("[ENTER]");
-
- /*
- static const string voice_key_pressed{"voice_key_pressed"};
- static const string voice_key_released{"voice_key_released"};
-
- if (0 == command.compare(voice_key_pressed)) {
- process_event(MA_PLUGIN_EVENT_VOICE_KEY_PRESSED, NULL, 0);
- } else if (0 == command.compare(voice_key_released)) {
- process_event(MA_PLUGIN_EVENT_VOICE_KEY_RELEASED, NULL, 0);
- }
- */
-
- mWakeupEngineManager.engine_set_assistant_specific_command(appid, command);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_background_volume(string appid, double ratio)
-{
- MWR_LOGD("[DEBUG] set background volume (%f)", ratio);
-
- int ret = 0;
- mAudioManager.set_background_volume(ratio);
- return ret;
-}
-
-bool CWakeupManager::update_recognition_result(string appid, int result)
-{
- MWR_LOGI("[ENTER]");
-
- stop_streaming_utterance_data();
- stop_streaming_previous_utterance_data();
- stop_streaming_follow_up_data();
-
- mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
- mWakeupEngineManager.update_recognition_result(appid, result);
- if (WAKEUP_MANAGER_STATE_PROCESSING == mWakeupManagerState ||
- WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
- }
- MWR_LOGD("[END]");
- return true;
-}
-
-static long long get_current_milliseconds_after_epoch()
-{
- auto now = chrono::steady_clock::now();
- auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
- /* number of milliseconds since the epoch of system_clock */
- auto value = now_ms.time_since_epoch();
-
- return value.count();
-}
-
-bool CWakeupManager::process_plugin_event(mas_plugin_event_e event, void* data, int len)
-{
- MWR_LOGE("[ENTER] : %d", event);
- if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManagerState)
- return false;
-
- bool start_recording = false;
- bool stop_recording = false;
-
- boost::optional<ma_voice_key_status_e> next_voice_key_status;
- if (MAS_PLUGIN_EVENT_VOICE_KEY_PRESSED == event) {
- if (STREAMING_MODE::FOLLOW_UP == mStreamingMode) {
- MWR_LOGE("Voice key pressed, but currently streaming follow_up audio");
- } else {
- if (VOICE_KEY_SUPPORT_MODE_NONE != mCurrentVoiceKeySupportMode) {
- start_recording = true;
- }
- }
- next_voice_key_status = MA_VOICE_KEY_STATUS_PRESSED;
- } else if (MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_PUSH == event) {
- if (VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK == mCurrentVoiceKeySupportMode ||
- VOICE_KEY_SUPPORT_MODE_ALL == mCurrentVoiceKeySupportMode) {
- stop_recording = true;
- }
- next_voice_key_status = MA_VOICE_KEY_STATUS_RELEASED_AFTER_PUSH;
- } else if (MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_TAP == event) {
- if (VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK == mCurrentVoiceKeySupportMode) {
- stop_recording = true;
- }
- next_voice_key_status = MA_VOICE_KEY_STATUS_RELEASED_AFTER_TAP;
- }
-
- if (start_recording) {
- mRecordingByVoiceKey = true;
-
- mAudioManager.stop_recording(true);
-
- stop_streaming_utterance_data();
- stop_streaming_previous_utterance_data();
- stop_streaming_follow_up_data();
-
- mAudioManager.clear_audio_data();
- change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
-
- /* Start recorder thread using appropriate recording device */
- mAudioManager.set_recording_session(RECORDING_SESSION_UTTERANCE);
- mAudioManager.start_recording(true);
-
- /* Wakeup default assistant */
- /* TODO: apply conversation timeout for selecting assistant here */
- mas_wakeup_event_info wakeup_info;
- initialize_wakeup_event_info(&wakeup_info);
- /* Make sure to use background data */
- wakeup_info.wakeup_time_valid = true;
- wakeup_info.wakeup_end_time = get_current_milliseconds_after_epoch();
- wakeup_info.wakeup_engine = WAKEUP_ENGINE_VOICE_KEY;
-
- std::string default_assistant_appid = mWakeupSettings.get_default_assistant_appid();
- wakeup_info.wakeup_appid = default_assistant_appid.c_str();
- MWR_LOGD("wakeup_appid : %s", wakeup_info.wakeup_appid);
-
- set_last_wakeup_event_info(wakeup_info);
- mWakeupEngineManager.set_selected_wakeup_info(wakeup_info);
- for (const auto& observer : mWakeupObservers) {
- observer->on_wakeup(wakeup_info);
- }
- }
- if (stop_recording) {
- mRecordingByVoiceKey = false;
-
- stop_streaming_duration_timer();
- mAudioManager.finalize_audio_data();
-
- if (STREAMING_MODE::UTTERANCE == mStreamingMode) {
- change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
- } else {
- change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
- }
-
- mAudioManager.stop_recording(true);
- mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
- if (mWakeupEngineManager.get_audio_data_required()) {
- /* Restart recorder thread using appropriate recording device */
- mAudioManager.start_recording(true);
- }
- }
-
- if (next_voice_key_status) {
- update_voice_key_status(*next_voice_key_status);
- }
-
- MWR_LOGD("[END]");
- return true;
-}
-
-void CWakeupManager::set_streaming_completed(bool completed)
-{
- MWR_LOGI("[ENTER] : %d", completed);
- mStreamingCompleted.store(completed);
-
- /* When Streaming completes, update pending voice key status */
- update_pending_voice_key_status();
-}
-
-void CWakeupManager::start_voice_key_status_update_timer()
-{
- const float VOICE_KEY_STATUS_UPDATE_INTERVAL = 5.0f;
-
- if (mVoiceKeyStatusUpdateTimer) {
- ecore_timer_del(mVoiceKeyStatusUpdateTimer);
- }
-
- mVoiceKeyStatusUpdateTimer = ecore_timer_add(VOICE_KEY_STATUS_UPDATE_INTERVAL,
- [](void *data) {
- MAS_LOGE("voice_key_status_update_timer expired");
- auto manager = static_cast<CWakeupManager*>(data);
- manager->update_pending_voice_key_status();
- return ECORE_CALLBACK_CANCEL;
- }, static_cast<void*>(this));
-}
-
-void CWakeupManager::update_pending_voice_key_status()
-{
- MAS_LOGI("[ENTER]");
- if (mVoiceKeyStatusUpdateTimer) {
- ecore_timer_del(mVoiceKeyStatusUpdateTimer);
- mVoiceKeyStatusUpdateTimer = nullptr;
- }
- if (mPendingVoiceKeyStatus) {
- for (const auto& observer : mWakeupObservers) {
- observer->on_voice_key_status_changed(*mPendingVoiceKeyStatus);
- }
- mPendingVoiceKeyStatus = boost::none;
- }
-}
-
-void CWakeupManager::update_voice_key_status(ma_voice_key_status_e status)
-{
- MWR_LOGI("status : %d", status);
- if (mPendingVoiceKeyStatus) {
- for (const auto& observer : mWakeupObservers) {
- observer->on_voice_key_status_changed(*mPendingVoiceKeyStatus);
- }
- mPendingVoiceKeyStatus = boost::none;
- }
-
- /* If streaming has not been completed yet after pressed event,
- * postpone the status update until streaming is completed */
- bool postpone = false;
- if (status == MA_VOICE_KEY_STATUS_RELEASED_AFTER_PUSH) {
- if (!mStreamingCompleted.load()) {
- postpone = true;
- }
- }
-
- if (postpone) {
- mPendingVoiceKeyStatus = status;
- start_voice_key_status_update_timer();
- } else {
- for (const auto& observer : mWakeupObservers) {
- observer->on_voice_key_status_changed(status);
- }
- }
-
- if (status == MA_VOICE_KEY_STATUS_PRESSED) {
- mStreamingCompleted.store(false);
- }
-}
-
-vector<IWakeupEventObserver*> CWakeupManager::get_wakeup_observers()
-{
- return mWakeupObservers;
-}
-
-void CWakeupManager::set_last_wakeup_event_info(mas_wakeup_event_info wakeup_info)
-{
- mLastWakeupEventInfo = wakeup_info;
- mLastWakeupEventID++;
-}
-
-vector<ISettingValueObserver*> CWakeupManager::get_setting_observers()
-{
- return mSettingObservers;
-}
-
-static Eina_Bool streaming_duration_expired(void *data)
-{
- MWR_LOGW("[ENTER]");
- CWakeupManager *wakeup_manager = static_cast<CWakeupManager*>(data);
- if (nullptr == wakeup_manager) return ECORE_CALLBACK_CANCEL;
-
- wakeup_manager->set_streaming_duration_timer(nullptr);
-
- CAudioManager *audio_manager = wakeup_manager->get_audio_manager();
- CWakeupEngineManager *engine_manager = wakeup_manager->get_engine_manager();
-
- if (nullptr == audio_manager) return ECORE_CALLBACK_CANCEL;
- if (nullptr == engine_manager) return ECORE_CALLBACK_CANCEL;
-
- switch(wakeup_manager->get_streaming_mode()) {
- case STREAMING_MODE::UTTERANCE:
- audio_manager->stop_streaming_current_utterance_data();
- engine_manager->stop_streaming_current_utterance_data();
- break;
- case STREAMING_MODE::PREVIOUS_UTTERANCE:
- audio_manager->stop_streaming_previous_utterance_data();
- break;
- case STREAMING_MODE::FOLLOW_UP:
- audio_manager->stop_streaming_follow_up_data();
- audio_manager->stop_recording(true);
- wakeup_manager->set_recording_by_voice_key(false);
- audio_manager->clear_audio_data();
- break;
- }
-
- wakeup_manager->set_streaming_mode(STREAMING_MODE::NONE);
-
- if (WAKEUP_MANAGER_STATE_UTTERANCE == wakeup_manager->get_manager_state()) {
- audio_manager->stop_recording(true);
- wakeup_manager->set_recording_by_voice_key(false);
- audio_manager->set_recording_session(RECORDING_SESSION_WAKE_WORD);
- if (engine_manager->get_audio_data_required()) {
- /* Restart recorder thread using appropriate recording device */
- audio_manager->start_recording(true);
- }
- wakeup_manager->change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
- }
-
- return ECORE_CALLBACK_CANCEL;
-}
-
-bool CWakeupManager::start_streaming_utterance_data()
-{
- MWR_LOGI("[ENTER]");
-
- if (mCurrentStreamingSessionID == mLastWakeupEventID) {
- MWR_LOGW("Streaming already started for this session");
- return false;
- }
-
- mCurrentStreamingSessionID = mLastWakeupEventID;
-
- mAudioManager.stop_streaming_current_utterance_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- mStreamingMode = STREAMING_MODE::UTTERANCE;
-
- bool streaming_by_manager = true;
- if (false == mLastWakeupEventInfo.wakeup_time_valid) {
- mWakeupEngineManager.start_streaming_current_utterance_data();
- streaming_by_manager = false;
- } else {
- mAudioManager.start_streaming_current_utterance_data(mLastWakeupEventInfo.wakeup_end_time);
- }
-
- stop_streaming_duration_timer();
- if (streaming_by_manager) {
- start_streaming_duration_timer();
- }
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::stop_streaming_utterance_data()
-{
- MWR_LOGI("[ENTER]");
-
- if (STREAMING_MODE::UTTERANCE != mStreamingMode) return false;
-
- mAudioManager.stop_streaming_current_utterance_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- if (mStreamingDurationTimer) {
- stop_streaming_duration_timer();
- }
- if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
- mAudioManager.stop_recording(true);
- mRecordingByVoiceKey = false;
- mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
- if (mWakeupEngineManager.get_audio_data_required()) {
- /* Restart recorder thread using appropriate recording device */
- mAudioManager.start_recording(true);
- }
- }
-
- mStreamingMode = STREAMING_MODE::NONE;
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::start_streaming_follow_up_data()
-{
- MWR_LOGI("[ENTER]");
-
- mAudioManager.stop_streaming_follow_up_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- mStreamingMode = STREAMING_MODE::FOLLOW_UP;
-
- /* For the follow up streaming, audio data should be recorded from now on */
- mAudioManager.stop_recording(true);
- mAudioManager.clear_audio_data();
- change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
- mAudioManager.set_recording_session(RECORDING_SESSION_FOLLOW_UP);
- mAudioManager.start_recording(true);
-
- mAudioManager.start_streaming_follow_up_data();
-
- stop_streaming_duration_timer();
- start_streaming_duration_timer();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::stop_streaming_follow_up_data()
-{
- MWR_LOGI("[ENTER]");
- if (STREAMING_MODE::FOLLOW_UP != mStreamingMode) return false;
-
- mAudioManager.stop_streaming_follow_up_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- if (mStreamingDurationTimer) {
- stop_streaming_duration_timer();
- }
-
- if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
- mAudioManager.stop_recording(true);
- mRecordingByVoiceKey = false;
- mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
- if (mWakeupEngineManager.get_audio_data_required()) {
- /* Restart recorder thread using appropriate recording device */
- mAudioManager.start_recording(true);
- }
- }
-
- mStreamingMode = STREAMING_MODE::NONE;
-
- mAudioManager.clear_audio_data();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::start_streaming_previous_utterance_data()
-{
- MWR_LOGI("[ENTER]");
-
- mAudioManager.stop_streaming_previous_utterance_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- mStreamingMode = STREAMING_MODE::PREVIOUS_UTTERANCE;
- mAudioManager.start_streaming_previous_utterance_data();
-
- stop_streaming_duration_timer();
- start_streaming_duration_timer();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::stop_streaming_previous_utterance_data()
-{
- MWR_LOGI("[ENTER]");
- if (STREAMING_MODE::PREVIOUS_UTTERANCE != mStreamingMode) return false;
-
- mAudioManager.stop_streaming_previous_utterance_data();
- mWakeupEngineManager.stop_streaming_current_utterance_data();
-
- if (mStreamingDurationTimer) {
- stop_streaming_duration_timer();
- }
-
- if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
- change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
- }
-
- mStreamingMode = STREAMING_MODE::NONE;
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::get_audio_format(int* rate, int* channel, int* audio_type)
-{
- MWR_LOGI("[ENTER]");
-
- if (!audio_type || !rate || !channel) {
- MWR_LOGE("[ERROR] Invalid parameter");
- return false;
- }
-
- dependency_resolver_get_audio_format(rate, channel, audio_type);
-
- MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
- return true;
-}
-
-bool CWakeupManager::get_audio_source_type(char** type)
-{
- MWR_LOGI("[ENTER]");
-
- if (!type) {
- MWR_LOGE("[ERROR] Invalid parameter");
- return false;
- }
-
- dependency_resolver_get_audio_source_type(type);
-
- MWR_LOGD("[END] type(%s)", *type);
- return true;
-}
-
-bool CWakeupManager::set_wake_word_audio_require_flag(bool require)
-{
- MWR_LOGI("[ENTER]");
-
- mWakeupEngineManager.set_wake_word_audio_require_flag(require);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_voice_key_tap_duration(float duration)
-{
- MWR_LOGI("[ENTER]");
-
- dependency_resolver_set_voice_key_tap_duration(duration);
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::unset_voice_key_tap_duration()
-{
- MWR_LOGI("[ENTER]");
-
- dependency_resolver_unset_voice_key_tap_duration();
-
- MWR_LOGD("[END]");
- return true;
-}
-
-bool CWakeupManager::set_voice_key_support_mode(VOICE_KEY_SUPPORT_MODE mode)
-{
- MWR_LOGI("Voice key support mode : %d", mode);
- mCurrentVoiceKeySupportMode = mode;
-
- char* support_mode = NULL;
- switch (mode)
- {
- case VOICE_KEY_SUPPORT_MODE_NONE:
- support_mode = strdup("none");
- break;
- case VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK:
- support_mode = strdup("push_to_talk");
- break;
- case VOICE_KEY_SUPPORT_MODE_TAP_TO_TALK:
- support_mode = strdup("tap_to_talk");
- break;
- case VOICE_KEY_SUPPORT_MODE_ALL:
- support_mode = strdup("all");
- break;
- default:
- support_mode = strdup("none");
- break;
- }
-
- dependency_resolver_set_voice_key_support_mode(support_mode);
-
- if (support_mode)
- free(support_mode);
-
- return true;
-}
-
-CWakeupPolicy* CWakeupManager::get_wakeup_policy()
-{
- return mWakeupPolicy.get();
-}
-
-CWakeupEngineManager* CWakeupManager::get_engine_manager()
-{
- return &mWakeupEngineManager;
-}
-
-CAudioManager* CWakeupManager::get_audio_manager()
-{
- return &mAudioManager;
-}
-
-CWakeupSettings* CWakeupManager::get_wakeup_settings()
-{
- return &mWakeupSettings;
-}
-
-void CWakeupManager::feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
-{
- const std::chrono::seconds interval(5);
- static auto last = std::chrono::steady_clock::now();
- auto now = std::chrono::steady_clock::now();
- if (now - last > interval) {
- std::cerr << "Feeding Audio : " << len << std::endl;
- last = now;
- }
-
- mAudioManager.feed_audio_data(event, buffer, len);
-}
-
-void CWakeupManager::set_dependency_module_command(string engine_name, string command)
-{
- mWakeupEngineManager.engine_set_dependency_module_command(engine_name, command);
-}
-
-static Eina_Bool periodic_monitor_func(void *data)
-{
- std::cerr << "MAS PERIODIC HEALTH CHECK" << std::endl;
- return ECORE_CALLBACK_RENEW;
-}
-
-void CWakeupManager::start_periodic_monitor_timer()
-{
- MWR_LOGI("MONITOR_TIMER START");
- mPeriodicMonitorTimer = ecore_timer_add(
- 30.0f,
- periodic_monitor_func, nullptr);
-}
-
-void CWakeupManager::stop_periodic_monitor_timer()
-{
- if (mPeriodicMonitorTimer) {
- ecore_timer_del(mPeriodicMonitorTimer);
- mPeriodicMonitorTimer = nullptr;
- }
-}
-
-void CWakeupManager::start_streaming_duration_timer()
-{
- MWR_LOGI("DURATION_TIMER START");
- ecore_main_loop_thread_safe_call_async([](void* data) {
- MWR_LOGI("DURATION_TIMER START - async");
- CWakeupManager* manager = static_cast<CWakeupManager*>(data);
- if (!manager) return;
-
- CWakeupSettings *settings = manager->get_wakeup_settings();
- if (settings) {
- Ecore_Timer* timer = ecore_timer_add(
- settings->get_streaming_duration_max(),
- streaming_duration_expired, manager);
- manager->set_streaming_duration_timer(timer);
- MWR_LOGI("DURATION_TIMER STARTED : %p", timer);
- }
- }, this);
-}
-
-void CWakeupManager::stop_streaming_duration_timer()
-{
- MWR_LOGI("DURATION_TIMER STOP");
- if (mStreamingDurationTimer) {
- MWR_LOGI("DURATION_TIMER STOP - has timer");
- ecore_main_loop_thread_safe_call_async([](void* data) {
- MWR_LOGI("DURATION_TIMER STOP - async");
- CWakeupManager* manager = static_cast<CWakeupManager*>(data);
- if (!manager) return;
-
- Ecore_Timer* timer = manager->get_streaming_duration_timer();
- void* ret = ecore_timer_del(timer);
- MWR_LOGI("DURATION_TIMER EXISTS : %p %p", timer, ret);
- manager->set_streaming_duration_timer(nullptr);
- }, this);
- }
-}
-
-void CWakeupManager::set_streaming_duration_timer(Ecore_Timer* timer)
-{
- MWR_LOGI("DURATION_TIMER SET : %p", timer);
- mStreamingDurationTimer = timer;
-}
-
-Ecore_Timer* CWakeupManager::get_streaming_duration_timer()
-{
- return mStreamingDurationTimer;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info)
-{
- MWR_LOGI("[ENTER]");
- if (nullptr == mWakeupManager) return false;
- if (nullptr == wakeup_info.wakeup_appid) return false;
-
- if (0 != mWakeupManager->get_default_assistant().compare(wakeup_info.wakeup_appid)) {
- if (false == mWakeupManager->get_assistant_enabled(string{wakeup_info.wakeup_appid})) {
- MWR_LOGE("Wakeup event with deactivated appid : %s", wakeup_info.wakeup_appid);
- return false;
- }
- }
-
- CWakeupPolicy* policy = mWakeupManager->get_wakeup_policy();
- if (policy) {
- policy->wakeup_candidate(wakeup_info);
- }
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_speech_status(string engine_name, mas_speech_status_e status)
-{
- MWR_LOGI("[ENTER]");
- if (nullptr == mWakeupManager) return false;
-
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_error(string engine_name, int error_code, string error_message)
-{
- MWR_LOGI("[ENTER]");
- if (nullptr == mWakeupManager) return false;
-
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_audio_data_require_status(string engine_name, bool require)
-{
- MWR_LOGI("[ENTER]");
- if (nullptr == mWakeupManager) return false;
- if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManager->get_manager_state()) return false;
-
- CAudioManager *audio_manager = mWakeupManager->get_audio_manager();
- CWakeupEngineManager *engine_manager = mWakeupManager->get_engine_manager();
-
- if (audio_manager && engine_manager) {
- if (engine_manager->get_audio_data_required()) {
- if (mWakeupManager->get_recording_by_voice_key() != true) {
- audio_manager->set_recording_session(RECORDING_SESSION_WAKE_WORD);
- audio_manager->start_recording(true);
- }
- } else {
- if (mWakeupManager->get_recording_by_voice_key() != true) {
- audio_manager->stop_recording(true);
- }
- }
- }
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_streaming_audio_data(
- mas_speech_streaming_event_e event, void* buffer, unsigned int len)
-{
- if (nullptr == mWakeupManager) return false;
-
- vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
- for (const auto& observer : observers) {
- observer->on_streaming_audio_data(event, buffer, len);
- }
-
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_audio_streaming_data_section(
- ma_audio_streaming_data_section_e section)
-{
- if (nullptr == mWakeupManager) return false;
-
- vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
- for (const auto& observer : observers) {
- observer->on_audio_streaming_data_section(section);
- }
-
- return true;
-}
-
-bool CWakeupManager::CEngineEventObserver::on_wakeup_engine_command(
- mas_wakeup_engine_command_target_e target, string engine_name, string assistant_name, string command)
-{
- if (nullptr == mWakeupManager) return false;
-
- if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_DEPENDENCY_MODULE == target) {
- dependency_resolver_process_wakeup_engine_command(engine_name.c_str(), command.c_str());
- }
-
- if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_ALL_ASSISTANTS == target ||
- MAS_WAKEUP_ENGINE_COMMAND_TARGET_SPECIFIC_ASSISTANT == target) {
- vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
- for (const auto& observer : observers) {
- observer->on_wakeup_engine_command(target, assistant_name.c_str(), command.c_str());
- }
- }
-
- return true;
-}
-
-void CWakeupManager::CPolicyEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
-{
- if (nullptr == mWakeupManager) return;
-
- CAudioManager *audio_manager = mWakeupManager->get_audio_manager();
- CWakeupEngineManager *engine_manager = mWakeupManager->get_engine_manager();
- CWakeupSettings* settings = mWakeupManager->get_wakeup_settings();
- if (nullptr == audio_manager || nullptr == engine_manager || nullptr == settings) return;
-
- if (wakeup_info.wakeup_appid && strlen(wakeup_info.wakeup_appid) > 0) {
- mWakeupManager->set_default_assistant(wakeup_info.wakeup_appid);
- }
-
- mWakeupManager->stop_streaming_utterance_data();
- mWakeupManager->stop_streaming_previous_utterance_data();
- mWakeupManager->stop_streaming_follow_up_data();
- mWakeupManager->change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
-
- mWakeupManager->set_last_wakeup_event_info(wakeup_info);
- engine_manager->set_selected_wakeup_info(wakeup_info);
- vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
- for (const auto& observer : observers) {
- observer->on_wakeup(wakeup_info);
- }
-
- audio_manager->set_recording_session(RECORDING_SESSION_UTTERANCE);
-}
-
-bool CWakeupManager::CAudioEventObserver::on_recording_audio_data(long time, void* data, int len)
-{
- if (nullptr == mWakeupManager) return false;
- if (nullptr == mEngineManager) return false;
-
- if (false == mEngineManager->get_audio_data_required()) return false;
-
- if (mWakeupManager->get_recording_by_voice_key() != true) {
- /* When follow-up streaming in progress, no need to feed audio data to wakeup engines */
- if (STREAMING_MODE::FOLLOW_UP != mWakeupManager->get_streaming_mode()) {
- mEngineManager->engine_feed_audio_data(time, data, len);
- }
- }
-
- return true;
-}
-
-bool CWakeupManager::CAudioEventObserver::on_streaming_audio_data(
- mas_speech_streaming_event_e event, void* buffer, unsigned int len)
-{
- if (nullptr == mWakeupManager) return false;
-
- vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
- for (const auto& observer : observers) {
- observer->on_streaming_audio_data(event, buffer, len);
- }
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
- mWakeupManager->set_streaming_mode(STREAMING_MODE::NONE);
- mWakeupManager->stop_streaming_duration_timer();
-
- mWakeupManager->set_streaming_completed(true);
- }
-
- return true;
-}
-
-bool CWakeupManager::CSettingsEventObserver::on_voice_input_language_changed(
- const char* language)
-{
- if (nullptr == mWakeupManager || nullptr == language) return false;
- mWakeupManager->set_language(std::string(language));
- vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
- for (const auto& observer : observers) {
- observer->on_value_changed();
- }
- return true;
-}
-
-bool CWakeupManager::CSettingsEventObserver::on_assistant_enabled_info_changed(
- const char* appid, bool enabled)
-{
- MWR_LOGE("[ENTER]");
- if (nullptr == mWakeupManager || nullptr == appid) return false;
- mWakeupManager->set_assistant_enabled(std::string(appid), enabled);
- vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
- for (const auto& observer : observers) {
- if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
- observer->on_loaded_wakeup_engine_changed();
- else
- observer->on_value_changed();
- }
- MWR_LOGE("[END]");
- return true;
-}
-
-bool CWakeupManager::CSettingsEventObserver::on_default_assistant_appid_changed(
- const char* appid)
-{
- MWR_LOGE("[ENTER]");
- if (nullptr == mWakeupManager || nullptr == appid) return false;
- /* Passing 'expected' as false since the change was occurred outside of MAS */
- mWakeupManager->process_default_assistant_changed(std::string(appid), false);
- vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
- for (const auto& observer : observers) {
- if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
- observer->on_value_changed();
- else
- observer->on_loaded_wakeup_engine_changed();
- }
- MWR_LOGE("[END]");
- return true;
-}
-
-bool CWakeupManager::CSettingsEventObserver::on_multiple_mode_changed()
-{
- MWR_LOGE("[ENTER]");
- if (nullptr == mWakeupManager) return false;
- vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
- for (const auto& observer : observers) {
- observer->on_loaded_wakeup_engine_changed();
- }
- MWR_LOGE("[END]");
- return true;
-}
-
-bool CWakeupManager::CSettingsEventObserver::on_wake_word_detection_enabled_info_changed()
-{
- MWR_LOGE("[ENTER]");
- if (nullptr == mWakeupManager) return false;
- vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
- for (const auto& observer : observers) {
- observer->on_loaded_wakeup_engine_changed();
- }
- MWR_LOGE("[END]");
- return true;
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-/*
- * Copyright 2018-2019 Samsung Electronics Co., Ltd
- *
- * Licensed under the Flora License, Version 1.1 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "wakeup_manager_wrapper.h"
-#include "wakeup_manager_main.h"
-#include "wakeup_manager.h"
-
-#include <memory>
-
-#if 0
-#define BUF_SAVE_MODE
-#endif
-#if 0
-#define BUF_LOAD_MODE
-#endif
-
-#ifdef BUF_SAVE_MODE
-static char g_temp_file_name[128] = {'\0', };
-
-static FILE* g_pFile = NULL;
-
-static int g_count = 1;
-#endif
-
-#ifdef BUF_LOAD_MODE
-static FILE* g_pFile = NULL;
-#endif
-
-using namespace multiassistant::wakeup;
-
-static wakeup_service_wakeup_event_cb g_wakeup_event_cb;
-static void* g_wakeup_event_user_data;
-
-static wakeup_service_speech_streaming_cb g_utterance_streaming_cb;
-static void* g_utterance_streaming_user_data;
-
-static wakeup_service_speech_streaming_cb g_previous_utterance_streaming_cb;
-static void* g_previous_utterance_streaming_user_data;
-
-static wakeup_service_speech_streaming_cb g_follow_up_streaming_cb;
-static void* g_follow_up_streaming_user_data;
-
-static wakeup_service_speech_status_cb g_speech_status_cb;
-static void* g_speech_status_user_data;
-
-static wakeup_service_setting_changed_cb g_setting_changed_cb;
-static void* g_setting_changed_user_data;
-
-static wakeup_service_error_cb g_error_cb;
-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;
-
-static wakeup_service_state_changed_cb g_wakeup_service_state_changed_cb;
-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;
- void on_streaming_audio_data(
- mas_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(
- mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command) override;
- void on_wakeup_service_state_changed(ma_service_state_e state) override;
- void on_voice_key_status_changed(ma_voice_key_status_e status) override;
-};
-
-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;
-static std::unique_ptr<CSettingValueObserver> g_setting_value_observer;
-static std::unique_ptr<CWakeupManager> g_wakeup_manager;
-
-int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
-
-#ifdef BUF_LOAD_MODE
-static Eina_Bool file_read_feed(void *data)
-{
- if (g_pFile == NULL) {
- g_pFile = fopen("/tmp/ma_feed_file", "rb");
- if (g_pFile == NULL) return EINA_FALSE;
- }
-
- if (feof(g_pFile)) {
- fclose(g_pFile);
- return EINA_FALSE;
- }
-
- const size_t BUFFER_SIZE = 4096;
- unsigned char buffer[BUFFER_SIZE];
- size_t len = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, g_pFile);
- wakeup_manager_feed_audio_data(MAS_SPEECH_STREAMING_EVENT_CONTINUE, buffer, len);
-
- return EINA_TRUE;
-}
-#endif
-
-int wakeup_manager_initialize(void)
-{
- MWR_LOGI("[ENTER]");
-
- try {
- g_wakeup_event_observer.reset(new CWakeupEventObserver);
- g_setting_value_observer.reset(new CSettingValueObserver);
- if (NULL == g_wakeup_event_observer || NULL == g_setting_value_observer) {
- return -1;
- }
- g_wakeup_manager.reset(new CWakeupManager(g_wakeup_event_observer.get(), g_setting_value_observer.get()));
- if (NULL == g_wakeup_manager) {
- return -1;
- }
- } catch (const std::exception& e) {
- MWR_LOGE("Exception caught : %s", e.what());
- return -1;
- }
-
- g_wakeup_event_cb = NULL;
- g_wakeup_event_user_data = NULL;
-
- g_utterance_streaming_cb = NULL;
- g_utterance_streaming_user_data = NULL;
-
- g_follow_up_streaming_cb = NULL;
- g_follow_up_streaming_user_data = NULL;
-
- g_speech_status_cb = NULL;
- g_speech_status_user_data = NULL;
-
- g_setting_changed_cb = NULL;
- g_setting_changed_user_data = NULL;
-
- 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_service_state_changed_cb = NULL;
- g_wakeup_service_state_changed_user_data = NULL;
-
- 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]");
-
-#ifdef BUF_SAVE_MODE
- if (g_pFile) {
- fclose(g_pFile);
- g_pFile = NULL;
- } else {
- MWR_LOGD("[Recorder Info] File not found!");
- }
-
- while (1) {
- snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/wakeup_manager_%d_%d", getpid(), g_count);
- int ret = access(g_temp_file_name, 0);
-
- if (0 == ret) {
- MWR_LOGD("[Recorder ERROR] File is already exist");
- if (0 == remove(g_temp_file_name)) {
- MWR_LOGD("[Recorder] Remove file");
- break;
- } else {
- g_count++;
- }
- } else {
- break;
- }
- }
-
- MWR_LOGD("[Recorder] Temp file name=[%s]", g_temp_file_name);
-
- /* open test file */
- g_pFile = fopen(g_temp_file_name, "wb+x");
- if (!g_pFile) {
- MWR_LOGD("[Recorder ERROR] File not found!");
- }
- g_count++;
-#endif
-
-#ifdef BUF_LOAD_MODE
- Ecore_Timer* timer = ecore_timer_add(0.01f, file_read_feed, NULL);
-#endif
- return 0;
-}
-
-int wakeup_manager_deinitialize(void)
-{
- MWR_LOGI("[ENTER]");
-
-#ifdef BUF_SAVE_MODE
- if (g_pFile) {
- MWR_LOGE("[Recorder SUCCESS] File Close");
- fclose(g_pFile);
- g_pFile = NULL;
- }
-#endif
-
- if (nullptr == g_wakeup_manager) return -1;
-
- try {
- g_wakeup_manager->deinitialize();
- g_wakeup_manager.reset();
-
- g_wakeup_event_observer.reset();
- g_setting_value_observer.reset();
- } catch (const std::exception& e) {
- MWR_LOGE("Exception caught : %s", e.what());
- return -1;
- }
-
- MWR_LOGI("[END]");
- return 0;
-}
-
-int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size)
-{
- if (NULL == settings || NULL == struct_size) {
- MWR_LOGD("[ERROR] Parameter is invalid, settings(%p), struct_size(%p)", settings, struct_size);
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- CWakeupSettings* wakeup_settings = g_wakeup_manager->get_wakeup_settings();
- if (wakeup_settings) {
- const int PLUGIN_VERSION = 1;
- static ma_plugin_settings current_settings;
- current_settings.plugin_version = PLUGIN_VERSION;
- current_settings.ui_panel_enabled = wakeup_settings->get_ui_panel_enabled();
- *struct_size = sizeof(current_settings);
- *settings = ¤t_settings;
- }
-
- return 0;
-}
-
-int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == appid || NULL == wakeup_word) {
- MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->add_assistant_wakeup_word(
- string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == appid || NULL == wakeup_word) {
- MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->remove_assistant_wakeup_word(
- string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_add_assistant_language(const char* appid, const char* language)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == appid || NULL == language) {
- MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->add_assistant_language(string{appid}, string{language});
-
- MWR_LOGD("[DEBUG] language(%s)", language);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_add_assistant_wakeup_engine(const char* appid, const char* engine)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == appid || NULL == engine) {
- MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup engine(%s)", appid, engine);
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- MWR_LOGD("[DEBUG] appid(%s), wakeup engine(%s)", appid, engine);
- g_wakeup_manager->add_assistant_wakeup_engine(string{appid}, string{engine});
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_default_assistant(const char* appid)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == appid) {
- MWR_LOGD("[ERROR] Parameter is NULL");
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- MWR_LOGD("[DEBUG] default_assistant appid(%s)", appid);
- g_wakeup_manager->set_default_assistant(string{appid});
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_get_default_assistant(const char** appid)
-{
- static string default_assistant;
-
- if (nullptr == g_wakeup_manager) return -1;
- default_assistant = g_wakeup_manager->get_default_assistant();
-
- if (default_assistant.empty()) {
- *appid = nullptr;
- } else {
- *appid = default_assistant.c_str();
- }
- return 0;
-}
-
-int wakeup_manager_set_language(const char* language)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == language) {
- MWR_LOGD("[ERROR] Parameter is NULL");
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_language(string{language});
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_change_state(wakeup_manager_state_e state)
-{
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->change_manager_state(state);
- return 0;
-}
-
-int wakeup_manager_activate(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->activate();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_deactivate(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->deactivate();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_update_voice_feedback_state(const char* appid, int state)
-{
- MWR_LOGI("[ENTER]");
-
- string appid_string;
- if (NULL == appid) {
- MWR_LOGD("[ERROR] Parameter is NULL");
- } else {
- appid_string = appid;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->update_voice_feedback_state(appid_string, state);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_assistant_specific_command(const char* appid, const char* command)
-{
- MWR_LOGI("[ENTER]");
-
- string appid_string;
- string command_string;
- if (NULL == appid || NULL == command) {
- MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), command(%s)", appid, command);
- }
- if (appid) appid_string = appid;
- if (command) command_string = command;
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_assistant_specific_command(appid_string, command_string);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_background_volume(const char* appid, double ratio)
-{
- MWR_LOGI("[ENTER]");
-
- string appid_string;
- if (NULL == appid) {
- MWR_LOGD("[ERROR] Parameter is NULL");
- } else {
- appid_string = appid;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_background_volume(appid_string, ratio);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_update_recognition_result(const char* appid, int result)
-{
- MWR_LOGI("[ENTER]");
-
- string appid_string;
- if (NULL == appid) {
- MWR_LOGD("[ERROR] Parameter is NULL");
- } else {
- appid_string = appid;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->update_recognition_result(appid_string, result);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_process_plugin_event(mas_plugin_event_e event, void* data, int len)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->process_plugin_event(event, data, len);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_start_streaming_utterance_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->start_streaming_utterance_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_stop_streaming_utterance_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->stop_streaming_utterance_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_start_streaming_follow_up_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->start_streaming_follow_up_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_stop_streaming_follow_up_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->stop_streaming_follow_up_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_start_streaming_previous_utterance_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->start_streaming_previous_utterance_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_stop_streaming_previous_utterance_data(void)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->stop_streaming_previous_utterance_data();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_get_audio_format(int* rate, int* channel, int* audio_type)
-{
- MWR_LOGI("[ENTER]");
-
- if (!audio_type || !rate || !channel) {
- MWR_LOGE("[ERROR] Invalid parameter");
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->get_audio_format(rate, channel, audio_type);
-
- MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
- return 0;
-}
-
-int wakeup_manager_get_audio_source_type(char** type)
-{
- MWR_LOGI("[ENTER]");
-
- if (!type) {
- MWR_LOGE("[ERROR] Invalid parameter");
- return -1;
- }
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->get_audio_source_type(type);
-
- MWR_LOGD("[END] type(%s)", *type);
- return 0;
-}
-
-int wakeup_manager_set_voice_key_tap_duration(float duration)
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_voice_key_tap_duration(duration);
-
- MWR_LOGD("[END] duration(%f)", duration);
- return 0;
-}
-
-int wakeup_manager_unset_voice_key_tap_duration()
-{
- MWR_LOGI("[ENTER]");
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->unset_voice_key_tap_duration();
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_voice_key_support_mode(int mode)
-{
- MWR_LOGI("[ENTER] : %d", mode);
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_voice_key_support_mode(static_cast<VOICE_KEY_SUPPORT_MODE>(mode));
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_wake_word_audio_require_flag(bool require)
-{
- MWR_LOGI("[ENTER] : %d", require);
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_wake_word_audio_require_flag(require);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_assistant_language(const char* appid, const char* language)
-{
- MWR_LOGI("[ENTER]");
-
- string appid_string;
- string language_string;
- if (NULL == appid || NULL == language) {
- MWR_LOGE("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
- return -1;
- }
- appid_string = appid;
- language_string = language;
-
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_assistant_language(appid_string, language_string);
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_wakeup_event_cb = callback;
- g_wakeup_event_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_utterance_streaming_cb = callback;
- g_utterance_streaming_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_previous_utterance_streaming_cb = callback;
- g_previous_utterance_streaming_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_follow_up_streaming_cb = callback;
- g_follow_up_streaming_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_speech_status_cb = callback;
- g_speech_status_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_setting_changed_cb = callback;
- g_setting_changed_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_error_cb = callback;
- g_error_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_streaming_section_changed_cb = callback;
- g_streaming_section_changed_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data)
-{
- MWR_LOGI("[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_set_wakeup_service_state_changed_callback(wakeup_service_state_changed_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_wakeup_service_state_changed_cb = callback;
- g_wakeup_service_state_changed_user_data = user_data;
-
- MWR_LOGD("[END]");
- return 0;
-}
-
-int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data)
-{
- MWR_LOGI("[ENTER]");
-
- if (NULL == callback) {
- MWR_LOGE("[ERROR] Input parameter is NULL");
- return -1;
- }
-
- g_wakeup_service_voice_key_status_changed_cb = callback;
- g_wakeup_service_voice_key_status_changed_user_data = user_data;
-
- MWR_LOGD("[END]");
- 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;
-
-#ifdef BUF_SAVE_MODE
- static int num = 0;
- const int MAXIMUM_NUM = 1000;
- if (g_pFile && num++ < MAXIMUM_NUM)
- fwrite(buffer, 1, len, g_pFile);
-#endif
-
- g_wakeup_manager->feed_audio_data(event, buffer, len);
-
- return 0;
-}
-
-int wakeup_manager_set_dependency_module_command(const char* engine_name, const char* command)
-{
- if (nullptr == g_wakeup_manager) return -1;
- g_wakeup_manager->set_dependency_module_command(
- engine_name ? engine_name : "",
- command ? command : "");
- return 0;
-}
-
-int wakeup_manager_wakeup_assistant(const mas_wakeup_event_info* wakeup_info)
-{
- if (nullptr == g_wakeup_manager) return -1;
- CWakeupPolicy* policy = g_wakeup_manager->get_wakeup_policy();
- if (policy) policy->select_candidate(*wakeup_info);
- return 0;
-}
-
-void CWakeupEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
-{
- if (NULL != g_wakeup_event_cb) {
- g_wakeup_event_cb(wakeup_info, g_wakeup_event_user_data);
- }
-}
-
-void CWakeupEventObserver::on_streaming_audio_data(
- mas_speech_streaming_event_e event, void* buffer, unsigned int len)
-{
- if (MAS_SPEECH_STREAMING_EVENT_START == event) {
- MWR_LOGI("streaming_cb START");
- }
- if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
- MWR_LOGI("streaming_cb FINISH");
- }
- if (NULL != g_utterance_streaming_cb) {
- g_utterance_streaming_cb(event, buffer, len, g_utterance_streaming_user_data);
- } else {
- MWR_LOGI("[INFO] No service streaming callback");
- }
-}
-
-void CWakeupEventObserver::on_audio_streaming_data_section(
- ma_audio_streaming_data_section_e section)
-{
- if (g_streaming_section_changed_cb) {
- g_streaming_section_changed_cb(section, g_streaming_section_changed_user_data);
- }
-}
-
-void CWakeupEventObserver::on_wakeup_engine_command(
- mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command)
-{
- if (g_wakeup_engine_command_cb) {
- g_wakeup_engine_command_cb(target, assistant_name, command, g_wakeup_engine_command_user_data);
- }
-}
-
-void CWakeupEventObserver::on_wakeup_service_state_changed(ma_service_state_e state)
-{
- if (g_wakeup_service_state_changed_cb) {
- g_wakeup_service_state_changed_cb(state, g_wakeup_service_state_changed_user_data);
- }
-}
-
-void CWakeupEventObserver::on_voice_key_status_changed(ma_voice_key_status_e status)
-{
- if (g_wakeup_service_voice_key_status_changed_cb) {
- g_wakeup_service_voice_key_status_changed_cb(status, g_wakeup_service_voice_key_status_changed_user_data);
- }
-}
-
-void CSettingValueObserver::on_value_changed()
-{
- if (g_setting_changed_cb) {
- 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);
- }
-}
+++ /dev/null
-#include "wakeup_policy.h"
-#include "wakeup_policy_impl.h"
-
-#include <vector>
-#include <algorithm>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-void CWakeupPolicyImpl::subscribe(IPolicyEventObserver *observer)
-{
- mObservers.push_back(observer);
-}
-
-void CWakeupPolicyImpl::unsubscribe(IPolicyEventObserver *observer)
-{
- auto iter = find(mObservers.begin(), mObservers.end(), observer);
- if (iter != mObservers.end()) {
- mObservers.erase(iter);
- }
-}
-
-void CWakeupPolicyImpl::wakeup(mas_wakeup_event_info wakeup_info)
-{
- for (const auto& observer : mObservers) {
- if (observer) {
- observer->on_wakeup(wakeup_info);
- }
- }
-}
-
-CWakeupPolicy::CWakeupPolicy()
-{
- mImpl.reset(new CWakeupPolicyImpl);
-}
-
-CWakeupPolicy::~CWakeupPolicy()
-{
-}
-
-CWakeupPolicy::CWakeupPolicy(IPolicyEventObserver *observer) : CWakeupPolicy()
-{
- subscribe(observer);
-}
-
-void CWakeupPolicy::subscribe(IPolicyEventObserver *observer)
-{
- if (mImpl) mImpl->subscribe(observer);
-}
-
-void CWakeupPolicy::unsubscribe(IPolicyEventObserver *observer)
-{
- if (mImpl) mImpl->unsubscribe(observer);
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-#include "wakeup_policy_default.h"
-#include "wakeup_policy_impl.h"
-#include "wakeup_manager_main.h"
-
-#include <vector>
-
-#include <Eina.h>
-#include <dlog.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-CWakeupPolicyDefault::CWakeupPolicyDefault(IPolicyEventObserver *observer)
- : CWakeupPolicy(observer)
-{
-}
-
-CWakeupPolicyDefault::~CWakeupPolicyDefault()
-{
- if (mTimer) {
- ecore_timer_del(mTimer);
- mTimer = nullptr;
- }
-}
-
-bool CWakeupPolicyDefault::valid()
-{
- return true;
-}
-
-void CWakeupPolicyDefault::set_assistant_priority(string appid, int priority)
-{
- PRIORITY_INFO info;
- info.appid = appid;
- info.priority = priority;
-
- MWR_LOGD("Setting assistant priority : %s %d", appid.c_str(), priority);
- mPriorityInfos.push_back(info);
-}
-
-void CWakeupPolicyDefault::set_delay(float seconds)
-{
- MWR_LOGD("Setting delay : %f", seconds);
- mDelaySeconds = seconds;
-}
-
-float CWakeupPolicyDefault::get_delay()
-{
- return mDelaySeconds;
-}
-
-void CWakeupPolicyDefault::set_timer(Ecore_Timer* timer)
-{
- mTimer = timer;
-}
-
-Ecore_Timer* CWakeupPolicyDefault::get_timer()
-{
- return mTimer;
-}
-
-static Eina_Bool timer_func(void *data)
-{
- MWR_LOGD("[ENTER]");
- if (data) {
- CWakeupPolicyDefault *policy = static_cast<CWakeupPolicyDefault*>(data);
- policy->timer_expired();
- policy->set_timer(nullptr);
- }
- return ECORE_CALLBACK_CANCEL;
-}
-
-void CWakeupPolicyDefault::wakeup_candidate(mas_wakeup_event_info wakeup_info)
-{
- MWR_LOGI("[ENTER]");
- mas_wakeup_event_info_wrapper wrapper;
- wrapper.info = wakeup_info;
- if (wakeup_info.wakeup_appid) wrapper.wakeup_appid = wakeup_info.wakeup_appid;
- if (wakeup_info.wakeup_word) wrapper.wakeup_word = wakeup_info.wakeup_word;
- if (wakeup_info.wakeup_language) wrapper.wakeup_language = wakeup_info.wakeup_language;
- if (wakeup_info.wakeup_voice_id) wrapper.wakeup_voice_id = wakeup_info.wakeup_voice_id;
- 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;
-
- 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);
- if (nullptr == mTimer) {
- ecore_main_loop_thread_safe_call_async([](void* data) {
- /* Assume that choosing the first wakeup event is the default behavior */
- timer_func(data);
- }, this);
- }
-}
-
-void CWakeupPolicyDefault::select_candidate(mas_wakeup_event_info wakeup_info)
-{
- MWR_LOGE("Default wakeup policy does not support selecting candidate");
-}
-
-void CWakeupPolicyDefault::timer_expired()
-{
- MWR_LOGD("[ENTER]");
- if (0 == mWakeupInfos.size()) return;
-
- mas_wakeup_event_info_wrapper selected = mWakeupInfos.front();
- LOGD("wake word : %s", selected.wakeup_word.c_str());
- int selected_priority = -1;
- for (const auto &wakeup : mWakeupInfos) {
- for (const auto &info : mPriorityInfos) {
- if (0 == info.appid.compare(wakeup.wakeup_appid)) {
- if (info.priority > selected_priority || -1 == selected_priority) {
- MWR_LOGD("Wakeup with higher priority found : %s, %d",
- info.appid.c_str(), info.priority);
- selected = wakeup;
- selected_priority = info.priority;
- }
- }
- }
- }
- selected.info.wakeup_appid = selected.wakeup_appid.c_str();
- selected.info.wakeup_word = selected.wakeup_word.c_str();
- 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);
- mWakeupInfos.clear();
-
- if (mTimer) {
- MWR_LOGD("Now deleting timer");
- ecore_timer_del(mTimer);
- mTimer = nullptr;
- }
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-#include "wakeup_policy_external.h"
-#include "wakeup_policy_impl.h"
-
-#include "dependency_resolver.h"
-
-#include <dlog.h>
-
-#ifndef LOG_TAG
-#define LOG_TAG "WakeupPolicyExternal"
-#endif
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-CWakeupPolicyExternal::CWakeupPolicyExternal(IPolicyEventObserver *observer)
- : CWakeupPolicy(observer)
-{
-}
-
-CWakeupPolicyExternal::~CWakeupPolicyExternal()
-{
-}
-
-bool CWakeupPolicyExternal::valid()
-{
- bool ret = false;
- mas_dependency_module_interface* interface = dependency_resolver_get_interface();
- if (interface) {
- if (interface->process_wakeup_candidate) {
- ret = true;
- }
- }
- return ret;
-}
-
-void CWakeupPolicyExternal::wakeup_candidate(mas_wakeup_event_info wakeup_info)
-{
- dependency_resolver_process_wakeup_candidate(&wakeup_info);
-}
-
-void CWakeupPolicyExternal::select_candidate(mas_wakeup_event_info wakeup_info)
-{
- if (mImpl) mImpl->wakeup(wakeup_info);
-}
-
-} // wakeup
-} // multiassistant
+++ /dev/null
-#include "wakeup_settings.h"
-#include "wakeup_manager_main.h"
-
-#include <sstream>
-#include <algorithm>
-#include <json/json.h>
-
-namespace multiassistant
-{
-namespace wakeup
-{
-
-/* Utility function for checking if an element exists in a container */
-template<class C, class T>
-static auto contains(const C& v, const T& x) -> decltype(end(v), true)
-{
- return end(v) != find(begin(v), end(v), x);
-}
-
-static string prev_wake_word_enabled;
-
-CWakeupSettings::CWakeupSettings()
-{
-}
-
-CWakeupSettings::~CWakeupSettings()
-{
-}
-
-static void wakeup_setting_input_language_changed_cb(keynode_t* node, void* data)
-{
- MWR_LOGD("[ENTER]");
- if (nullptr == node) return;
-
- CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
- if (nullptr == settings) return;
-
- if (VCONF_TYPE_STRING == node->type) {
- const char* value = static_cast<const char*>(node->value.s);
- const auto& observers = settings->get_observers();
- for (const auto& observer : observers) {
- if (observer) {
- if (!observer->on_voice_input_language_changed(value)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- } else {
- LOGE("[Settings ERROR] the value type is not string : %d", node->type);
- }
-}
-
-static void wakeup_setting_streaming_duration_max_changed_cb(keynode_t* node, void* data)
-{
- MWR_LOGD("[ENTER]");
- if (nullptr == node) return;
-
- CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
- if (nullptr == settings) return;
-
- if (VCONF_TYPE_DOUBLE == node->type) {
- double value = static_cast<double>(node->value.d);
- settings->set_streaming_duration_max(static_cast<float>(value));
- } else {
- LOGE("[Settings ERROR] the value type is not string : %d", node->type);
- }
-}
-
-
-static void wakeup_setting_enabled_assistants_changed_cb(keynode_t* node, void* data)
-{
- MWR_LOGD("[ENTER]");
- if (nullptr == node) return;
-
- CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
- if (nullptr == settings) return;
-
- if (VCONF_TYPE_STRING == node->type) {
- vector<string> newlyAddedAssistants;
- vector<string> newlyRemovedAssistants;
- const char* value = static_cast<const char*>(node->value.s);
- if (value) {
- vector<string> previouslyEnabledAssistants = settings->get_enabled_assistants();
- vector<string> currentlyEnabledAssistants;
- string token;
- istringstream iss(value);
- currentlyEnabledAssistants.clear();
- while (getline(iss, token, ';')) {
- currentlyEnabledAssistants.push_back(token);
- MWR_LOGD("enabled_assistants : %s", token.c_str());
- }
-
- for (const auto& assistant : currentlyEnabledAssistants) {
- if (!contains(previouslyEnabledAssistants, assistant)) {
- newlyAddedAssistants.push_back(assistant);
- }
- }
- for (const auto& assistant : previouslyEnabledAssistants) {
- if (!contains(currentlyEnabledAssistants, assistant)) {
- newlyRemovedAssistants.push_back(assistant);
- }
- }
- }
-
- const auto& observers = settings->get_observers();
- for (const auto& observer : observers) {
- if (observer) {
- for (const auto& assistant : newlyAddedAssistants) {
- if (!observer->on_assistant_enabled_info_changed(assistant.c_str(), true)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- for (const auto& assistant : newlyRemovedAssistants) {
- if (!observer->on_assistant_enabled_info_changed(assistant.c_str(), false)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- }
- } else {
- LOGE("[Settings ERROR] the value type is not string : %d", node->type);
- }
-}
-
-static void wakeup_setting_default_assistant_appid_changed_cb(keynode_t* node, void* data)
-{
- MWR_LOGD("[ENTER]");
- if (nullptr == node) return;
-
- CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
- if (nullptr == settings) return;
-
- if (VCONF_TYPE_STRING == node->type) {
- const char* value = static_cast<const char*>(node->value.s);
- const auto& observers = settings->get_observers();
- for (const auto& observer : observers) {
- if (observer) {
- if (!observer->on_default_assistant_appid_changed(value)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- } else {
- LOGE("[Settings ERROR] the value type is not string : %d", node->type);
- }
-}
-
-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");
- }
- }
- }
-}
-
-static void wakeup_setting_enabled_wake_word_detection_changed_cb(keynode_t* node, void* data)
-{
- MWR_LOGD("[ENTER]");
-
- char *vconf_str = vconf_keynode_get_str(node);
- if (!vconf_str) return;
-
- MWR_LOGI("vconf value : %s", vconf_str);
- if (0 == prev_wake_word_enabled.compare(string(vconf_str))) {
- return;
- }
-
- prev_wake_word_enabled = string(vconf_str);
-
- 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_wake_word_detection_enabled_info_changed()) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
-}
-
-void CWakeupSettings::initialize(map<string, string> custom_keys)
-{
- int vconf_ret;
- int vconf_bool;
- double vconf_double;
-
- mCustomVconfKeys.clear();
- mCustomVconfKeys = custom_keys;
-
- char *default_assistant_appid = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str());
- if (default_assistant_appid) {
- mDefaultAssistantAppid = default_assistant_appid;
- MWR_LOGD("default_assistant_appid : %s", mDefaultAssistantAppid.c_str());
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_default_assistant_appid_changed(default_assistant_appid)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- free(default_assistant_appid);
- default_assistant_appid = nullptr;
- }
- vconf_ret = vconf_get_bool(WAKEUP_SETTINGS_KEY_UI_PANEL_ENABLED, &vconf_bool);
- if (0 == vconf_ret) {
- mUiPanelEnabled = vconf_bool;
- MWR_LOGD("ui_panel_enabled : %s", (mUiPanelEnabled ? "true" : "false"));
- }
- vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_CONVERSATION_TIMEOUT, &vconf_double);
- if (0 == vconf_ret) {
- mConversationTimeout = vconf_double;
- MWR_LOGD("conversation_timeout : %f", mConversationTimeout);
- }
- vconf_ret = vconf_get_bool(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE, &vconf_bool);
- if (0 == vconf_ret) {
- mMultipleMode = vconf_bool;
- MWR_LOGD("multiple_mode : %s", (mMultipleMode ? "true" : "false"));
- }
- if (true == mMultipleMode) {
- char *enabled_assistants = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str());
- if (enabled_assistants) {
- string token;
- istringstream iss(enabled_assistants);
- mEnabledAssistants.clear();
- while (getline(iss, token, ';')) {
- mEnabledAssistants.push_back(token);
- MWR_LOGD("enabled_assistants : %s", token.c_str());
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_assistant_enabled_info_changed(token.c_str(), true)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- }
- free(enabled_assistants);
- enabled_assistants = nullptr;
- }
- }
- char *wakeword_detection_enabled = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str());
- if (wakeword_detection_enabled) {
- Json::Reader reader;
- Json::Value root;
- mWakeWordDisabledAssistants.clear();
- if (!reader.parse(wakeword_detection_enabled, root)) {
- LOGW("[Settings WARNING] Failed to parse Json : %s", reader.getFormattedErrorMessages().c_str());
- } else {
- auto member = root.getMemberNames();
- for (string m : member) {
- if (0 == root[m].asString().compare("off")) {
- mWakeWordDisabledAssistants.push_back(m);
- MWR_LOGD("wake_word_detection_disabled assistant : %s", m.c_str());
- }
- }
- }
- free(wakeword_detection_enabled);
- wakeword_detection_enabled = nullptr;
- }
- vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_DELAY, &vconf_double);
- if (0 == vconf_ret) {
- mWakeupPolicyDelay = vconf_double;
- MWR_LOGD("conversation_timeout : %f", mWakeupPolicyDelay);
- }
- char *wakeup_policy_priority = vconf_get_str(WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_PRIORITY);
- if (wakeup_policy_priority) {
- string token;
- istringstream iss(wakeup_policy_priority);
- mWakeupPolicyPriority.clear();
- while (getline(iss, token, ';')) {
- mWakeupPolicyPriority.push_back(token);
- MWR_LOGD("wakeup_policy_priority : %s", token.c_str());
- }
- free(wakeup_policy_priority);
- wakeup_policy_priority = nullptr;
- }
- vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX, &vconf_double);
- if (0 == vconf_ret) {
- mStreamingDurationMax = vconf_double;
- MWR_LOGD("streaming_duration_max : %f", mStreamingDurationMax);
- }
-#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
- char *voice_input_language = vconf_get_str(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE);
- if (voice_input_language) {
- mVoiceInputLanguage = voice_input_language;
- MWR_LOGD("voice input language : %s", mVoiceInputLanguage.c_str());
- for (const auto& observer : mObservers) {
- if (observer) {
- if (!observer->on_voice_input_language_changed(voice_input_language)) {
- LOGW("[Settings WARNING] One of the observer returned false");
- }
- }
- }
- free(voice_input_language);
- voice_input_language = nullptr;
- }
-#endif
-
-#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
- vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE,
- wakeup_setting_input_language_changed_cb, this);
-#endif
- vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX,
- wakeup_setting_streaming_duration_max_changed_cb, this);
- vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(),
- wakeup_setting_default_assistant_appid_changed_cb, this);
- if (true == mMultipleMode) {
- vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str(),
- wakeup_setting_enabled_assistants_changed_cb, this);
- }
- vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
- wakeup_setting_multiple_mode_changed_cb, this);
- vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str(),
- wakeup_setting_enabled_wake_word_detection_changed_cb, this);
-}
-
-void CWakeupSettings::deinitialize()
-{
-#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
- vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE,
- wakeup_setting_input_language_changed_cb);
-#endif
- vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX,
- wakeup_setting_streaming_duration_max_changed_cb);
- vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(),
- wakeup_setting_default_assistant_appid_changed_cb);
- if (true == mMultipleMode) {
- vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str(),
- wakeup_setting_enabled_assistants_changed_cb);
- }
- vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
- wakeup_setting_multiple_mode_changed_cb);
- vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str(),
- wakeup_setting_enabled_wake_word_detection_changed_cb);
-}
-
-void CWakeupSettings::subscribe(ISettingsEventObserver *observer)
-{
- mObservers.push_back(observer);
-}
-
-void CWakeupSettings::unsubscribe(ISettingsEventObserver *observer)
-{
- auto iter = find(mObservers.begin(), mObservers.end(), observer);
- if (iter != mObservers.end()) {
- mObservers.erase(iter);
- }
-}
-
-const vector<ISettingsEventObserver*>& CWakeupSettings::get_observers()
-{
- return mObservers;
-}
-
-string CWakeupSettings::get_default_assistant_appid()
-{
- char *vconf_str;
- vconf_str = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str());
- MWR_LOGD("vconf default_assistant_appid : %s", vconf_str);
- if (vconf_str) {
- mDefaultAssistantAppid = vconf_str;
- MWR_LOGD("member default_assistant_appid : %s", mDefaultAssistantAppid.c_str());
- free(vconf_str);
- vconf_str = nullptr;
- }
-
- return mDefaultAssistantAppid;
-}
-
-void CWakeupSettings::set_default_assistant_appid(std::string appid)
-{
- if (appid.empty()) {
- MWR_LOGE("appid is NULL");
- return;
- }
- if (appid.compare(get_default_assistant_appid()) == 0) {
- MWR_LOGE("Default assistant appid not changed, ignoring...");
- return;
- }
- int ret = vconf_set_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(), appid.c_str());
- MWR_LOGD("default_assistant_appid : %s, %d", appid.c_str(), ret);
- mDefaultAssistantAppid = appid;
-}
-
-bool CWakeupSettings::get_ui_panel_enabled()
-{
- return mUiPanelEnabled;
-}
-
-float CWakeupSettings::get_conversation_timeout()
-{
- return mConversationTimeout;
-}
-
-bool CWakeupSettings::get_multiple_mode()
-{
- return mMultipleMode;
-}
-
-vector<string> CWakeupSettings::get_enabled_assistants()
-{
- return mEnabledAssistants;
-}
-
-float CWakeupSettings::get_wakeup_policy_delay()
-{
- return mWakeupPolicyDelay;
-}
-
-vector<string> CWakeupSettings::get_wakeup_policy_priority()
-{
- return mWakeupPolicyPriority;
-}
-
-float CWakeupSettings::get_streaming_duration_max()
-{
- return mStreamingDurationMax;
-}
-
-void CWakeupSettings::set_streaming_duration_max(float duration)
-{
- MWR_LOGE("Setting Streaming Duration Max Value : %f", duration);
- mStreamingDurationMax = duration;
-}
-
-std::string CWakeupSettings::get_current_language(void)
-{
- std::string result{"en_US"};
-
-#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
- char* language = vconf_get_str(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE);
- if (language) {
- result = language;
- free(language);
- }
-#endif
-
- return result;
-}
-
-vector<string> CWakeupSettings::get_wake_word_disabled_assistants()
-{
- return mWakeWordDisabledAssistants;
-}
-
-} // wakeup
-} // multiassistant
{
MAS_LOGD("[Enter]");
- char filepath[512] = {'\0', };
- const char *default_engine_path = MA_WAKEUP_MANAGER_PATH;
- snprintf(filepath, 512, "%s/%s", default_engine_path, MA_DEFAULT_WAKEUP_MANAGER_FILENAME);
-
- char *error;
- mPluginHandle = nullptr;
- mPluginHandle = dlopen(filepath, RTLD_LAZY);
- if (nullptr != (error = dlerror())) {
- MAS_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", filepath, error);
- if (mPluginHandle) dlclose(mPluginHandle);
- mPluginHandle = nullptr;
- return -1; //MAS_ERROR_OPERATION_FAILED;
- }
- if (nullptr == mPluginHandle) {
- MAS_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", filepath, error);
- return -1; //MAS_ERROR_OPERATION_FAILED;
- }
-
- mWakeupManagerInterface.initialize =
- (wakeup_manager_initialize)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_INITIALIZE);
- mWakeupManagerInterface.deinitialize =
- (wakeup_manager_deinitialize)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_DEINITIALIZE);
- mWakeupManagerInterface.get_settings =
- (wakeup_manager_get_settings)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_GET_SETTINGS);
- mWakeupManagerInterface.add_assistant_wakeup_word =
- (wakeup_manager_add_assistant_wakeup_word)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_WORD);
- mWakeupManagerInterface.remove_assistant_wakeup_word =
- (wakeup_manager_remove_assistant_wakeup_word)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_REMOVE_ASSISTANT_WAKEUP_WORD);
- mWakeupManagerInterface.add_assistant_language =
- (wakeup_manager_add_assistant_language)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_LANGUAGE);
- mWakeupManagerInterface.add_assistant_wakeup_engine =
- (wakeup_manager_add_assistant_wakeup_engine)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_ENGINE);
- mWakeupManagerInterface.set_default_assistant =
- (wakeup_manager_set_default_assistant)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_DEFAULT_ASSISTANT);
- mWakeupManagerInterface.get_default_assistant =
- (wakeup_manager_get_default_assistant)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_GET_DEFAULT_ASSISTANT);
- mWakeupManagerInterface.set_language =
- (wakeup_manager_set_language)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_LANGUAGE);
- mWakeupManagerInterface.activate =
- (wakeup_manager_activate)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_ACTIVATE);
- mWakeupManagerInterface.deactivate =
- (wakeup_manager_deactivate)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_DEACTIVATE);
- mWakeupManagerInterface.update_voice_feedback_state =
- (wakeup_manager_update_voice_feedback_state)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_UPDATE_VOICE_FEEDBACK_STATE);
- mWakeupManagerInterface.set_assistant_specific_command =
- (wakeup_manager_set_assistant_specific_command)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND);
- mWakeupManagerInterface.set_background_volume =
- (wakeup_manager_set_background_volume)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_BACKGROUND_VOLUME);
- mWakeupManagerInterface.update_recognition_result =
- (wakeup_manager_update_recognition_result)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_UPDATE_RECOGNITION_RESULT);
- mWakeupManagerInterface.process_plugin_event =
- (wakeup_manager_process_plugin_event)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_PROCESS_PLUGIN_EVENT);
- mWakeupManagerInterface.start_streaming_utterance_data =
- (wakeup_manager_start_streaming_utterance_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_START_STREAMING_UTTERANCE_DATA);
- mWakeupManagerInterface.stop_streaming_utterance_data =
- (wakeup_manager_stop_streaming_utterance_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_UTTERANCE_DATA);
- mWakeupManagerInterface.start_streaming_previous_utterance_data =
- (wakeup_manager_start_streaming_previous_utterance_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_START_STREAMING_PREVIOUS_UTTERANCE_DATA);
- mWakeupManagerInterface.stop_streaming_previous_utterance_data =
- (wakeup_manager_stop_streaming_previous_utterance_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_PREVIOUS_UTTERANCE_DATA);
- mWakeupManagerInterface.start_streaming_follow_up_data =
- (wakeup_manager_start_streaming_follow_up_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_START_STREAMING_FOLLOW_UP_DATA);
- mWakeupManagerInterface.stop_streaming_follow_up_data =
- (wakeup_manager_stop_streaming_follow_up_data)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_FOLLOW_UP_DATA);
- mWakeupManagerInterface.get_audio_format =
- (wakeup_manager_get_audio_format)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_FORMAT);
- mWakeupManagerInterface.get_audio_source_type =
- (wakeup_manager_get_audio_source_type)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_SOURCE_TYPE);
- mWakeupManagerInterface.set_wake_word_audio_require_flag =
- (wakeup_manager_set_wake_word_audio_require_flag)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG);
- mWakeupManagerInterface.set_assistant_language =
- (wakeup_manager_set_assistant_language)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_LANGUAGE);
- mWakeupManagerInterface.set_voice_key_tap_duration =
- (wakeup_manager_set_voice_key_tap_duration)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_TAP_DURATION);
- mWakeupManagerInterface.unset_voice_key_tap_duration =
- (wakeup_manager_unset_voice_key_tap_duration)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
- mWakeupManagerInterface.set_voice_key_support_mode =
- (wakeup_manager_set_voice_key_support_mode)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
- mWakeupManagerInterface.set_wakeup_event_callback =
- (wakeup_manager_set_wakeup_event_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_EVENT_CALLBACK);
- mWakeupManagerInterface.set_utterance_streaming_callback =
- (wakeup_manager_set_utterance_streaming_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_UTTERANCE_STREAMING_CALLBACK);
- mWakeupManagerInterface.set_previous_utterance_streaming_callback =
- (wakeup_manager_set_previous_utterance_streaming_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_PREVIOUS_UTTERANCE_STREAMING_CALLBACK);
- mWakeupManagerInterface.set_follow_up_streaming_callback =
- (wakeup_manager_set_follow_up_streaming_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_FOLLOW_UP_STREAMING_CALLBACK);
- mWakeupManagerInterface.set_speech_status_callback =
- (wakeup_manager_set_speech_status_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_SPEECH_STATUS_CALLBACK);
- mWakeupManagerInterface.set_setting_changed_callback =
- (wakeup_manager_set_setting_changed_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_SETTING_CHANGED_CALLBACK);
- mWakeupManagerInterface.set_error_callback =
- (wakeup_manager_set_error_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_ERROR_CALLBACK);
- mWakeupManagerInterface.set_streaming_section_changed_callback =
- (wakeup_manager_set_streaming_section_changed_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_STREAMING_SECTION_CHANGED_CALLBACK);
- mWakeupManagerInterface.set_wakeup_engine_command_callback =
- (wakeup_manager_set_wakeup_engine_command_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_ENGINE_COMMAND_CALLBACK);
- mWakeupManagerInterface.set_wakeup_service_state_changed_callback =
- (wakeup_manager_set_wakeup_service_state_changed_callback)dlsym(mPluginHandle,
- MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_SERVICE_STATE_CHANGED_CALLBACK);
- 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) {
- wakeup_manager_initialize func = mWakeupManagerInterface.initialize;
-
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_INITIALIZE);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to initialize, ret(%d)", ret);
- }
- }
-
- wakeup_manager_get_settings get_settings_func = mWakeupManagerInterface.get_settings;
+ ret = wakeup_manager_initialize();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to initialize, ret(%d)", ret);
+ return ret;
+ }
- if (NULL == get_settings_func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_GET_SETTINGS);
- } else {
- size_t struct_size;
- ret = get_settings_func(&mPluginSettings, &struct_size);
- if (0 != ret || struct_size != sizeof(ma_plugin_settings)) {
- MAS_LOGE("[ERROR] Fail to get settings, ret(%d), size %zu", ret, struct_size);
- mPluginSettings = NULL;
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ size_t struct_size;
+ ret = wakeup_manager_get_settings(&mPluginSettings, &struct_size);
+ if (0 != ret || struct_size != sizeof(ma_plugin_settings)) {
+ MAS_LOGE("[ERROR] Fail to get settings, ret(%d), size %zu", ret, struct_size);
+ mPluginSettings = NULL;
}
+
return ret;
}
}
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_deinitialize func = mWakeupManagerInterface.deinitialize;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_DEINITIALIZE);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to deinitialize, ret(%d)", ret);
- }
- }
-
- dlclose(mPluginHandle);
- mPluginHandle = NULL;
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_deinitialize();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to deinitialize, ret(%d)", ret);
}
return ret;
int CServicePlugin::get_settings(ma_plugin_settings **settings, size_t *struct_size)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_get_settings func = mWakeupManagerInterface.get_settings;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_GET_SETTINGS);
- } else {
- ret = func(settings, struct_size);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get settings, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_get_settings(settings, struct_size);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get settings, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_language(const char* language)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_language func = mWakeupManagerInterface.set_language;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_LANGUAGE);
- } else {
- ret = func(language);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set langauge(%s), ret(%d)", language, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_language(language);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set langauge(%s), ret(%d)", language, ret);
}
return ret;
}
int CServicePlugin::add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_add_assistant_wakeup_word func = mWakeupManagerInterface.add_assistant_wakeup_word;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_WORD);
- } else {
- ret = func(appid, wakeup_word, language);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to add wakeup word(%s)(%s)(%s), ret(%d)", appid, wakeup_word, language, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_add_assistant_wakeup_word(appid, wakeup_word, language);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to add wakeup word(%s)(%s)(%s), ret(%d)", appid, wakeup_word, language, ret);
}
return ret;
}
int CServicePlugin::remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_remove_assistant_wakeup_word func = mWakeupManagerInterface.remove_assistant_wakeup_word;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_REMOVE_ASSISTANT_WAKEUP_WORD);
- } else {
- ret = func(appid, wakeup_word, language);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to remove wakeup word(%s)(%s)(%s), ret(%d)", appid, wakeup_word, language, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_remove_assistant_wakeup_word(appid, wakeup_word, language);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to remove wakeup word(%s)(%s)(%s), ret(%d)", appid, wakeup_word, language, ret);
}
return ret;
}
int CServicePlugin::add_assistant_language(const char* appid, const char* language)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_add_assistant_language func = mWakeupManagerInterface.add_assistant_language;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_LANGUAGE);
- } else {
- ret = func(appid, language);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set wakeup word(%s)(%s), ret(%d)", appid, language, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_add_assistant_language(appid, language);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set wakeup word(%s)(%s), ret(%d)", appid, language, ret);
}
return ret;
}
int CServicePlugin::add_assistant_wakeup_engine(const char* appid, const char* engine)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_add_assistant_wakeup_engine func = mWakeupManagerInterface.add_assistant_wakeup_engine;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_ADD_ASSISTANT_WAKEUP_ENGINE);
- } else {
- ret = func(appid, engine);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set wakeup engine(%s)(%s), ret(%d)", appid, engine, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_add_assistant_wakeup_engine(appid, engine);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set wakeup engine(%s)(%s), ret(%d)", appid, engine, ret);
}
return ret;
}
int CServicePlugin::set_default_assistant(const char* appid)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_default_assistant func = mWakeupManagerInterface.set_default_assistant;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_DEFAULT_ASSISTANT);
- } else {
- ret = func(appid);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set default assistant(%s), ret(%d)", appid, ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_default_assistant(appid);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set default assistant(%s), ret(%d)", appid, ret);
}
return ret;
}
MAS_LOGE("[ERROR] appid is not valid");
return ret;
}
- if (NULL != mPluginHandle) {
- wakeup_manager_get_default_assistant func = mWakeupManagerInterface.get_default_assistant;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_GET_DEFAULT_ASSISTANT);
- } else {
- ret = func(appid);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get default assistant, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_get_default_assistant(appid);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get default assistant, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::activate(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_activate func = mWakeupManagerInterface.activate;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_ACTIVATE);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to start recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_activate();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to start recording, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::deactivate(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_deactivate func = mWakeupManagerInterface.deactivate;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_DEACTIVATE);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_deactivate();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::update_voice_feedback_state(const char* appid, int state)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_update_voice_feedback_state func = mWakeupManagerInterface.update_voice_feedback_state;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_UPDATE_VOICE_FEEDBACK_STATE);
- } else {
- ret = func(appid, state);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_update_voice_feedback_state(appid, state);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_assistant_specific_command(const char* appid, const char* command)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_assistant_specific_command func = mWakeupManagerInterface.set_assistant_specific_command;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND);
- } else {
- ret = func(appid, command);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_assistant_specific_command(appid, command);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_background_volume(const char* appid, double ratio)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_background_volume func = mWakeupManagerInterface.set_background_volume;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_BACKGROUND_VOLUME);
- } else {
- ret = func(appid, ratio);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set background volume, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_background_volume(appid, ratio);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set background volume, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::update_recognition_result(const char* appid, int state)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_update_recognition_result func = mWakeupManagerInterface.update_recognition_result;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_UPDATE_RECOGNITION_RESULT);
- } else {
- ret = func(appid, state);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to update result state, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_update_recognition_result(appid, state);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to update result state, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::process_event(int event, void *data, int len)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_process_plugin_event func = mWakeupManagerInterface.process_plugin_event;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_PROCESS_PLUGIN_EVENT);
- } else {
- ret = func((mas_plugin_event_e)event, data, len);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_process_plugin_event((mas_plugin_event_e)event, data, len);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
}
return ret;
}
{
MAS_LOGI("[ENTER");
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_start_streaming_utterance_data func = mWakeupManagerInterface.start_streaming_utterance_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_START_STREAMING_UTTERANCE_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_start_streaming_utterance_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::stop_streaming_utterance_data(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_stop_streaming_utterance_data func = mWakeupManagerInterface.stop_streaming_utterance_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_UTTERANCE_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_stop_streaming_utterance_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::start_streaming_previous_utterance_data(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_start_streaming_previous_utterance_data func = mWakeupManagerInterface.start_streaming_previous_utterance_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_START_STREAMING_PREVIOUS_UTTERANCE_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request previous speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_start_streaming_previous_utterance_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request previous speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::stop_streaming_previous_utterance_data(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_stop_streaming_previous_utterance_data func = mWakeupManagerInterface.stop_streaming_previous_utterance_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_PREVIOUS_UTTERANCE_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request previous speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_stop_streaming_previous_utterance_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request previous speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::start_streaming_follow_up_data(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_start_streaming_follow_up_data func = mWakeupManagerInterface.start_streaming_follow_up_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_START_STREAMING_FOLLOW_UP_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_start_streaming_follow_up_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::stop_streaming_follow_up_data(void)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_stop_streaming_follow_up_data func = mWakeupManagerInterface.stop_streaming_follow_up_data;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_STOP_STREAMING_FOLLOW_UP_DATA);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_stop_streaming_follow_up_data();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to request speech data, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::get_recording_audio_format(int *rate, int *channel, int *audio_type)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_get_audio_format func = mWakeupManagerInterface.get_audio_format;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_FORMAT);
- } else {
- ret = func(rate, channel, audio_type);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get recording audio format, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_get_audio_format(rate, channel, audio_type);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get recording audio format, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::get_recording_audio_source_type(char** type)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_get_audio_source_type func = mWakeupManagerInterface.get_audio_source_type;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_GET_AUDIO_SOURCE_TYPE);
- } else {
- ret = func(type);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to get recording audio source type, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_get_audio_source_type(type);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get recording audio source type, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_voice_key_tap_duration(float duration)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_voice_key_tap_duration func = mWakeupManagerInterface.set_voice_key_tap_duration;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_TAP_DURATION);
- } else {
- ret = func(duration);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set voice key tap duration, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_voice_key_tap_duration(duration);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set voice key tap duration, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::unset_voice_key_tap_duration()
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_unset_voice_key_tap_duration func = mWakeupManagerInterface.unset_voice_key_tap_duration;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
- } else {
- ret = func();
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_unset_voice_key_tap_duration();
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_voice_key_support_mode(int mode)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_voice_key_support_mode func = mWakeupManagerInterface.set_voice_key_support_mode;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
- } else {
- ret = func(mode);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set voice key support mode, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_voice_key_support_mode(mode);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set voice key support mode, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_wake_word_audio_require_flag(const char* appid, bool require)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_wake_word_audio_require_flag func = mWakeupManagerInterface.set_wake_word_audio_require_flag;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG);
- } else {
- ret = func(require);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set wake word audio require flag, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_wake_word_audio_require_flag(require);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set wake word audio require flag, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_assistant_language(const char* appid, const char* language)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_assistant_language func = mWakeupManagerInterface.set_assistant_language;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_ASSISTANT_LANGUAGE);
- } else {
- ret = func(appid, language);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set assistant language, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_assistant_language(appid, language);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set assistant language, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_wakeup_event_callback func = mWakeupManagerInterface.set_wakeup_event_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_EVENT_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set wakeup event callback, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_wakeup_event_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set wakeup event callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_utterance_streaming_callback func = mWakeupManagerInterface.set_utterance_streaming_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_UTTERANCE_STREAMING_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set utterance streaming callback, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_utterance_streaming_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set utterance streaming callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_previous_utterance_streaming_callback func = mWakeupManagerInterface.set_previous_utterance_streaming_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_PREVIOUS_UTTERANCE_STREAMING_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set utterance streaming callback, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_previous_utterance_streaming_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set utterance streaming callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_follow_up_streaming_callback func = mWakeupManagerInterface.set_follow_up_streaming_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_FOLLOW_UP_STREAMING_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set follow-up streaming callback, ret(%d)", ret);
- }
- }
- } else {
- MAS_LOGE("[ERROR] mPluginHandle is not valid");
+ ret = wakeup_manager_set_follow_up_streaming_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set follow-up streaming callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_speech_status_callback func = mWakeupManagerInterface.set_speech_status_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_SPEECH_STATUS_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set speech status callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_speech_status_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set speech status callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_setting_changed_callback func = mWakeupManagerInterface.set_setting_changed_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_SETTING_CHANGED_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set setting_changed callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_setting_changed_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set setting_changed callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_error_callback(wakeup_service_error_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_error_callback func = mWakeupManagerInterface.set_error_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_ERROR_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_error_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_streaming_section_changed_callback func = mWakeupManagerInterface.set_streaming_section_changed_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_STREAMING_SECTION_CHANGED_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set streaming section changed callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_streaming_section_changed_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set streaming section changed callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_wakeup_engine_command_callback(wakeup_service_wakeup_engine_command_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_wakeup_engine_command_callback func = mWakeupManagerInterface.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);
- }
- }
+ ret = wakeup_manager_set_wakeup_engine_command_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_wakeup_service_state_changed_callback(wakeup_service_wakeup_service_state_changed_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_wakeup_service_state_changed_callback func = mWakeupManagerInterface.set_wakeup_service_state_changed_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_WAKEUP_SERVICE_STATE_CHANGED_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_wakeup_service_state_changed_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
}
return ret;
}
int CServicePlugin::set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data)
{
int ret = -1;
- if (NULL != mPluginHandle) {
- wakeup_manager_set_voice_key_status_changed_callback func = mWakeupManagerInterface.set_voice_key_status_changed_callback;
- if (NULL == func) {
- MAS_LOGE("[ERROR] symbol lookup failed : %s", MA_WAKEUP_MANAGER_FUNC_SET_VOICE_KEY_STATUS_CHANGED_CALLBACK);
- } else {
- ret = func(callback, user_data);
- if (0 != ret) {
- MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
- }
- }
+ ret = wakeup_manager_set_voice_key_status_changed_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
}
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);
- }
- }
+ ret = wakeup_manager_set_loaded_engine_changed_callback(callback, user_data);
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback, ret(%d)", ret);
}
return ret;
}
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(ma-wakeup-manager)
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(PACKAGE ${PROJECT_NAME})
+
+SET(CMAKE_SKIP_BUILD_RPATH TRUE)
+
+INCLUDE_DIRECTORIES(
+ ${CMAKE_SOURCE_DIR}/inc
+ ./inc
+ )
+
+SET(WMPKG_CHECK_MODULES
+ ecore
+ dlog
+ capi-appfw-preference
+ capi-media-audio-io
+ capi-media-sound-manager
+ eina
+ vconf
+ pkgmgr-info
+ multi-assistant
+ jsoncpp
+)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(wmpkgs REQUIRED ${WMPKG_CHECK_MODULES})
+MESSAGE("Modules : ${WMPKG_CHECK_MODULES}")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
+
+SET(SRCS
+ src/wakeup_manager.cpp
+ src/wakeup_settings.cpp
+ src/wakeup_policy.cpp
+ src/wakeup_policy_default.cpp
+ src/wakeup_policy_external.cpp
+ src/wakeup_audio_manager.cpp
+ src/wakeup_engine_manager.cpp
+ src/wakeup_manager_wrapper.cpp
+ src/dependency_resolver.cpp
+ src/heap_tracer.cpp
+ src/assistant_config_manager.cpp
+)
+
+FOREACH(flag ${wmpkgs_CFLAGS})
+ SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+
+
+SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} -fPIC -Wall" )
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fstack-protector-strong -D_FORTIFY_SOURCE=2 -Wl,-z,relro -fPIC -std=c++11 -fvisibility=hidden")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS} )
+
+# Install libraries
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${wmpkgs_LDFLAGS} -ldl ${EXTRA_LDFLAGS})
+MESSAGE("LDFLAG : ${wmpkgs_LDFLAGS}")
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/plugins/wakeup-manager/libma-wakeup-manager.so DESTINATION ${TZ_SYS_RO_SHARE}/multiassistant/)
+
+ADD_SUBDIRECTORY(dependency-default)
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _ASSISTANT_CONFIG_MANAGER_H_
+#define _ASSISTANT_CONFIG_MANAGER_H_
+
+#include <string>
+#include <functional>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+constexpr char LANGUAGE_PREFIX[] = "LANGUAGE_";
+
+typedef void (*foreach_assistant_language_cb)(const char* appid, const char* language, void* user_data);
+
+class CAssistantConfigManager
+{
+public:
+ CAssistantConfigManager();
+ virtual ~CAssistantConfigManager();
+
+ CAssistantConfigManager(const CAssistantConfigManager&) = delete;
+ CAssistantConfigManager& operator=(const CAssistantConfigManager&) = delete;
+
+ void initialize();
+ void deinitialize();
+
+ int set_assistant_language(string assistant, string language);
+ int get_assistant_language(string assistant, string& language);
+
+ void foreach_assistant_language(foreach_assistant_language_cb callback, void* user_data);
+private:
+};
+
+} // wakeup
+} // multiassistant
+
+#endif _ASSISTANT_CONFIG_MANAGER_H_
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _DEPENDENCY_RESOLVER_H_
+#define _DEPENDENCY_RESOLVER_H_
+
+#include <tzplatform_config.h>
+#include <multi_assistant_service.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**************************************************************************************
+ *** Definitions for dependencies
+ *************************************************************************************/
+#define MAS_DEPENDENCY_DEFAULT_PATH tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_SHARE"), "multiassistant/")
+#define MAS_DEPENDENCY_DEFAULT_FILENAME "libma-dependency-default.so"
+#define MAS_DEPENDENCY_MODULE_PATH "db/multi-assistant/dependency_module_path"
+
+#define MAS_DEPENDENCY_FUNC_INITIALIZE "mas_dependency_initialize"
+typedef int (*mas_dependency_initialize)(mas_dependency_plugin_proxy_interface interface, int *dependency_version);
+#define MAS_DEPENDENCY_FUNC_DEINITIALIZE "mas_dependency_deinitialize"
+typedef int (*mas_dependency_deinitialize)(void);
+#define MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK "mas_dependency_set_error_callback"
+typedef int (*mas_dependency_set_error_callback)(mas_error_cb callback, void* user_data);
+#define MAS_DEPENDENCY_FUNC_START_RECORDING "mas_dependency_start_recording"
+typedef int (*mas_dependency_start_recording)(void);
+#define MAS_DEPENDENCY_FUNC_STOP_RECORDING "mas_dependency_stop_recording"
+typedef int (*mas_dependency_stop_recording)(void);
+#define MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION "mas_dependency_set_recording_session"
+typedef int (*mas_dependency_set_recording_session)(unsigned int);
+#define MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME "mas_dependency_set_background_volume"
+typedef int (*mas_dependency_set_background_volume)(double ratio);
+#define MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT "mas_dependency_get_audio_format"
+typedef int (*mas_dependency_get_audio_format)(int* rate, int* channel, int* audio_type);
+#define MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE "mas_dependency_get_audio_source_type"
+typedef int (*mas_dependency_get_audio_source_type)(char** type);
+#define MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND "mas_dependency_process_wakeup_engine_command"
+typedef int (*mas_dependency_process_wakeup_engine_command)(const char* engine_name, const char* command);
+#define MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE "mas_dependency_process_wakeup_candidate"
+typedef int (*mas_dependency_process_wakeup_candidate)(const mas_wakeup_event_info* info);
+#define MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION "mas_dependency_set_voice_key_tap_duration"
+typedef int (*mas_dependency_set_voice_key_tap_duration)(float duration);
+#define MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION "mas_dependency_unset_voice_key_tap_duration"
+typedef int (*mas_dependency_unset_voice_key_tap_duration)(void);
+#define MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE "mas_dependency_set_voice_key_support_mode"
+typedef int (*mas_dependency_set_voice_key_support_mode)(const char* support_mode);
+#define MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY "mas_dependency_get_custom_vconf_key"
+typedef int (*mas_dependency_get_custom_vconf_key)(const char* default_key, char** custom_key);
+
+
+typedef struct {
+ mas_dependency_initialize initialize;
+ mas_dependency_deinitialize deinitialize;
+ mas_dependency_set_error_callback set_error_callback;
+ mas_dependency_start_recording start_recording;
+ mas_dependency_stop_recording stop_recording;
+ mas_dependency_set_recording_session set_recording_session;
+ mas_dependency_set_background_volume set_background_volume;
+ mas_dependency_get_audio_format get_audio_format;
+ mas_dependency_get_audio_source_type get_audio_source_type;
+ mas_dependency_process_wakeup_engine_command process_wakeup_engine_command;
+ mas_dependency_process_wakeup_candidate process_wakeup_candidate;
+ mas_dependency_set_voice_key_tap_duration set_voice_key_tap_duration;
+ mas_dependency_unset_voice_key_tap_duration unset_voice_key_tap_duration;
+ mas_dependency_set_voice_key_support_mode set_voice_key_support_mode;
+ mas_dependency_get_custom_vconf_key get_custom_vconf_key;
+} mas_dependency_module_interface;
+
+int dependency_resolver_initialize(mas_dependency_plugin_proxy_interface interface);
+int dependency_resolver_deinitialize(void);
+int dependency_resolver_set_error_callback(mas_error_cb callback, void* user_data);
+int dependency_resolver_start_recording();
+int dependency_resolver_stop_recording();
+int dependency_resolver_set_recording_session(unsigned int);
+int dependency_resolver_set_background_volume(double ratio);
+int dependency_resolver_get_audio_format(int* rate, int* channel, int* audio_type);
+int dependency_resolver_get_audio_source_type(char** type);
+int dependency_resolver_process_wakeup_engine_command(const char* engine, const char* command);
+int dependency_resolver_process_wakeup_candidate(mas_wakeup_event_info* info);
+int dependency_resolver_set_voice_key_tap_duration(float duration);
+int dependency_resolver_unset_voice_key_tap_duration();
+int dependency_resolver_set_voice_key_support_mode(const char* support_mode);
+int dependency_resolver_get_custom_vconf_key(const char* default_key, char** custom_key);
+
+mas_dependency_module_interface* dependency_resolver_get_interface();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _DEPENDENCY_RESOLVER_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __HEAP_TRACER_H__
+#define __HEAP_TRACER_H__
+
+#include <list>
+#include <mutex>
+#include <unordered_map>
+#include <string>
+#include <set>
+
+#ifndef __MODULE__
+#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#endif
+
+#define vm_calloc_simple(nmemb, size) vm_calloc(nmemb, size, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
+#define vm_malloc_simple(size) vm_malloc(size, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
+#define vm_free_simple(ptr) vm_free(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
+#define vm_strdup_simple(ptr) vm_strdup(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
+#define vm_mark_unmanaged_simple(ptr) vm_mark_unmanaged(ptr, "%s: %s(%d)", __MODULE__, __func__, __LINE__)
+
+void *vm_calloc(size_t nmemb, size_t size, const char *fmt, ...);
+void *vm_malloc(size_t size, const char *fmt, ...);
+void vm_free(void *ptr, const char *fmt, ...);
+char *vm_strdup(const char *s, const char *fmt, ...);
+void *vm_mark_unmanaged(void *ptr, const char *fmt, ...);
+
+class HeapTracer {
+public:
+ HeapTracer();
+ virtual ~HeapTracer();
+
+ bool Insert(void *ptr, std::string description, size_t size = 0);
+ bool Delete(void *ptr, std::string description);
+ std::string Find(void *ptr);
+
+ void MarkUnmanaged(void *ptr, std::string description);
+
+ bool Empty();
+ void Trace();
+protected:
+ typedef struct {
+ void *ptr{nullptr};
+ std::string description;
+ int size{0};
+ } AllocationEntry;
+
+ std::mutex mManagedTableMutex;
+ std::unordered_map<void*, AllocationEntry> mManagedTable;
+
+ std::mutex mUnmanagedRecordsMutex;
+ std::list<AllocationEntry> mUnmanagedRecords;
+ size_t mUnmanagedRecordsSize{0};
+
+ enum class EntryOperation {
+ INSERT,
+ DELETE,
+ };
+ typedef struct {
+ AllocationEntry entry;
+ EntryOperation operation;
+ struct timespec ts;
+ } EntryHistory;
+ std::list<EntryHistory> mEntryHistory;
+};
+
+#endif /* __HEAP_TRACER_H__ */
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _WAKEUP_AUDIO_MANAGER_H_
+#define _WAKEUP_AUDIO_MANAGER_H_
+
+#include "service_common.h"
+
+#include <atomic>
+#include <list>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+#include <multi_assistant_service.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+class IAudioEventObserver
+{
+public:
+ virtual ~IAudioEventObserver() = default;
+ virtual bool on_recording_audio_data(long time, void* data, int len) = 0;
+ virtual bool on_streaming_audio_data(
+ mas_speech_streaming_event_e event, void* buffer, unsigned int len) = 0;
+};
+
+typedef enum
+{
+ RECORDING_SESSION_WAKE_WORD,
+ RECORDING_SESSION_UTTERANCE,
+ RECORDING_SESSION_FOLLOW_UP,
+} recording_session;
+
+class CAudioManager
+{
+public:
+ CAudioManager();
+ CAudioManager(IAudioEventObserver *observer);
+ ~CAudioManager();
+
+ CAudioManager(const CAudioManager&) = delete;
+ CAudioManager& operator=(const CAudioManager&) = delete;
+
+ int initialize();
+ int deinitialize();
+
+ void sound_focus_changed();
+
+ /* NOTE : The observer that is being passed to this subscribe() function
+ * must not be deleted before the call to CAudioManager::deinitialize(),
+ * since the observer's callback can be called even after unsubscribe() */
+ void subscribe(IAudioEventObserver *observer);
+ void unsubscribe(IAudioEventObserver *observer);
+
+ void start_recording(bool proactive);
+ void stop_recording(bool proactive);
+
+ void set_recording_session(recording_session session);
+
+ void feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
+ void finalize_audio_data();
+ void clear_audio_data();
+
+ void start_streaming_current_utterance_data(long long start_time = 0);
+ void stop_streaming_current_utterance_data();
+
+ void start_streaming_previous_utterance_data();
+ void stop_streaming_previous_utterance_data();
+
+ void start_streaming_follow_up_data();
+ void stop_streaming_follow_up_data();
+
+ void set_background_volume(double ratio);
+conditional_public:
+ void add_audio_data(mas_speech_data& data, long long time);
+ void notify_audio_data_recording(long time, void* data, int len);
+
+ void streaming_previous_audio_data_thread_func();
+ void streaming_audio_data_thread_func(long long start_time);
+
+private:
+ int mSoundFocusWatchId{0};
+ bool mRecordingRequired{false};
+ bool mIsRecording{false};
+
+ vector<IAudioEventObserver*> mObservers;
+
+ thread mStreamingThread;
+ atomic_bool mStopStreamingThread{false};
+ atomic_bool mStreamingThreadActive{false};
+
+ thread mStreamingPreviousThread;
+ atomic_bool mStopStreamingPreviousThread{false};
+
+ static constexpr long long mAudioRecordingDurationMilliseconds = 10 * 1000;
+ typedef struct {
+ long long time;
+ mas_speech_data data;
+ } mas_speech_data_with_time;
+ vector<mas_speech_data_with_time> mPreviousAudioData;
+ list<mas_speech_data_with_time> mAudioData;
+
+ mutex mMutex;
+ bool mVoiceKeyPressed{false};
+
+ thread mBackgroundVolumeThread;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_AUDIO_MANAGER_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_ENGINE_MANAGER_H_
+#define _WAKEUP_ENGINE_MANAGER_H_
+
+#include "wakeup_manager_wrapper.h"
+
+#include <atomic>
+#include <string>
+#include <thread>
+#include <vector>
+#include <set>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+/**************************************************************************************
+ *** Definitions for wakeup engine interface
+ *************************************************************************************/
+#define MA_WAKEUP_ENGINE_PATH tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_SHARE"), "multiassistant/engines")
+/* Need to check whether this dedicated engine path also needs to be configurable */
+#define MA_WAKEUP_DEDICATED_ENGINE_PATH "shared/lib/libwakeup-engine.so"
+
+/* Interfaces without version information */
+#define MA_WAKEUP_ENGINE_FUNC_INITIALIZE "wakeup_engine_initialize"
+typedef int (*wakeup_engine_initialize)(void);
+#define MA_WAKEUP_ENGINE_FUNC_DEINITIALIZE "wakeup_engine_deinitialize"
+typedef int (*wakeup_engine_deinitialize)(void);
+#define MA_WAKEUP_ENGINE_FUNC_ACTIVATE "wakeup_engine_activate"
+typedef int (*wakeup_engine_activate)(void);
+#define MA_WAKEUP_ENGINE_FUNC_DEACTIVATE "wakeup_engine_deactivate"
+typedef int (*wakeup_engine_deactivate)(void);
+#define MA_WAKEUP_ENGINE_FUNC_ADD_WAKEUP_WORD "wakeup_engine_add_wakeup_word"
+typedef int (*wakeup_engine_add_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
+#define MA_WAKEUP_ENGINE_FUNC_REMOVE_WAKEUP_WORD "wakeup_engine_remove_wakeup_word"
+typedef int (*wakeup_engine_remove_wakeup_word)(const char* appid, const char* wakeup_word, const char* language);
+#define MA_WAKEUP_ENGINE_FUNC_ADD_LANGUAGE "wakeup_engine_add_language"
+typedef int (*wakeup_engine_add_language)(const char* appid, const char* language);
+#define MA_WAKEUP_ENGINE_FUNC_SET_LANGUAGE "wakeup_engine_set_language"
+typedef int (*wakeup_engine_set_language)(const char* language);
+#define MA_WAKEUP_ENGINE_FUNC_UPDATE_MANAGER_STATE "wakeup_engine_update_manager_state"
+typedef int (*wakeup_engine_update_manager_state)(wakeup_manager_state_e state);
+#define MA_WAKEUP_ENGINE_FUNC_UPDATE_RECOGNITION_RESULT "wakeup_engine_update_recognition_result"
+typedef int (*wakeup_engine_update_recognition_result)(const char* appid, int result);
+#define MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_FORMAT "wakeup_engine_set_audio_format"
+typedef int (*wakeup_engine_set_audio_format)(int rate, int channel, int audio_type);
+#define MA_WAKEUP_ENGINE_FUNC_GET_AUDIO_FORMAT "wakeup_engine_get_audio_format"
+typedef int (*wakeup_engine_get_audio_format)(int* rate, int* channel, int* audio_type);
+#define MA_WAKEUP_ENGINE_FUNC_FEED_AUDIO_DATA "wakeup_engine_feed_audio_data"
+typedef int (*wakeup_engine_feed_audio_data)(long time, void* data, int len);
+#define MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA_COUNT "wakeup_engine_get_utterance_data_count"
+typedef int (*wakeup_engine_get_utterance_data_count)(void);
+#define MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA "wakeup_engine_get_utterance_data"
+typedef int (*wakeup_engine_get_utterance_data)(int index, mas_speech_data *data);
+#define MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA_COUNT "wakeup_engine_get_wake_word_data_count"
+typedef int (*wakeup_engine_get_wake_word_data_count)(void);
+#define MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA "wakeup_engine_get_wake_word_data"
+typedef int (*wakeup_engine_get_wake_word_data)(int index, mas_speech_data *data);
+#define MA_WAKEUP_ENGINE_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND "wakeup_engine_set_assistant_specific_command"
+typedef int (*wakeup_engine_set_assistant_specific_command)(const char* appid, const char* command);
+#define MA_WAKEUP_ENGINE_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG "wakeup_engine_set_wake_word_audio_require_flag"
+typedef int (*wakeup_engine_set_wake_word_audio_require_flag)(bool require);
+#define MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_EVENT_CALLBACK "wakeup_engine_set_wakeup_event_callback"
+typedef int (*wakeup_engine_set_wakeup_event_callback)(wakeup_service_wakeup_event_cb callback, void* user_data);
+#define MA_WAKEUP_ENGINE_FUNC_SET_SPEECH_STATUS_CALLBACK "wakeup_engine_set_speech_status_callback"
+typedef int (*wakeup_engine_set_speech_status_callback)(wakeup_service_speech_status_cb callback, void* user_data);
+#define MA_WAKEUP_ENGINE_FUNC_SET_ERROR_CALLBACK "wakeup_engine_set_error_callback"
+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"
+typedef int (*wakeup_engine_get_version)(int* version);
+#define MA_WAKEUP_ENGINE_FUNC_SET_DEPENDENCY_MODULE_COMMAND "wakeup_engine_set_dependency_module_command"
+typedef int (*wakeup_engine_set_dependency_module_command)(const char* command);
+
+typedef struct {
+ wakeup_engine_initialize initialize;
+ wakeup_engine_deinitialize deinitialize;
+ wakeup_engine_activate activate;
+ wakeup_engine_deactivate deactivate;
+ wakeup_engine_add_wakeup_word add_wakeup_word;
+ wakeup_engine_remove_wakeup_word remove_wakeup_word;
+ wakeup_engine_add_language add_language;
+ wakeup_engine_set_language set_language;
+ wakeup_engine_update_manager_state update_manager_state;
+ wakeup_engine_update_recognition_result update_recognition_result;
+ wakeup_engine_set_audio_format set_audio_format;
+ wakeup_engine_get_audio_format get_audio_format;
+ wakeup_engine_feed_audio_data feed_audio_data;
+ wakeup_engine_get_utterance_data_count get_utterance_data_count;
+ wakeup_engine_get_utterance_data get_utterance_data;
+ wakeup_engine_get_wake_word_data_count get_wake_word_data_count;
+ wakeup_engine_get_wake_word_data get_wake_word_data;
+ wakeup_engine_get_version get_version;
+ wakeup_engine_set_assistant_specific_command set_assistant_specific_command;
+ wakeup_engine_set_wake_word_audio_require_flag set_wake_word_audio_require_flag;
+ wakeup_engine_set_dependency_module_command set_dependency_module_command;
+ wakeup_engine_set_wakeup_event_callback set_wakeup_event_callback;
+ 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
+{
+public:
+ virtual ~IEngineEventObserver() = default;
+ virtual bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info) = 0;
+ virtual bool on_speech_status(string engine_name, mas_speech_status_e status) = 0;
+ virtual bool on_error(string engine_name, int error_code, string error_message) = 0;
+ virtual bool on_audio_data_require_status(string engine_name, bool require) = 0;
+
+ virtual bool on_streaming_audio_data(
+ mas_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(
+ mas_wakeup_engine_command_target_e target, string engine_name, string assistant_name, string command) = 0;
+};
+
+class CWakeupEngineManager
+{
+public:
+ CWakeupEngineManager();
+ CWakeupEngineManager(IEngineEventObserver *observer);
+ virtual ~CWakeupEngineManager();
+
+ CWakeupEngineManager(const CWakeupEngineManager&) = delete;
+ CWakeupEngineManager& operator=(const CWakeupEngineManager&) = delete;
+
+ void initialize();
+ void deinitialize();
+
+ void subscribe(IEngineEventObserver *observer);
+ void unsubscribe(IEngineEventObserver *observer);
+
+ bool get_audio_data_required();
+ void set_selected_wakeup_info(mas_wakeup_event_info wakeup_info);
+
+ bool set_language(string language);
+ bool set_assistant_language(string appid, string language);
+ void set_assistant_activated(string appid, bool activated);
+ bool get_assistant_activated(string appid);
+ void set_wake_word_audio_require_flag(bool require);
+
+ void start_streaming_current_utterance_data();
+ void stop_streaming_current_utterance_data();
+
+ void update_manager_state(wakeup_manager_state_e state);
+ void update_recognition_result(string appid, int result);
+
+ void engine_add_target_assistant(string engine_name, string appid);
+ void engine_add_wakeup_word(string appid, string wakeup_word, string language);
+ void engine_remove_wakeup_word(string appid, string wakeup_word, string language);
+ void engine_set_assistant_specific_command(string appid, string command);
+ void engine_set_dependency_module_command(string engine_name, string command);
+ void engine_feed_audio_data(long time, void* data, int len);
+
+ bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info);
+ bool on_speech_status(string engine_name, mas_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,
+ mas_wakeup_engine_command_target_e target, string assistant_name, string command);
+private:
+ typedef struct {
+ int version;
+ string engine_name;
+ bool activated{false};
+ bool audio_data_require_status{false};
+ string engine_path;
+ wakeup_engine_interface interface{nullptr, };
+ vector<string> assistant_list;
+ set<string> activated_assistants;
+ void *engine_handle{nullptr};
+ } EngineInfo;
+
+ void add_engine_directory(string name, string path);
+ void add_engine(string name, string path);
+
+ vector<IEngineEventObserver*> mObservers;
+
+ void streaming_speech_data_thread_func();
+
+ vector<EngineInfo> mEngineInfo;
+ const EngineInfo* mSelectedEngine{nullptr};
+ bool mAudioDataRequired{false};
+
+ thread mStreamingThread;
+ atomic_bool mStopStreamingThread{false};
+ wakeup_manager_state_e mWakeupManagerState{WAKEUP_MANAGER_STATE_INACTIVE};
+
+ bool mWakeWordAudioRequired{false};
+
+ typedef struct {
+ atomic_llong last_audio_fetched{0};
+ atomic_llong last_count_fetched{0};
+ atomic_llong last_audio_sent{0};
+ } StreamingHistory;
+
+ StreamingHistory mStreamingHistory;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_ENGINE_MANAGER_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _WAKEUP_MANAGER_H_
+#define _WAKEUP_MANAGER_H_
+
+#include "service_config.h"
+#include "wakeup_manager_wrapper.h"
+#include "wakeup_settings.h"
+#include "wakeup_engine_manager.h"
+#include "wakeup_audio_manager.h"
+#include "wakeup_policy_default.h"
+#include "assistant_config_manager.h"
+
+#include <memory>
+#include <map>
+#include <mutex>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+#define WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID "db/multi-assistant/default_assistant_appid"
+#define WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS "db/multi-assistant/enabled_assistants"
+#define WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED "db/multi-assistant/wake_word_detection_enabled"
+
+enum class STREAMING_MODE {
+ NONE,
+ UTTERANCE,
+ PREVIOUS_UTTERANCE,
+ FOLLOW_UP,
+};
+
+class IWakeupEventObserver {
+public:
+ virtual ~IWakeupEventObserver() = default;
+ virtual void on_wakeup(mas_wakeup_event_info wakeup_info) = 0;
+ virtual void on_streaming_audio_data(
+ mas_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(
+ mas_wakeup_engine_command_target_e target, const char* name, const char* command) = 0;
+ virtual void on_wakeup_service_state_changed(ma_service_state_e state) = 0;
+ virtual void on_voice_key_status_changed(ma_voice_key_status_e status) = 0;
+};
+
+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,
+ the wakeup_engine attribute of wakeup_event_info will have the following value */
+#define WAKEUP_ENGINE_VOICE_KEY "voice_key"
+
+class CWakeupManager
+{
+public:
+ CWakeupManager(IWakeupEventObserver* wakeup_observer, ISettingValueObserver* setting_observer);
+ virtual ~CWakeupManager();
+
+ CWakeupManager(const CWakeupManager&) = delete;
+ CWakeupManager& operator=(const CWakeupManager&) = delete;
+
+ bool initialize();
+ bool deinitialize();
+
+ void subscribe_wakeup_observer(IWakeupEventObserver* observer);
+ void unsubscribe_wakeup_observer(IWakeupEventObserver* observer);
+
+ void subscribe_setting_observer(ISettingValueObserver* observer);
+ void unsubscribe_setting_observer(ISettingValueObserver* observer);
+
+ bool activate();
+ bool deactivate();
+
+ bool add_assistant_language(string appid, string language);
+ bool add_assistant_wakeup_word(string appid, string wakeup_word, string language);
+ bool remove_assistant_wakeup_word(string appid, string wakeup_word, string language);
+ bool add_assistant_wakeup_engine(string appid, string engine);
+ bool set_assistant_language(string appid, string language);
+
+ bool set_assistant_enabled(string appid, bool enabled);
+ bool get_assistant_enabled(string appid);
+ bool set_default_assistant(string appid);
+ bool process_default_assistant_changed(string appid, bool expected);
+ string get_default_assistant();
+
+ bool update_voice_feedback_state(string appid, bool state);
+ bool set_assistant_specific_command(string appid, string command);
+ bool set_background_volume(string appid, double ratio);
+ bool update_recognition_result(string appid, int result);
+ bool process_plugin_event(mas_plugin_event_e event, void* data, int len);
+ bool get_audio_format(int* rate, int* channel, int* audio_type);
+ bool get_audio_source_type(char** type);
+ bool set_language(string language);
+ bool get_recording_by_voice_key();
+ void set_recording_by_voice_key(bool recording);
+ bool set_voice_key_tap_duration(float duration);
+ bool unset_voice_key_tap_duration();
+ bool set_voice_key_support_mode(VOICE_KEY_SUPPORT_MODE mode);
+ bool set_wake_word_audio_require_flag(bool require);
+
+ STREAMING_MODE get_streaming_mode();
+ bool set_streaming_mode(STREAMING_MODE mode);
+
+ bool start_streaming_utterance_data();
+ bool stop_streaming_utterance_data();
+ bool start_streaming_follow_up_data();
+ bool stop_streaming_follow_up_data();
+ bool start_streaming_previous_utterance_data();
+ bool stop_streaming_previous_utterance_data();
+
+ CWakeupPolicy* get_wakeup_policy();
+ CWakeupEngineManager* get_engine_manager();
+ CAudioManager* get_audio_manager();
+ CWakeupSettings* get_wakeup_settings();
+
+ vector<IWakeupEventObserver*> get_wakeup_observers();
+ void set_last_wakeup_event_info(mas_wakeup_event_info wakeup_info);
+
+ vector<ISettingValueObserver*> get_setting_observers();
+
+ bool change_manager_state(wakeup_manager_state_e state);
+ wakeup_manager_state_e get_manager_state();
+
+ void feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
+ void set_dependency_module_command(string engine_name, string command);
+
+ void start_streaming_duration_timer();
+ void stop_streaming_duration_timer();
+
+ void set_streaming_duration_timer(Ecore_Timer* timer);
+ Ecore_Timer* get_streaming_duration_timer();
+
+ void start_periodic_monitor_timer();
+ void stop_periodic_monitor_timer();
+
+ void update_voice_key_status(ma_voice_key_status_e status);
+ void update_pending_voice_key_status();
+
+ void start_voice_key_status_update_timer();
+ void set_streaming_completed(bool completed);
+private:
+ class CEngineEventObserver : public IEngineEventObserver
+ {
+ public:
+ bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info) override;
+ bool on_speech_status(string engine_name, mas_speech_status_e status) override;
+ bool on_error(string engine_name, int error_code, string error_message) override;
+ bool on_audio_data_require_status(string engine_name, bool require) override;
+
+ bool on_streaming_audio_data(
+ mas_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(
+ mas_wakeup_engine_command_target_e target, string engine, string name, string command) override;
+
+ void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
+ private:
+ CWakeupManager *mWakeupManager{nullptr};
+ };
+
+ class CPolicyEventObserver : public IPolicyEventObserver
+ {
+ public:
+ void on_wakeup(mas_wakeup_event_info wakeup_info) override;
+
+ void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
+ private:
+ CWakeupManager *mWakeupManager{nullptr};
+ };
+
+ class CAudioEventObserver : public IAudioEventObserver
+ {
+ public:
+ bool on_recording_audio_data(long time, void* data, int len) override;
+ bool on_streaming_audio_data(
+ mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
+
+ void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
+ void set_wakeup_engine_manager(CWakeupEngineManager *manager) { mEngineManager = manager; }
+ private:
+ CWakeupManager *mWakeupManager{nullptr};
+ CWakeupEngineManager *mEngineManager{nullptr};
+ };
+
+ class CSettingsEventObserver : public ISettingsEventObserver
+ {
+ public:
+ 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;
+ bool on_wake_word_detection_enabled_info_changed() override;
+
+ void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
+ private:
+ CWakeupManager *mWakeupManager{nullptr};
+ };
+
+ void initialize_wakeup_policy();
+
+ typedef struct {
+ string appid;
+ vector<string> languageList;
+ } AssistantLanguageInfo;
+ vector<AssistantLanguageInfo> mAssistantLanguageInfo;
+ map<string, bool> mAssistantSupportsCurrentLanguage;
+ map<string, bool> mAssistantEnabled;
+
+ vector<IWakeupEventObserver*> mWakeupObservers;
+ vector<ISettingValueObserver*> mSettingObservers;
+
+ unique_ptr<CWakeupPolicy> mWakeupPolicy;
+
+ CAudioManager mAudioManager;
+ CWakeupEngineManager mWakeupEngineManager;
+ CWakeupSettings mWakeupSettings;
+ CAssistantConfigManager mAssistantConfigManager;
+
+ CAudioEventObserver mAudioEventObserver;
+ CEngineEventObserver mEngineEventObserver;
+ CPolicyEventObserver mPolicyEventObserver;
+ CSettingsEventObserver mSettingsEventObserver;
+
+ thread mEngineDataThread;
+ atomic_bool mStopEngineDataThread{false};
+
+ bool mRecordingByVoiceKey{false};
+
+ string mCurrentLanguage;
+ string mCurrentDefaultAssistant;
+ /* Assume Push-to-talk is the default mode */
+ VOICE_KEY_SUPPORT_MODE mCurrentVoiceKeySupportMode{VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK};
+
+ STREAMING_MODE mStreamingMode{STREAMING_MODE::NONE};
+ Ecore_Timer* mStreamingDurationTimer{nullptr};
+ Ecore_Timer* mPeriodicMonitorTimer{nullptr};
+
+ wakeup_manager_state_e mWakeupManagerState{WAKEUP_MANAGER_STATE_INACTIVE};
+
+ mas_wakeup_event_info mLastWakeupEventInfo;
+
+ unsigned int mLastWakeupEventID{0};
+ unsigned int mCurrentStreamingSessionID{0};
+
+ boost::optional<ma_voice_key_status_e> mPendingVoiceKeyStatus;
+ atomic_bool mStreamingCompleted{false};
+ Ecore_Timer *mVoiceKeyStatusUpdateTimer{nullptr};
+ mutex mVoiceKeyStatusUpdateMutex;
+
+ mutex mMutex;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_MANAGER_H_ */
--- /dev/null
+#ifndef __MUTLI_WAKEUP_MAIN_H__
+#define __MUTLI_WAKEUP_MAIN_H__
+
+#include <dlog.h>
+#include <glib.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "multi-assistant"
+
+#ifdef __MODULE__
+#undef __MODULE__
+#endif
+#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+
+#define MWR_SECURE_LOG_(id, prio, tag, fmt, arg...) \
+ ({ do { \
+ __dlog_print(id, prio, tag, "%s: %s(%d) > [SECURE_LOG] " fmt, __MODULE__, __func__, __LINE__, ##arg); \
+ } while (0); })
+
+#define MWR_LOG_(prio, tag, fmt, arg...) \
+ ({ do { \
+ dlog_print(prio, tag, "%s: %s(%d) > " fmt, __MODULE__, __func__, __LINE__, ##arg); \
+ } while (0); })
+
+#define MWR_LOGD(fmt, args...) MWR_LOG_(DLOG_DEBUG, LOG_TAG, fmt, ##args)
+#define MWR_LOGI(fmt, args...) MWR_LOG_(DLOG_INFO, LOG_TAG, fmt, ##args)
+#define MWR_LOGW(fmt, args...) MWR_LOG_(DLOG_WARN, LOG_TAG, fmt, ##args)
+#define MWR_LOGE(fmt, args...) MWR_LOG_(DLOG_ERROR, LOG_TAG, fmt, ##args)
+
+#define MWR_SLOGD(fmt, args...) MWR_SECURE_LOG_(DLOG_DEBUG, LOG_TAG, fmt, ##args)
+#define MWR_SLOGI(fmt, args...) MWR_SECURE_LOG_(DLOG_INFO, LOG_TAG, fmt, ##args)
+#define MWR_SLOGW(fmt, args...) MWR_SECURE_LOG_(DLOG_WARN, LOG_TAG, fmt, ##args)
+#define MWR_SLOGE(fmt, args...) MWR_SECURE_LOG_(DLOG_ERROR, LOG_TAG, fmt, ##args)
+
+#endif /* __MUTLI_WAKEUP_MAIN_H__ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _WAKEUP_MANAGER_WRAPPER_H_
+#define _WAKEUP_MANAGER_WRAPPER_H_
+
+#include <dlog.h>
+#include <stdbool.h>
+#include <tizen.h>
+#include <tzplatform_config.h>
+
+#include <multi_assistant_service.h>
+#include <multi_assistant_internal.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+ WAKEUP_MANAGER_STATE_INACTIVE = 0,
+ WAKEUP_MANAGER_STATE_LISTENING = 1,
+ WAKEUP_MANAGER_STATE_UTTERANCE = 2,
+ WAKEUP_MANAGER_STATE_PROCESSING = 3,
+ WAKEUP_MANAGER_STATE_VOICE_FEEDBACK = 4
+} wakeup_manager_state_e;
+
+typedef void (*ma_audio_streaming_data_section_changed_cb)(ma_audio_streaming_data_section_e section, void* user_data);
+
+typedef void (*wakeup_service_wakeup_event_cb)(mas_wakeup_event_info wakeup_info, void* user_data);
+
+typedef void (*wakeup_service_speech_streaming_cb)(mas_speech_streaming_event_e event, void* buffer, int len, void *user_data);
+
+typedef void (*wakeup_service_speech_status_cb)(mas_speech_status_e status, void *user_data);
+
+typedef void (*wakeup_service_setting_changed_cb)( void *user_data);
+
+typedef void (*wakeup_service_error_cb)(int error, const char* err_msg, void* user_data);
+
+typedef void (*wakeup_service_audio_data_require_status_cb)(bool require, void* user_data);
+
+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)(mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command, void* user_data);
+
+typedef void (*wakeup_service_state_changed_cb)(ma_service_state_e state, void* user_data);
+
+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;
+} ma_plugin_settings;
+
+int wakeup_manager_initialize(void);
+
+int wakeup_manager_deinitialize(void);
+
+int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size);
+
+int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language);
+
+int wakeup_manager_remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language);
+
+int wakeup_manager_add_assistant_language(const char* appid, const char* language);
+
+int wakeup_manager_add_assistant_wakeup_engine(const char* appid, const char *engine);
+
+int wakeup_manager_set_default_assistant(const char* appid);
+
+int wakeup_manager_get_default_assistant(const char** appid);
+
+int wakeup_manager_set_language(const char* language);
+
+int wakeup_manager_activate(void);
+
+int wakeup_manager_deactivate(void);
+
+int wakeup_manager_update_voice_feedback_state(const char *appid, int state);
+
+int wakeup_manager_set_assistant_specific_command(const char* appid, const char* command);
+
+int wakeup_manager_set_background_volume(const char *appid, double ratio);
+
+int wakeup_manager_update_recognition_result(const char *appid, int result);
+
+int wakeup_manager_process_plugin_event(mas_plugin_event_e event, void* data, int len);
+
+int wakeup_manager_start_streaming_utterance_data(void);
+
+int wakeup_manager_stop_streaming_utterance_data(void);
+
+int wakeup_manager_start_streaming_previous_utterance_data(void);
+
+int wakeup_manager_stop_streaming_previous_utterance_data(void);
+
+int wakeup_manager_start_streaming_follow_up_data(void);
+
+int wakeup_manager_stop_streaming_follow_up_data(void);
+
+int wakeup_manager_get_audio_format(int *rate, int *channel, int *audio_type);
+
+int wakeup_manager_get_audio_source_type(char** type);
+
+int wakeup_manager_set_voice_key_tap_duration(float duration);
+
+int wakeup_manager_unset_voice_key_tap_duration();
+
+int wakeup_manager_set_voice_key_support_mode(int mode);
+
+int wakeup_manager_set_wake_word_audio_require_flag(bool require);
+
+int wakeup_manager_set_assistant_language(const char* appid, const char *language);
+
+int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data);
+
+int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
+
+int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
+
+int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data);
+
+int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data);
+
+int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data);
+
+int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data);
+
+int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data);
+
+int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data);
+
+int wakeup_manager_set_wakeup_service_state_changed_callback(wakeup_service_state_changed_cb callback, void* user_data);
+
+int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data);
+
+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);
+
+int wakeup_manager_set_dependency_module_command(const char* engine_name, const char* command);
+
+int wakeup_manager_wakeup_assistant(const mas_wakeup_event_info* wakeup_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _WAKEUP_MANAGER_WRAPPER_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_POLICY_H_
+#define _WAKEUP_POLICY_H_
+
+#include <string>
+#include <memory>
+
+#include <multi_assistant_service.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+class IPolicyEventObserver
+{
+public:
+ virtual ~IPolicyEventObserver() = default;
+ virtual void on_wakeup(mas_wakeup_event_info wakeup_info) = 0;
+};
+
+class CWakeupPolicyImpl;
+
+class CWakeupPolicy
+{
+public:
+ CWakeupPolicy();
+ CWakeupPolicy(IPolicyEventObserver *observer);
+ virtual ~CWakeupPolicy();
+
+ CWakeupPolicy(const CWakeupPolicy&) = delete;
+ CWakeupPolicy& operator=(const CWakeupPolicy&) = delete;
+
+ virtual bool valid() = 0;
+
+ void subscribe(IPolicyEventObserver *observer);
+ void unsubscribe(IPolicyEventObserver *observer);
+
+ virtual void wakeup_candidate(mas_wakeup_event_info wakeup_info) = 0;
+ virtual void select_candidate(mas_wakeup_event_info wakeup_info) = 0;
+protected:
+ unique_ptr<CWakeupPolicyImpl> mImpl;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_POLICY_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_POLICY_DEFAULT_H_
+#define _WAKEUP_POLICY_DEFAULT_H_
+
+#include "wakeup_policy.h"
+
+#include <vector>
+#include <string>
+
+#include <Ecore.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+typedef struct {
+ std::string wakeup_appid;
+ std::string wakeup_word;
+ std::string wakeup_language;
+ 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;
+
+
+using namespace std;
+
+class CWakeupPolicyDefault : public CWakeupPolicy
+{
+public:
+ CWakeupPolicyDefault(IPolicyEventObserver *observer);
+ ~CWakeupPolicyDefault();
+
+ bool valid() override;
+
+ void set_assistant_priority(string appid, int priority);
+
+ void wakeup_candidate(mas_wakeup_event_info wakeup_info) override;
+ void select_candidate(mas_wakeup_event_info wakeup_info) override;
+
+ void timer_expired();
+
+ void set_delay(float seconds);
+ float get_delay();
+
+ void set_timer(Ecore_Timer* timer);
+ Ecore_Timer* get_timer();
+
+private:
+ typedef struct {
+ string appid;
+ int priority{0};
+ } PRIORITY_INFO;
+
+ float mDelaySeconds{0.0f};
+ vector<PRIORITY_INFO> mPriorityInfos;
+ vector<mas_wakeup_event_info_wrapper> mWakeupInfos;
+
+ Ecore_Timer *mTimer{nullptr};
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_POLICY_H_ */
--- /dev/null
+/*
+ * Copyright 2018 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_POLICY_EXTERNAL_H_
+#define _WAKEUP_POLICY_EXTERNAL_H_
+
+#include "wakeup_policy.h"
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+class CWakeupPolicyExternal : public CWakeupPolicy
+{
+public:
+ CWakeupPolicyExternal(IPolicyEventObserver *observer);
+ ~CWakeupPolicyExternal();
+
+ bool valid() override;
+
+ void wakeup_candidate(mas_wakeup_event_info wakeup_info) override;
+ void select_candidate(mas_wakeup_event_info wakeup_info) override;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_POLICY_EXTERNAL_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_POLICY_IMPL_H_
+#define _WAKEUP_POLICY_IMPL_H_
+
+#include "wakeup_policy.h"
+#include <string>
+#include <vector>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+class CWakeupPolicyImpl
+{
+public:
+ CWakeupPolicyImpl() {}
+ ~CWakeupPolicyImpl() {}
+
+ void subscribe(IPolicyEventObserver *observer);
+ void unsubscribe(IPolicyEventObserver *observer);
+
+ void wakeup(mas_wakeup_event_info wakeup_info);
+private:
+ vector<IPolicyEventObserver*> mObservers;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_POLICY_IMPL_H_ */
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WAKEUP_SETTINGS_H_
+#define _WAKEUP_SETTINGS_H_
+
+#include <string>
+#include <vector>
+#include <vconf.h>
+#include <map>
+
+//#define ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
+
+typedef void (*input_language_changed_cb)(void* data);
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+using namespace std;
+
+#define WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID "db/multi-assistant/default_assistant_appid"
+#define WAKEUP_SETTINGS_KEY_UI_PANEL_ENABLED "db/multi-assistant/ui_panel_enabled"
+#define WAKEUP_SETTINGS_KEY_CONVERSATION_TIMEOUT "db/multi-assistant/conversation_timeout"
+#define WAKEUP_SETTINGS_KEY_MULTIPLE_MODE "db/multi-assistant/multiple_mode"
+#define WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS "db/multi-assistant/enabled_assistants"
+#define WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_DELAY "db/multi-assistant/wakeup_policy_delay"
+#define WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_PRIORITY "db/multi-assistant/wakeup_policy_priority"
+#define WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX "db/multi-assistant/streaming_duration_max"
+#define WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE "db/multi-assistant/voice_input_language"
+#define WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED "db/multi-assistant/wake_word_detection_enabled"
+
+class ISettingsEventObserver
+{
+public:
+ virtual ~ISettingsEventObserver() = default;
+ 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;
+ virtual bool on_wake_word_detection_enabled_info_changed() = 0;
+};
+
+class CWakeupSettings
+{
+public:
+ CWakeupSettings();
+ virtual ~CWakeupSettings();
+
+ CWakeupSettings(const CWakeupSettings&) = delete;
+ CWakeupSettings& operator=(const CWakeupSettings&) = delete;
+
+ void initialize(map<string, string> custom_keys);
+ void deinitialize();
+
+ void subscribe(ISettingsEventObserver *observer);
+ void unsubscribe(ISettingsEventObserver *observer);
+ const vector<ISettingsEventObserver*>& get_observers();
+
+ string get_default_assistant_appid();
+ void set_default_assistant_appid(std::string appid);
+
+ bool get_ui_panel_enabled();
+ float get_conversation_timeout();
+ bool get_multiple_mode();
+ vector<string> get_enabled_assistants();
+ float get_wakeup_policy_delay();
+ vector<string> get_wakeup_policy_priority();
+ float get_streaming_duration_max();
+ void set_streaming_duration_max(float duration);
+ string get_current_language(void);
+ vector<string> get_wake_word_disabled_assistants();
+private:
+ vector<ISettingsEventObserver*> mObservers;
+
+ string mDefaultAssistantAppid;
+ bool mUiPanelEnabled{true};
+ float mConversationTimeout{5.0};
+ bool mMultipleMode{false};
+ vector<string> mEnabledAssistants;
+ float mWakeupPolicyDelay{0.0};
+ vector<string> mWakeupPolicyPriority; // No priority by default
+ float mStreamingDurationMax{15.0};
+ string mVoiceInputLanguage;
+ map<string, string> mCustomVconfKeys;
+ vector<string> mWakeWordDisabledAssistants;
+};
+
+} // wakeup
+} // multiassistant
+
+#endif /* _WAKEUP_SETTINGS_H_ */
--- /dev/null
+#include "wakeup_manager_main.h"
+#include "assistant_config_manager.h"
+
+#include <string.h>
+
+#include <app_preference.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+CAssistantConfigManager::CAssistantConfigManager()
+{
+}
+
+CAssistantConfigManager::~CAssistantConfigManager()
+{
+}
+
+void CAssistantConfigManager::initialize()
+{
+}
+
+void CAssistantConfigManager::deinitialize()
+{
+}
+
+int CAssistantConfigManager::set_assistant_language(string assistant, string language)
+{
+ string key = string{LANGUAGE_PREFIX} + assistant;
+
+ preference_set_string(key.c_str(), language.c_str());
+ MWR_LOGE("Set assistant language : %s %s", key.c_str(), language.c_str());
+
+ return 0;
+}
+
+int CAssistantConfigManager::get_assistant_language(string assistant, string& language)
+{
+ string key = string{LANGUAGE_PREFIX} + assistant;
+
+ bool existing = false;
+ preference_is_existing(key.c_str(), &existing);
+ if (!existing) return -1;
+
+ char* value = nullptr;
+ preference_get_string(key.c_str(), &value);
+ if (nullptr == value) return -1;
+
+ language = value;
+ MWR_LOGE("Got assistant language : %s %s", key.c_str(), language.c_str());
+ free(value);
+
+ return 0;
+}
+
+void CAssistantConfigManager::foreach_assistant_language(foreach_assistant_language_cb callback, void* user_data)
+{
+ typedef struct {
+ foreach_assistant_language_cb callback;
+ void* user_data;
+ } foreach_assistant_language_cb_closure;
+
+ foreach_assistant_language_cb_closure closure;
+ closure.callback = callback;
+ closure.user_data = user_data;
+
+ preference_foreach_item(
+ [](const char *key, void *data) {
+ string prefix = string{LANGUAGE_PREFIX};
+ foreach_assistant_language_cb_closure* closure =
+ static_cast<foreach_assistant_language_cb_closure*>(data);
+ if (key && strlen(key) > prefix.length() &&
+ 0 == prefix.compare(0, prefix.length(), key, prefix.length())) {
+ char* value = nullptr;
+ preference_get_string(key, &value);
+ if (value) {
+ if (closure) {
+ closure->callback(key + prefix.length(), value, closure->user_data);
+ }
+ free(value);
+ }
+ }
+ return true;
+ }, static_cast<void*>(&closure)
+ );
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tizen.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <vconf.h>
+
+#include <stdexcept>
+
+#include "service_common.h"
+#include "dependency_resolver.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "dependency-resolver"
+
+static void *g_handle = NULL;
+static mas_dependency_module_interface g_mas_dependency = { NULL, };
+
+mas_dependency_module_interface* dependency_resolver_get_interface()
+{
+ return &g_mas_dependency;
+}
+
+int dependency_resolver_initialize(mas_dependency_plugin_proxy_interface interface)
+{
+ MAS_LOGD("[Enter]");
+
+ const int FILEPATH_LEN = 512;
+ char filepath[FILEPATH_LEN] = {'\0', };
+ char *vconf_str = vconf_get_str(MAS_DEPENDENCY_MODULE_PATH);
+ if (vconf_str) {
+ snprintf(filepath, FILEPATH_LEN - 1, "%s", vconf_str);
+ free(vconf_str);
+ } else {
+ const char *default_path = MAS_DEPENDENCY_DEFAULT_PATH;
+ snprintf(filepath, FILEPATH_LEN - 1, "%s/%s", default_path, MAS_DEPENDENCY_DEFAULT_FILENAME);
+ }
+ filepath[FILEPATH_LEN - 1] = '\0';
+
+ char *error;
+ g_handle = NULL;
+ g_handle = dlopen(filepath, RTLD_LAZY);
+ if (NULL != (error = dlerror())) {
+ MAS_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", filepath, error);
+ return -1; //MAS_ERROR_OPERATION_FAILED;
+ }
+
+ g_mas_dependency.initialize =
+ (mas_dependency_initialize)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_INITIALIZE);
+ g_mas_dependency.deinitialize =
+ (mas_dependency_deinitialize)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_DEINITIALIZE);
+ g_mas_dependency.set_error_callback =
+ (mas_dependency_set_error_callback)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK);
+ g_mas_dependency.start_recording =
+ (mas_dependency_start_recording)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_START_RECORDING);
+ g_mas_dependency.stop_recording =
+ (mas_dependency_stop_recording)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_STOP_RECORDING);
+ g_mas_dependency.set_recording_session =
+ (mas_dependency_set_recording_session)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION);
+ g_mas_dependency.set_background_volume =
+ (mas_dependency_set_background_volume)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME);
+ g_mas_dependency.get_audio_format =
+ (mas_dependency_get_audio_format)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT);
+ g_mas_dependency.get_audio_source_type =
+ (mas_dependency_get_audio_source_type)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
+ g_mas_dependency.process_wakeup_engine_command =
+ (mas_dependency_process_wakeup_engine_command)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND);
+ g_mas_dependency.process_wakeup_candidate =
+ (mas_dependency_process_wakeup_candidate)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE);
+ g_mas_dependency.set_voice_key_tap_duration =
+ (mas_dependency_set_voice_key_tap_duration)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION);
+ g_mas_dependency.unset_voice_key_tap_duration =
+ (mas_dependency_unset_voice_key_tap_duration)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
+ g_mas_dependency.set_voice_key_support_mode =
+ (mas_dependency_set_voice_key_support_mode)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
+ g_mas_dependency.get_custom_vconf_key =
+ (mas_dependency_get_custom_vconf_key)dlsym(g_handle,
+ MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY);
+
+ int ret = -1;
+ int dependency_version = 0;
+ if (NULL != g_handle) {
+ mas_dependency_initialize func = g_mas_dependency.initialize;
+
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_INITIALIZE);
+ } else {
+ 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);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+ MAS_LOGD("g_handle : %p, dependency_version %d", g_handle, dependency_version);
+ return ret;
+}
+
+int dependency_resolver_deinitialize(void)
+{
+ MAS_LOGD("g_handle : %p", g_handle);
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_deinitialize func = g_mas_dependency.deinitialize;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_DEINITIALIZE);
+ } else {
+ 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);
+ }
+ }
+
+ dlclose(g_handle);
+ g_handle = NULL;
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_set_error_callback(mas_error_cb callback, void* user_data)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_set_error_callback func = g_mas_dependency.set_error_callback;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK);
+ } else {
+ try {
+ ret = func(callback, user_data);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_SET_ERROR_CALLBACK, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set error callback(%p, %p), ret(%d)", callback, user_data, ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+ return ret;
+}
+
+int dependency_resolver_start_recording(void)
+{
+ int ret = -1;
+ MAS_LOGD("g_handle : %p", g_handle);
+ if (NULL != g_handle) {
+ mas_dependency_start_recording func = g_mas_dependency.start_recording;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_START_RECORDING);
+ } else {
+ try {
+ ret = func();
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_START_RECORDING, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to start recording, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_stop_recording(void)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_stop_recording func = g_mas_dependency.stop_recording;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_STOP_RECORDING);
+ } else {
+ try {
+ ret = func();
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_STOP_RECORDING, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to stop recording, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_set_recording_session(unsigned int session)
+{
+ int ret = -1;
+ MAS_LOGD("g_handle : %p", g_handle);
+ if (NULL != g_handle) {
+ mas_dependency_set_recording_session func = g_mas_dependency.set_recording_session;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION);
+ } else {
+ try {
+ ret = func(session);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_SET_RECORDING_SESSION, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set recording session, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_set_background_volume(double ratio)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_set_background_volume func = g_mas_dependency.set_background_volume;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME);
+ } else {
+ try {
+ ret = func(ratio);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_SET_BACKGROUND_VOLUME, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set background volume to %f, ret(%d)", ratio, ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_get_audio_format(int* rate, int* channel, int* audio_type)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_get_audio_format func = g_mas_dependency.get_audio_format;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_FORMAT);
+ } else {
+ 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_GET_AUDIO_FORMAT, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get audio format, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_get_audio_source_type(char** type)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_get_audio_source_type func = g_mas_dependency.get_audio_source_type;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
+ } else {
+ try {
+ ret = func(type);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get audio source type, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_process_wakeup_engine_command(const char* engine, const char* command)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_process_wakeup_engine_command func = g_mas_dependency.process_wakeup_engine_command;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND);
+ } else {
+ try {
+ ret = func(engine, command);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_ENGINE_COMMAND, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to process wakeup engine command, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_process_wakeup_candidate(mas_wakeup_event_info* info)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_process_wakeup_candidate func = g_mas_dependency.process_wakeup_candidate;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE);
+ } else {
+ try {
+ ret = func(info);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_PROCESS_WAKEUP_CANDIDATE, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to process wakeup candidate, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_set_voice_key_tap_duration(float duration)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_set_voice_key_tap_duration func = g_mas_dependency.set_voice_key_tap_duration;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION);
+ } else {
+ try {
+ ret = func(duration);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_TAP_DURATION, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to set voice key tap duration to %f, ret(%d)", duration, ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_unset_voice_key_tap_duration()
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_unset_voice_key_tap_duration func = g_mas_dependency.unset_voice_key_tap_duration;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION);
+ } else {
+ try {
+ ret = func();
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_UNSET_VOICE_KEY_TAP_DURATION, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_set_voice_key_support_mode(const char* support_mode)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_set_voice_key_support_mode func = g_mas_dependency.set_voice_key_support_mode;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE);
+ } else {
+ try {
+ ret = func(support_mode);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_SET_VOICE_KEY_SUPPORT_MODE, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to unset voice key tap duration, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
+
+int dependency_resolver_get_custom_vconf_key(const char* default_key, char** custom_key)
+{
+ int ret = -1;
+ if (NULL != g_handle) {
+ mas_dependency_get_custom_vconf_key func = g_mas_dependency.get_custom_vconf_key;
+ if (NULL == func) {
+ MAS_LOGE("[ERROR] symbol lookup failed : %s", MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY);
+ } else {
+ try {
+ ret = func(default_key, custom_key);
+ } catch (const std::exception& e) {
+ MAS_LOGE("[ERROR] %s of dependency module threw exception : %s",
+ MAS_DEPENDENCY_FUNC_GET_CUSTOM_VCONF_KEY, e.what());
+ }
+ if (0 != ret) {
+ MAS_LOGE("[ERROR] Fail to get custom vconf key, ret(%d)", ret);
+ }
+ }
+ } else {
+ MAS_LOGE("[ERROR] g_handle is not valid");
+ }
+
+ return ret;
+}
--- /dev/null
+#include "heap_tracer.h"
+
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "ma_heap_tracer"
+
+static HeapTracer _tracer;
+
+const bool RECORD_UNMANAGED_CHUNKS = true;
+const int MAX_UNMANAGED_RECORDS = 128;
+const bool HEAP_TRACER_LOG_ENABLED = false
+;
+
+#define DESCRIPTION_LENGTH 255
+#define USE_HEAP_TRACER
+//#define ALLOW_FREE_UNMANAGED
+//#define RECORD_ALL_HISTORY
+
+void* vm_calloc(size_t nmemb, size_t size, const char *fmt, ...)
+{
+ void *ptr = calloc(nmemb, size);
+#ifdef USE_HEAP_TRACER
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ char description[DESCRIPTION_LENGTH];
+ vsnprintf(description, sizeof(description), fmt, argptr);
+ _tracer.Insert(ptr, description, nmemb * size);
+
+ va_end(argptr);
+#endif
+ return ptr;
+}
+
+void* vm_malloc(size_t size, const char *fmt, ...)
+{
+ void *ptr = malloc(size);
+#ifdef USE_HEAP_TRACER
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ char description[DESCRIPTION_LENGTH];
+ vsnprintf(description, sizeof(description), fmt, argptr);
+ _tracer.Insert(ptr, description, size);
+
+ va_end(argptr);
+#endif
+ return ptr;
+}
+
+void vm_free(void *ptr, const char *fmt, ...)
+{
+ if (ptr) {
+#ifdef USE_HEAP_TRACER
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ bool managed = true;
+ char description[DESCRIPTION_LENGTH];
+ vsnprintf(description, sizeof(description), fmt, argptr);
+ if (false == _tracer.Delete(ptr, description)) {
+ managed = false;
+ _tracer.Find(ptr);
+ }
+#ifdef ALLOW_FREE_UNMANAGED
+ free(ptr);
+#else
+ if (managed) {
+ free(ptr);
+ }
+#endif
+ va_end(argptr);
+#else
+ free(ptr);
+#endif
+ } else {
+ LOGD("Trying to free a null pointer");
+ }
+}
+
+char* vm_strdup(const char *s, const char *fmt, ...)
+{
+ char *ptr = nullptr;
+ if (s) {
+ ptr = strdup(s);
+#ifdef USE_HEAP_TRACER
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ char description[DESCRIPTION_LENGTH];
+ vsnprintf(description, sizeof(description), fmt, argptr);
+ _tracer.Insert(ptr, description, strlen(s) + 1);
+
+ va_end(argptr);
+#endif
+ } else {
+ LOGD("Trying to duplicate a null pointer");
+ }
+ return ptr;
+}
+
+void *vm_mark_unmanaged(void *ptr, const char *fmt, ...)
+{
+#ifdef USE_HEAP_TRACER
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ char description[DESCRIPTION_LENGTH];
+ vsnprintf(description, sizeof(description), fmt, argptr);
+ _tracer.MarkUnmanaged(ptr, description);
+
+ va_end(argptr);
+#endif
+ return ptr;
+}
+
+HeapTracer::HeapTracer()
+{
+ LOGD("HeapTracer()");
+}
+
+HeapTracer::~HeapTracer()
+{
+ LOGD("~HeapTracer()");
+
+ Trace();
+}
+
+bool HeapTracer::Insert(void *ptr, std::string description, size_t size)
+{
+ if (HEAP_TRACER_LOG_ENABLED) {
+ LOGD("Heap allocated %p [size %zu] : %s", ptr, size, description.c_str());
+ }
+
+ AllocationEntry entry;
+ entry.ptr = ptr;
+ entry.description = description;
+ entry.size = size;
+
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+ mManagedTable[ptr] = entry;
+
+#ifdef RECORD_ALL_HISTORY
+ EntryHistory history;
+ history.entry = entry;
+ history.operation = EntryOperation::INSERT;
+ clock_gettime(CLOCK_REALTIME, &(history.ts));
+ mEntryHistory.push_back(history);
+#endif
+ return true;
+}
+
+bool HeapTracer::Delete(void *ptr, std::string description)
+{
+ if (HEAP_TRACER_LOG_ENABLED) {
+ LOGD("Heap deallocated %p : %s", ptr, description.c_str());
+ }
+
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+ if (mManagedTable.find(ptr) != mManagedTable.end()) {
+#ifdef RECORD_ALL_HISTORY
+ EntryHistory history;
+ history.entry = mManagedTable[ptr];
+ history.entry.description = description;
+ history.operation = EntryOperation::DELETE;
+ clock_gettime(CLOCK_REALTIME, &(history.ts));
+ mEntryHistory.push_back(history);
+#endif
+ mManagedTable.erase(ptr);
+ } else {
+ LOGE("Heap Trace Error : Trying to delete an entry that does not exist : %p, %s",
+ ptr, description.c_str());
+ return false;
+ }
+ return true;
+}
+
+std::string HeapTracer::Find(void *ptr)
+{
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+#ifdef RECORD_ALL_HISTORY
+ for (auto& entry : mEntryHistory) {
+ if (entry.entry.ptr == ptr) {
+ LOGD("Heap history record for %p : %s, %lld.%.9ld, %s",
+ ptr,
+ (entry.operation == EntryOperation::INSERT ? "INSERT" : "DELETE"),
+ (long long)(entry.ts.tv_sec), entry.ts.tv_nsec,
+ entry.entry.description.c_str());
+ }
+ }
+#endif
+ if (mManagedTable.find(ptr) != mManagedTable.end()) {
+ return mManagedTable[ptr].description;
+ }
+ return std::string("Not found");
+}
+
+void HeapTracer::MarkUnmanaged(void *ptr, std::string description)
+{
+ LOGD("Marking as unmanaged : %p %s", ptr, description.c_str());
+
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+ auto iter = mManagedTable.find(ptr);
+ if (iter != mManagedTable.end()) {
+ if (RECORD_UNMANAGED_CHUNKS) {
+ std::lock_guard<std::mutex> lock(mUnmanagedRecordsMutex);
+ if (mUnmanagedRecordsSize >= MAX_UNMANAGED_RECORDS) {
+ mUnmanagedRecords.pop_front();
+ mUnmanagedRecordsSize--;
+ }
+ mUnmanagedRecords.push_back(iter->second);
+ mUnmanagedRecordsSize++;
+ }
+ mManagedTable.erase(ptr);
+ } else {
+ LOGE("Heap Trace Error : Trying to mark an entry that does not exist as unmanaged : %p", ptr);
+ }
+}
+
+bool HeapTracer::Empty()
+{
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+ return mManagedTable.empty();
+}
+
+void HeapTracer::Trace()
+{
+ LOGD("Heap Trace Start");
+
+ std::lock_guard<std::mutex> lock(mManagedTableMutex);
+ for (auto& item : mManagedTable) {
+ LOGD("No dealloc information exists for %p [size %d] : %s", item.first, item.second.size, item.second.description.c_str());
+ }
+ LOGD("Heap Trace End");
+}
--- /dev/null
+#define _GNU_SOURCE
+
+#include "wakeup_audio_manager.h"
+#include "wakeup_manager_main.h"
+#include "dependency_resolver.h"
+#include "heap_tracer.h"
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include <algorithm>
+#include <map>
+
+#include <Ecore.h>
+#include <audio_io.h>
+#include <sound_manager.h>
+#include <sound_manager_internal.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+/* Need to check whether this value needs to be configurable */
+static int g_speech_pcm_wait_count = 800;
+
+#ifdef PRINT_DETAILED_TIMEINFO
+static atomic_int g_mutex_wait_index{0};
+static map<int, long long int> g_mutex_wait_time;
+#endif
+
+static long long get_current_milliseconds_after_epoch()
+{
+ auto now = chrono::steady_clock::now();
+ auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
+ /* number of milliseconds since the epoch of system_clock */
+ auto value = now_ms.time_since_epoch();
+
+ return value.count();
+}
+
+#ifdef PRINT_DETAILED_TIMEINFO
+static std::string get_current_milliseconds_after_epoch(chrono::time_point<chrono::steady_clock> point)
+{
+ auto now_ms = chrono::time_point_cast<chrono::milliseconds>(point);
+ /* number of milliseconds since the epoch of system_clock */
+ auto value = now_ms.time_since_epoch();
+
+ return std::to_string(value.count());
+}
+#endif
+
+CAudioManager::CAudioManager()
+{
+}
+
+CAudioManager::~CAudioManager()
+{
+ deinitialize();
+}
+
+CAudioManager::CAudioManager(IAudioEventObserver *observer) : CAudioManager()
+{
+ subscribe(observer);
+}
+
+void recording_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask,
+ sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason,
+ const char *extra_info, void *user_data)
+{
+ MWR_LOGD("[Recorder] focus_mask : %d, focus_state : %d, reason : %d, [%s]",
+ focus_mask, focus_state, reason, extra_info);
+
+ if (nullptr == user_data) return;
+
+ /* The API description states that calling sound_manager_get_current_recording_focus()
+ function inside sound_stream_focus_state_watch_cb() function is prohibited */
+ ecore_main_loop_thread_safe_call_async(
+ [](void* data) {
+ CAudioManager *manager = static_cast<CAudioManager*>(data);
+ if (manager) {
+ manager->sound_focus_changed();
+ }
+ }, user_data);
+}
+
+int CAudioManager::initialize(void)
+{
+ sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_RECORDING,
+ recording_focus_state_watch_cb, this, &mSoundFocusWatchId);
+ return 0;
+}
+
+int CAudioManager::deinitialize(void)
+{
+ clear_audio_data();
+ if (mStreamingThread.joinable()) {
+ MWR_LOGD("mStreamingThread is joinable, trying join()");
+ mStopStreamingThread.store(true);
+ try {
+ mStreamingThread.join();
+ } catch (std::exception &e) {
+ MWR_LOGE("Exception thrown : %s", e.what());
+ }
+ }
+ mStopStreamingThread.store(false);
+
+ if (mBackgroundVolumeThread.joinable()) {
+ MWR_LOGD("mBackgroundVolumeThread is joinable, trying join()");
+ try {
+ mBackgroundVolumeThread.join();
+ } catch (std::exception &e) {
+ MWR_LOGE("Exception thrown : %s", e.what());
+ }
+ }
+
+ sound_manager_remove_focus_state_watch_cb(mSoundFocusWatchId);
+
+ return 0;
+}
+
+void CAudioManager::sound_focus_changed()
+{
+ sound_stream_focus_change_reason_e acquired_by;
+ int sound_behavior;
+ char* extra_info = NULL;
+ int focus = sound_manager_get_current_recording_focus(&acquired_by, &sound_behavior, &extra_info);
+ MWR_LOGD("[Recorder] sound focus has changed : %d %d %d %s", focus,
+ (SOUND_MANAGER_ERROR_NO_DATA != focus ? acquired_by : -1),
+ (SOUND_MANAGER_ERROR_NO_DATA != focus ? sound_behavior : -1),
+ (SOUND_MANAGER_ERROR_NO_DATA != focus ? extra_info : ""));
+ if (SOUND_MANAGER_ERROR_NO_DATA == focus) {
+ if (mRecordingRequired && !mIsRecording) {
+ MWR_LOGD("[Recorder] Currently no other process has acquired sound focus, start recording");
+ start_recording(false);
+ }
+ } else {
+ if (mIsRecording) {
+ MWR_LOGW("[Recorder] Sound focus acquired by other process, stop recording");
+ stop_recording(false);
+ }
+ }
+ if (extra_info) {
+ free(extra_info);
+ extra_info = NULL;
+ }
+}
+
+void CAudioManager::subscribe(IAudioEventObserver *observer)
+{
+ lock_guard<mutex> lock(mMutex);
+ if (observer) {
+ mObservers.push_back(observer);
+ }
+}
+
+void CAudioManager::unsubscribe(IAudioEventObserver *observer)
+{
+ lock_guard<mutex> lock(mMutex);
+ auto iter = find(mObservers.begin(), mObservers.end(), observer);
+ if (iter != mObservers.end()) {
+ mObservers.erase(iter);
+ }
+}
+
+void CAudioManager::stop_recording(bool proactive)
+{
+ dependency_resolver_stop_recording();
+ if (proactive) {
+ mRecordingRequired = false;
+ }
+ mIsRecording = false;
+}
+
+void CAudioManager::start_recording(bool proactive)
+{
+ if (mIsRecording) {
+ stop_recording(false);
+ }
+ if (proactive) {
+ mRecordingRequired = true;
+ }
+
+ sound_stream_focus_change_reason_e acquired_by;
+ int sound_behavior;
+ char* extra_info = NULL;
+ if (SOUND_MANAGER_ERROR_NO_DATA == sound_manager_get_current_recording_focus(&acquired_by, &sound_behavior, &extra_info)) {
+ MWR_LOGD("[Recorder] Currently no other process has acquired sound focus, start recording");
+ dependency_resolver_start_recording();
+ mIsRecording = true;
+ } else {
+ MWR_LOGW("[Recorder] Currently sound focus is acquired by other process, skip recording");
+ }
+ if (extra_info) {
+ free(extra_info);
+ extra_info = NULL;
+ }
+}
+
+void CAudioManager::set_recording_session(recording_session session)
+{
+ dependency_resolver_set_recording_session((unsigned int)session);
+}
+
+/* Need to consider adapting conventional producer-consumer model */
+void CAudioManager::streaming_previous_audio_data_thread_func()
+{
+ MWR_LOGI("[ENTER]");
+
+ unique_lock<mutex> lock(mMutex, defer_lock);
+
+ /* get feedback data */
+ size_t audio_data_size = 0;
+ lock.lock();
+ audio_data_size = mPreviousAudioData.size();
+ for (int index = 0; index < audio_data_size; index++) {
+ mas_speech_data& speech_data = mPreviousAudioData.at(index).data;
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_streaming_audio_data(
+ speech_data.event, speech_data.buffer, speech_data.len)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
+ MWR_LOGI("[INFO] Finish to send previous speech data");
+ return;
+ }
+ }
+
+ if (mStopStreamingThread.load()) {
+ MWR_LOGI("[INFO] Stop Streaming Requested, returning");
+ return;
+ }
+ }
+ lock.unlock();
+
+ MWR_LOGI("[EXIT]");
+}
+
+static void validate_audio_data_event_field(const mas_speech_data &data)
+{
+ if (data.event == MAS_SPEECH_STREAMING_EVENT_CONTINUE ||
+ data.event == MAS_SPEECH_STREAMING_EVENT_START ||
+ data.event == MAS_SPEECH_STREAMING_EVENT_FINISH ||
+ data.event == MAS_SPEECH_STREAMING_EVENT_FAIL) {
+ return;
+ }
+ MWR_LOGE("mas_speech_data has event field : %d", data.event);
+}
+
+void CAudioManager::streaming_audio_data_thread_func(long long start_time)
+{
+ MWR_LOGI("[ENTER]");
+
+ mStreamingThreadActive.store(true);
+
+ unique_lock<mutex> lock(mMutex, defer_lock);
+ bool finish_event_sent = false;
+
+ lock.lock();
+ auto lead = mAudioData.begin();
+ auto iter = lead;
+ while (lead != mAudioData.end() && lead->time < start_time) {
+ iter = lead;
+ advance(lead, 1);
+ }
+ MWR_LOGE("data_count : %zu", mAudioData.size());
+ lock.unlock();
+
+ while (!(mStopStreamingThread.load())) {
+ const size_t SEND_BUFFER_SIZE = 4096;
+ unsigned char send_buffer[SEND_BUFFER_SIZE];
+
+ int ret = -1;
+ int cnt = 0;
+
+ /* get feedback data */
+ lock.lock();
+ auto end = mAudioData.end();
+ lock.unlock();
+ if (lead == end) {
+ /* empty queue */
+ MWR_LOGD("[DEBUG] No feedback data. Waiting mode : %d", ret);
+
+ /* waiting */
+ while (!(mStopStreamingThread.load())) {
+ this_thread::sleep_for(chrono::milliseconds(10));
+ lock.lock();
+ end = mAudioData.end();
+ auto begin = mAudioData.begin();
+ vector<IAudioEventObserver*> observers = mObservers;
+ lock.unlock();
+ if (iter == end) {
+ lead = begin;
+ } else {
+ lead = iter;
+ if (lead != end) {
+ advance(lead, 1);
+ }
+ }
+ if (lead != end) {
+ MWR_LOGD("[INFO] Resume thread");
+ break;
+ }
+ if (g_speech_pcm_wait_count < cnt) {
+ unsigned char final_buffer[2] = {'\0', };
+ MWR_LOGE("[ERROR] Wrong request, there's no pcm data");
+ for (const auto& observer : observers) {
+ if (observer) {
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FAIL, NULL, 0)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ mStreamingThreadActive.store(false);
+ return;
+ }
+ cnt++;
+ }
+ MWR_LOGD("[INFO] Finish to wait for new feedback data come");
+
+ /* resume feedback thread */
+ continue;
+ }
+
+ /* FIXME : Extracted audio data here should be used as previous audio data*/
+
+ lock.lock();
+ end = mAudioData.end();
+ vector<IAudioEventObserver*> observers = mObservers;
+
+ if (lead != end) {
+ iter = lead;
+
+ mas_speech_data speech_data = iter->data;
+ size_t len = speech_data.len;
+ if (len > SEND_BUFFER_SIZE) {
+ LOGE("ERROR : SPEECH DATA contains data bigger than the buffer size : %d, truncating", len);
+ len = SEND_BUFFER_SIZE;
+ }
+ memcpy(send_buffer, speech_data.buffer, len);
+ speech_data.buffer = send_buffer;
+ speech_data.len = len;
+ lock.unlock();
+
+ for (const auto& observer : observers) {
+ if (observer) {
+ validate_audio_data_event_field(speech_data);
+
+#ifdef PRINT_DETAILED_TIMEINFO
+ auto started = std::chrono::steady_clock::now();
+#endif
+ if (!observer->on_streaming_audio_data(
+ speech_data.event, speech_data.buffer, speech_data.len)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+#ifdef PRINT_DETAILED_TIMEINFO
+ auto finished = std::chrono::steady_clock::now();
+ auto interval = finished - started;
+ long long int count = static_cast<long long int>(
+ chrono::duration_cast<chrono::milliseconds>(interval).count());
+ int index = g_mutex_wait_index;
+ g_mutex_wait_time[index] += count;
+#endif
+ }
+ }
+
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
+ MWR_LOGE("[INFO] Finish to get and send speech data");
+ finish_event_sent = true;
+ break;
+ }
+
+ advance(lead, 1);
+ } else {
+ lock.unlock();
+ }
+ }
+
+ if (true != finish_event_sent) {
+ unsigned char final_buffer[2] = {'\0', };
+ lock.lock();
+ vector<IAudioEventObserver*> observers = mObservers;
+ lock.unlock();
+ for (const auto& observer : observers) {
+ if (observer) {
+ MWR_LOGE("No FINISH event sent yet, adding to finalize streaming session");
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+ mStreamingThreadActive.store(false);
+ MWR_LOGE("[EXIT]");
+}
+
+#ifdef PRINT_DETAILED_TIMEINFO
+static void print_duration(std::chrono::time_point<std::chrono::steady_clock> started)
+{
+ const std::chrono::milliseconds threshold(100);
+ auto finished = std::chrono::steady_clock::now();
+ auto interval = finished - started;
+ if (interval > threshold) {
+ long long int count = static_cast<long long int>(
+ std::chrono::duration_cast<std::chrono::milliseconds>(interval).count());
+ int index = g_mutex_wait_index;
+ MAS_LOGE("Mutex wait time : %d %lld %lld, [%s~]", index, count,
+ g_mutex_wait_time[index],
+ get_current_milliseconds_after_epoch(started).c_str());
+ }
+}
+#endif
+
+void CAudioManager::add_audio_data(mas_speech_data& data, long long time)
+{
+#ifdef PRINT_DETAILED_TIMEINFO
+ ++g_mutex_wait_index;
+#endif
+
+ long long delta = mAudioRecordingDurationMilliseconds;
+
+ bool print_log = false;
+ static unsigned int num = 0;
+ const std::chrono::seconds interval(3);
+ static auto last = std::chrono::steady_clock::now();
+ auto now = std::chrono::steady_clock::now();
+
+ struct rusage process_usage_before;
+ struct rusage thread_usage_before;
+
+ if (now - last > interval) {
+ print_log = true;
+ last = now;
+ getrusage(RUSAGE_SELF, &process_usage_before);
+ getrusage(RUSAGE_THREAD, &thread_usage_before);
+ }
+ num++;
+
+ notify_audio_data_recording(time, data.buffer, data.len);
+
+ if (print_log) {
+ struct rusage process_usage_after;
+ struct rusage thread_usage_after;
+
+ getrusage(RUSAGE_SELF, &process_usage_after);
+ getrusage(RUSAGE_THREAD, &thread_usage_after);
+
+ MWR_LOGE("Feeding audio data : num(%d), now(%" PRId64 "), %d %zu ([%ld,%ld,%ld,%ld] -> [%ld,%ld,%ld,%ld]) ([%ld,%ld,%ld,%ld] -> [%ld,%ld,%ld,%ld])",
+ num, now.time_since_epoch().count(),
+ mStreamingThreadActive.load(), mAudioData.size(),
+ process_usage_before.ru_maxrss,
+ process_usage_before.ru_ixrss,
+ process_usage_before.ru_idrss,
+ process_usage_before.ru_isrss,
+ process_usage_after.ru_maxrss,
+ process_usage_after.ru_ixrss,
+ process_usage_after.ru_idrss,
+ process_usage_after.ru_isrss,
+ thread_usage_before.ru_maxrss,
+ thread_usage_before.ru_ixrss,
+ thread_usage_before.ru_idrss,
+ thread_usage_before.ru_isrss,
+ thread_usage_after.ru_maxrss,
+ thread_usage_after.ru_ixrss,
+ thread_usage_after.ru_idrss,
+ thread_usage_after.ru_isrss);
+ }
+
+ mas_speech_data_with_time data_with_time;
+ data_with_time.data = data;
+ data_with_time.time = time;
+
+ lock_guard<mutex> lock(mMutex);
+
+#ifdef PRINT_DETAILED_TIMEINFO
+ print_duration(now);
+#endif
+
+ /* Pop items only when the streaming is not activated */
+ if (!mStreamingThreadActive.load()) {
+ while(false == mAudioData.empty() && mAudioData.front().time < time - delta) {
+ const auto &front = mAudioData.front();
+ if (front.data.buffer) {
+ vm_free_simple(front.data.buffer);
+ }
+ mAudioData.pop_front();
+ }
+ }
+ validate_audio_data_event_field(data);
+ mAudioData.push_back(data_with_time);
+}
+
+void CAudioManager::feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
+{
+ if (NULL == buffer || 0 == len) return;
+
+ mas_speech_data speech_data;
+ speech_data.buffer = vm_malloc_simple(len);
+ if (speech_data.buffer) {
+ long long time = get_current_milliseconds_after_epoch();
+
+ speech_data.event = event;
+ speech_data.len = len;
+ memcpy(speech_data.buffer, buffer, len);
+ add_audio_data(speech_data, time);
+ }
+}
+
+void CAudioManager::finalize_audio_data()
+{
+ MWR_LOGI("Adding FINISH event to audio data list");
+ unsigned char final_buffer[2] = {'\0', };
+ mas_speech_data speech_data;
+ speech_data.event = MAS_SPEECH_STREAMING_EVENT_FINISH;
+ speech_data.len = sizeof(final_buffer);
+ speech_data.buffer = vm_malloc_simple(speech_data.len);
+ if (speech_data.buffer) {
+ long long time = get_current_milliseconds_after_epoch();
+
+ memcpy(speech_data.buffer, final_buffer, speech_data.len);
+ add_audio_data(speech_data, time);
+ }
+}
+
+void CAudioManager::clear_audio_data()
+{
+ lock_guard<mutex> lock(mMutex);
+ while(!mAudioData.empty()) {
+ const auto &front = mAudioData.front();
+ if (front.data.buffer) {
+ vm_free_simple(front.data.buffer);
+ }
+ mAudioData.pop_front();
+ }
+ mAudioData.clear();
+}
+
+void CAudioManager::notify_audio_data_recording(long time, void* data, int len)
+{
+ unique_lock<mutex> lock(mMutex, defer_lock);
+ lock.lock();
+ vector<IAudioEventObserver*> observers = mObservers;
+ lock.unlock();
+ for (const auto& observer : observers) {
+ if (observer) {
+ observer->on_recording_audio_data(time, data, len);
+ }
+ }
+}
+
+void CAudioManager::start_streaming_current_utterance_data(long long start_time)
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
+ return;
+ }
+ lock_guard<mutex> lock(mMutex);
+ mStreamingThread = thread(&CAudioManager::streaming_audio_data_thread_func, this, start_time);
+}
+
+void CAudioManager::stop_streaming_current_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGD("mStreamingThread is joinable, trying join()");
+ mStopStreamingThread.store(true);
+ try {
+ mStreamingThread.join();
+ } catch (std::exception &e) {
+ MWR_LOGE("Exception thrown : %s", e.what());
+ }
+ }
+ mStopStreamingThread.store(false);
+
+ /* FIXME : Need to move all the speech data to previous speech data for later use */
+}
+
+void CAudioManager::start_streaming_previous_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingPreviousThread.joinable()) {
+ MWR_LOGE("ERROR : mStreamingPreviousThread is joinable, will not start a new thread");
+ return;
+ }
+ lock_guard<mutex> lock(mMutex);
+ mStreamingPreviousThread = thread(&CAudioManager::streaming_previous_audio_data_thread_func, this);
+}
+
+void CAudioManager::stop_streaming_previous_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingPreviousThread.joinable()) {
+ MWR_LOGD("mStreamingPreviousThread is joinable, trying join()");
+ mStopStreamingPreviousThread.store(true);
+ try {
+ mStreamingPreviousThread.join();
+ } catch (std::exception &e) {
+ MWR_LOGE("Exception thrown : %s", e.what());
+ }
+ }
+ mStopStreamingThread.store(false);
+}
+
+void CAudioManager::start_streaming_follow_up_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
+ return;
+ }
+
+ mStreamingThread = thread(&CAudioManager::streaming_audio_data_thread_func, this, 0);
+}
+
+void CAudioManager::stop_streaming_follow_up_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGD("mStreamingThread is joinable, trying join()");
+ mStopStreamingThread.store(true);
+ mStreamingThread.join();
+ }
+ mStopStreamingThread.store(false);
+}
+
+static void set_background_volume_thread_func(double ratio)
+{
+ MWR_LOGI("[ENTER]");
+ dependency_resolver_set_background_volume(ratio);
+}
+
+void CAudioManager::set_background_volume(double ratio)
+{
+ if (mBackgroundVolumeThread.joinable()) {
+ mBackgroundVolumeThread.join();
+ }
+ mBackgroundVolumeThread = thread(&set_background_volume_thread_func, ratio);
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+#include <multi_assistant_service.h>
+
+#include "wakeup_engine_manager.h"
+#include "wakeup_manager_main.h"
+
+#include <dlfcn.h>
+#include <algorithm>
+#include <pkgmgr-info.h>
+#include <deque>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+/* Sound buf save for test */
+#if 0
+#define BUF_SAVE_MODE
+#endif
+
+#ifdef BUF_SAVE_MODE
+static char g_temp_file_name[128] = {'\0', };
+
+static FILE* g_pFile = NULL;
+
+static int g_count = 1;
+#endif
+
+/* Need to check whether this value needs to be configurable */
+static int g_speech_pcm_wait_count = 800;
+
+/* Utility function for checking if an element exists in a container */
+template<class C, class T>
+static auto contains(const C& v, const T& x) -> decltype(end(v), true)
+{
+ return end(v) != find(begin(v), end(v), x);
+}
+
+static long long get_current_milliseconds_after_epoch()
+{
+ auto now = chrono::steady_clock::now();
+ auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
+ /* number of milliseconds since the epoch of system_clock */
+ auto value = now_ms.time_since_epoch();
+
+ return value.count();
+}
+
+CWakeupEngineManager::CWakeupEngineManager()
+{
+}
+
+CWakeupEngineManager::~CWakeupEngineManager()
+{
+ MWR_LOGI("Wakeup Engine Manager is now being destroyed");
+}
+
+CWakeupEngineManager::CWakeupEngineManager(IEngineEventObserver *observer) : CWakeupEngineManager()
+{
+ subscribe(observer);
+}
+
+void CWakeupEngineManager::initialize()
+{
+ DIR* dp = opendir(MA_WAKEUP_ENGINE_PATH);
+ if (nullptr == dp) {
+ MWR_LOGD("Failed opening directory : %s", (const char*)MA_WAKEUP_ENGINE_PATH);
+ } else {
+ struct dirent *dirp = nullptr;
+ char dirpath[_POSIX_PATH_MAX];
+ do {
+ dirp = readdir(dp);
+
+ if (nullptr != dirp) {
+ const string current_directory{"."};
+ const string parent_directory{".."};
+ if (0 == current_directory.compare(dirp->d_name) ||
+ 0 == parent_directory.compare(dirp->d_name))
+ continue;
+
+ if (DT_DIR != dirp->d_type) /* If not a directory */
+ continue;
+
+ int dirpath_len = strlen(MA_WAKEUP_ENGINE_PATH) + strlen(dirp->d_name) + 1;
+ if (dirpath_len >= _POSIX_PATH_MAX) {
+ MWR_LOGD("File path is too long : %s", dirp->d_name);
+ closedir(dp);
+ return;
+ }
+
+ memset(dirpath, '\0', _POSIX_PATH_MAX);
+ snprintf(dirpath, _POSIX_PATH_MAX, "%s/%s",
+ (const char*)(MA_WAKEUP_ENGINE_PATH), dirp->d_name);
+
+ add_engine_directory(string{dirp->d_name}, dirpath);
+ }
+ } while (nullptr != dirp);
+
+ closedir(dp);
+ }
+}
+
+void CWakeupEngineManager::deinitialize()
+{
+ MWR_LOGI("[START]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGD("mStreamingThread is joinable, trying join()");
+ mStopStreamingThread.store(true);
+ mStreamingThread.join();
+ }
+ mStopStreamingThread.store(false);
+
+ for (auto& info : mEngineInfo) {
+ 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.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();
+ MWR_LOGI("Deinitialization [%s] returned %d", info.engine_name.c_str(), ret);
+ }
+ } 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) {
+ int ret = dlclose(info.engine_handle);
+ MWR_LOGI("Closing [%s] returned %d, [%s]", info.engine_name.c_str(), ret,
+ ((0 == ret) ? "" : dlerror()));
+ info.engine_handle = nullptr;
+ }
+ }
+ mSelectedEngine = nullptr;
+ mEngineInfo.clear();
+ MWR_LOGI("[END]");
+}
+
+void CWakeupEngineManager::subscribe(IEngineEventObserver *observer)
+{
+ mObservers.push_back(observer);
+ MWR_LOGD("Added Observer : %p %zu", observer, mObservers.size());
+}
+
+void CWakeupEngineManager::unsubscribe(IEngineEventObserver *observer)
+{
+ auto iter = find(mObservers.begin(), mObservers.end(), observer);
+ if (iter != mObservers.end()) {
+ mObservers.erase(iter);
+ }
+}
+
+bool CWakeupEngineManager::get_audio_data_required()
+{
+ return mAudioDataRequired;
+}
+
+void CWakeupEngineManager::set_selected_wakeup_info(mas_wakeup_event_info wakeup_info)
+{
+ mSelectedEngine = nullptr;
+
+ const auto& iter = find_if(mEngineInfo.begin(), mEngineInfo.end(),
+ [wakeup_info](const EngineInfo& info) {
+ if (nullptr == wakeup_info.wakeup_engine)
+ return false;
+
+ return (0 == info.engine_name.compare(wakeup_info.wakeup_engine));
+ });
+
+ if (iter != mEngineInfo.end()) {
+ mSelectedEngine = &(*iter);
+ MWR_LOGD("Selected : %s", iter->engine_name.c_str());
+ }
+}
+
+bool CWakeupEngineManager::set_language(string language)
+{
+ for (const auto& info : mEngineInfo) {
+ if (info.interface.set_language) {
+ 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;
+}
+
+bool CWakeupEngineManager::set_assistant_language(string appid, string language)
+{
+ for (auto& info : mEngineInfo) {
+ const auto& iter = find_if(info.assistant_list.begin(), info.assistant_list.end(),
+ [appid](const string& assistant) {
+ return (0 == assistant.compare(appid));
+ });
+
+ /* If the appid is in the assistant list */
+ if (info.assistant_list.end() != iter) {
+ try {
+ int ret = info.interface.set_language(language.c_str());
+ MWR_LOGI("set_language returned %d : %s %s %s",
+ ret, appid.c_str(), info.engine_name.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());
+ }
+ }
+ }
+ return true;
+}
+
+void CWakeupEngineManager::set_assistant_activated(string appid, bool activated)
+{
+ MWR_LOGE("[ENTER] : %s %d", appid.c_str(), activated);
+ for (auto& info : mEngineInfo) {
+ const auto& iter = find_if(info.assistant_list.begin(), info.assistant_list.end(),
+ [appid](const string& assistant) {
+ return (0 == assistant.compare(appid));
+ });
+
+ /* If the appid is in the assistant list */
+ if (info.assistant_list.end() != iter) {
+ MWR_LOGI("%s has %s", info.engine_name.c_str(), appid.c_str());
+ bool previously_activated = info.activated;
+ if (activated) {
+ info.activated_assistants.insert(appid);
+ } else {
+ info.activated_assistants.erase(appid);
+ }
+ info.activated = (info.activated_assistants.size() > 0);
+ if (previously_activated != info.activated) {
+ if (info.activated) {
+ try {
+ info.interface.activate();
+ MWR_LOGW("Activating wakeup engine : %s", 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());
+ }
+ } else {
+ try {
+ info.interface.deactivate();
+ MWR_LOGW("Deactivating wakeup engine : %s", 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());
+ }
+ }
+ /* Activated status changed, need to update audio_data_require_status too */
+ on_audio_data_require_status(info.engine_name, info.audio_data_require_status);
+ }
+ } else {
+ MWR_LOGI("%s does not have %s", info.engine_name.c_str(), appid.c_str());
+ }
+ }
+}
+
+void CWakeupEngineManager::set_wake_word_audio_require_flag(bool require)
+{
+ MWR_LOGD("[ENTER]");
+ mWakeWordAudioRequired = require;
+ for (const auto& info : mEngineInfo) {
+ if (info.interface.set_wake_word_audio_require_flag) {
+ 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());
+ }
+ }
+ }
+}
+
+void CWakeupEngineManager::streaming_speech_data_thread_func()
+{
+ MWR_LOGE("[ENTER]");
+
+ if (nullptr == mSelectedEngine) {
+ MWR_LOGE("No Engine Selected");
+ return;
+ }
+
+ const wakeup_engine_interface *interface = &(mSelectedEngine->interface);
+
+ if (NULL == interface ||
+ NULL == interface->get_utterance_data ||
+ NULL == interface->get_utterance_data_count)
+ return;
+
+ MWR_LOGE("data_count : %s, %d",
+ mSelectedEngine->engine_name.c_str(),
+ interface->get_utterance_data_count());
+
+#ifdef BUF_SAVE_MODE
+ if (g_pFile) {
+ fclose(g_pFile);
+ g_pFile = NULL;
+ } else {
+ MWR_LOGD("[Recorder Info] File not found!");
+ }
+
+ while (1) {
+ snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/ma_wue_%d_%d", getpid(), g_count);
+ int ret = access(g_temp_file_name, 0);
+
+ if (0 == ret) {
+ MWR_LOGD("[Recorder ERROR] File is already exist");
+ if (0 == remove(g_temp_file_name)) {
+ MWR_LOGD("[Recorder] Remove file");
+ break;
+ } else {
+ g_count++;
+ }
+ } else {
+ break;
+ }
+ }
+
+ MWR_LOGD("[Recorder] Temp file name=[%s]", g_temp_file_name);
+
+ /* open test file */
+ g_pFile = fopen(g_temp_file_name, "wb+x");
+ if (!g_pFile) {
+ MWR_LOGD("[Recorder ERROR] File not found!");
+ return;
+ }
+ g_count++;
+#endif
+
+ mas_speech_data speech_data;
+ int index = 0;
+ bool finish_event_sent = false;
+
+ if (mWakeWordAudioRequired &&
+ NULL != interface->get_wake_word_data &&
+ NULL != interface->get_wake_word_data_count) {
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_audio_streaming_data_section(MA_AUDIO_STREAMING_DATA_SECTION_WAKE_WORD)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ int count = interface->get_wake_word_data_count();
+ while (!(mStopStreamingThread.load()) && index < count) {
+ int ret = interface->get_wake_word_data(index, &speech_data);
+ if (0 == ret) {
+#ifdef BUF_SAVE_MODE
+ if (g_pFile)
+ fwrite(speech_data.buffer, 1, speech_data.len, g_pFile);
+#endif
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_streaming_audio_data(
+ speech_data.event, speech_data.buffer, speech_data.len)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ } else {
+ break;
+ }
+ index++;
+ }
+ index = 0;
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_audio_streaming_data_section(MA_AUDIO_STREAMING_DATA_SECTION_UTTERANCE)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+
+ int burst_count = 0;
+ int sleep_count = 0;
+
+ while (!(mStopStreamingThread.load())) {
+ int ret = -1;
+ int cnt = 0;
+
+ /* get feedback data */
+ if (interface && interface->get_utterance_data) {
+ ret = interface->get_utterance_data(index, &speech_data);
+ mStreamingHistory.last_audio_fetched.store(get_current_milliseconds_after_epoch());
+
+ if (0 != ret) {
+ /* empty queue */
+ MWR_LOGI("[DEBUG] No feedback data. Waiting mode : %d %d", ret, cnt);
+
+ sleep_count = 0;
+ /* waiting */
+ while (!(mStopStreamingThread.load())) {
+ burst_count = 0;
+ if (++sleep_count >= 100) {
+ MWR_LOGI("Still waiting : %d %p %p", sleep_count,
+ interface->get_utterance_data,
+ interface->get_utterance_data_count);
+ sleep_count = 0;
+ }
+ this_thread::sleep_for(chrono::milliseconds(10));
+ if (index < interface->get_utterance_data_count()) {
+ MWR_LOGI("[INFO] Resume thread, %d", cnt);
+ break;
+ }
+ mStreamingHistory.last_count_fetched.store(get_current_milliseconds_after_epoch());
+ if (g_speech_pcm_wait_count < cnt) {
+ unsigned char final_buffer[2] = {'\0', };
+ MWR_LOGE("[ERROR] Wrong request, there's no pcm data : %d", cnt);
+#ifdef BUF_SAVE_MODE
+ if (g_pFile) {
+ fwrite(final_buffer, 1, sizeof(final_buffer), g_pFile);
+ MWR_LOGE("[Recorder SUCCESS] File Close");
+ fclose(g_pFile);
+ g_pFile = NULL;
+ }
+#endif
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FAIL, NULL, 0)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
+ }
+ }
+ return;
+ }
+ cnt++;
+ }
+ MWR_LOGD("[INFO] Finish to wait for new feedback data come");
+
+ /* resume feedback thread */
+ continue;
+ }
+
+#ifdef BUF_SAVE_MODE
+ if (g_pFile)
+ fwrite(speech_data.buffer, 1, speech_data.len, g_pFile);
+
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
+ if (g_pFile) {
+ MWR_LOGE("[Recorder SUCCESS] File Close");
+ fclose(g_pFile);
+ g_pFile = NULL;
+ } else {
+ MWR_LOGE("[Recorder ERROR] File not found!");
+ }
+ }
+#endif
+ const int sleep_duration_in_millis = 10;
+ const int max_burst_count = 3;
+ if (++burst_count >= max_burst_count) {
+ burst_count = 0;
+ MWR_LOGI("[INFO] Streaming data burst transmission detected, forcing sleep");
+ this_thread::sleep_for(chrono::milliseconds(sleep_duration_in_millis));
+ }
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_streaming_audio_data(
+ speech_data.event, speech_data.buffer, speech_data.len)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
+ }
+ }
+
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == speech_data.event) {
+ MWR_LOGE("[INFO] Finish to get and send speech data");
+ finish_event_sent = true;
+ break;
+ }
+
+ index++;
+ }
+ }
+ MWR_LOGE("[INFO] Streaming loop exit");
+
+ if (true != finish_event_sent) {
+ unsigned char final_buffer[2] = {'\0', };
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ MWR_LOGE("No FINISH event sent yet, adding to finalize streaming session");
+ if (!observer->on_streaming_audio_data(
+ MAS_SPEECH_STREAMING_EVENT_FINISH, final_buffer, sizeof(final_buffer))) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ mStreamingHistory.last_audio_sent.store(get_current_milliseconds_after_epoch());
+ }
+ }
+#ifdef BUF_SAVE_MODE
+ if (g_pFile) {
+ fwrite(final_buffer, 1, sizeof(final_buffer), g_pFile);
+ MWR_LOGE("[Recorder SUCCESS] File Close");
+ fclose(g_pFile);
+ g_pFile = NULL;
+ }
+#endif
+ }
+
+ MWR_LOGE("[EXIT]");
+}
+
+void CWakeupEngineManager::start_streaming_current_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGE("ERROR : mStreamingThread is joinable, will not start a new thread");
+ return;
+ }
+ mStreamingThread = thread(&CWakeupEngineManager::streaming_speech_data_thread_func, this);
+}
+
+void CWakeupEngineManager::stop_streaming_current_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (mStreamingThread.joinable()) {
+ MWR_LOGE("mStreamingThread is joinable, trying join() %lld %lld %lld %lld",
+ get_current_milliseconds_after_epoch(),
+ mStreamingHistory.last_audio_fetched.load(),
+ mStreamingHistory.last_count_fetched.load(),
+ mStreamingHistory.last_audio_sent.load());
+ mStopStreamingThread.store(true);
+ mStreamingThread.join();
+ }
+ mStopStreamingThread.store(false);
+}
+
+void CWakeupEngineManager::update_manager_state(wakeup_manager_state_e state)
+{
+ for (const auto& info : mEngineInfo) {
+ if (info.interface.update_manager_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());
+ }
+ }
+ }
+ mWakeupManagerState = state;
+}
+
+void CWakeupEngineManager::update_recognition_result(string appid, int result)
+{
+ if (mSelectedEngine) {
+ if (mSelectedEngine->interface.update_recognition_result) {
+ mSelectedEngine->interface.update_recognition_result(appid.c_str(), result);
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_add_target_assistant(string engine_name, string appid)
+{
+ 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) {
+ /* Not found, add new library */
+ pkgmgrinfo_appinfo_h handle;
+ int ret = pkgmgrinfo_appinfo_get_appinfo(engine_name.c_str(), &handle);
+ if (PMINFO_R_OK == ret) {
+ char *root_path = nullptr;
+ ret = pkgmgrinfo_appinfo_get_root_path(handle, &root_path);
+ if (PMINFO_R_OK == ret && nullptr != root_path) {
+ string path = root_path;
+ path += "/";
+ path += MA_WAKEUP_DEDICATED_ENGINE_PATH;
+ add_engine(engine_name, path);
+ }
+ pkgmgrinfo_appinfo_destroy_appinfo(handle);
+ }
+ /* Find again to add appid to the newly created engine's assistant list */
+ const auto &new_iter = find_if(mEngineInfo.begin(), mEngineInfo.end(),
+ [engine_name](const EngineInfo& info) {
+ return (0 == info.engine_name.compare(engine_name));
+ });
+ if (mEngineInfo.end() != new_iter) {
+ new_iter->assistant_list.push_back(appid);
+ for (const auto& assistant : new_iter->assistant_list) {
+ MWR_LOGI("Assistant List : %s %s", assistant.c_str(), new_iter->engine_name.c_str());
+ }
+ }
+ } else {
+ /* If the engine already exists, simply add the appid to the assistant list */
+ iter->assistant_list.push_back(appid);
+ for (const auto& assistant : iter->assistant_list) {
+ MWR_LOGI("Assistant List : %s %s", assistant.c_str(), iter->engine_name.c_str());
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_add_wakeup_word(string appid, string wakeup_word, string language)
+{
+ for (const auto& info : mEngineInfo) {
+ bool found = contains(info.assistant_list, appid);
+ if (found) {
+ if (info.interface.add_wakeup_word) {
+ 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());
+ }
+ } else {
+ MWR_LOGE("Wakeup Engine does not provide add_wakeup_word");
+ }
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_remove_wakeup_word(string appid, string wakeup_word, string language)
+{
+ for (const auto& info : mEngineInfo) {
+ bool found = contains(info.assistant_list, appid);
+ if (found) {
+ if (info.interface.remove_wakeup_word) {
+ try {
+ info.interface.remove_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());
+ }
+ } else {
+ MWR_LOGE("Wakeup Engine does not provide remove_wakeup_word");
+ }
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_set_assistant_specific_command(string appid, string command)
+{
+ for (const auto& info : mEngineInfo) {
+ bool found = contains(info.assistant_list, appid);
+ if (found) {
+ if (info.interface.set_assistant_specific_command) {
+ 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());
+ }
+ }
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_feed_audio_data(long time, void* data, int len)
+{
+ bool print = false;
+ const std::chrono::seconds interval(3);
+ static auto last = std::chrono::steady_clock::now();
+ auto now = std::chrono::steady_clock::now();
+ if (now - last > interval) {
+ print = true;
+ last = now;
+ }
+ for (const auto& info : mEngineInfo) {
+ bool filtered_out = false;
+ if (info.activated &&
+ info.audio_data_require_status &&
+ info.interface.feed_audio_data) {
+ try {
+ /* After a wakeup event, wakeup engines other than the selected one
+ does not need to receive audio data. */
+ if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
+ if (mSelectedEngine && &info != mSelectedEngine) {
+ filtered_out = true;
+ }
+ }
+ if (!filtered_out) {
+ int ret = info.interface.feed_audio_data(time, data, len);
+ if (ret != 0 || print) {
+ LOGE("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());
+ }
+ }
+ if (print) {
+ MWR_LOGE("Feeding audio data to %s : %d %d %p %d",
+ info.engine_name.c_str(),
+ info.activated, info.audio_data_require_status,
+ info.interface.feed_audio_data, filtered_out);
+ }
+ }
+}
+
+void CWakeupEngineManager::engine_set_dependency_module_command(string engine_name, string command)
+{
+ 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) {
+ if (iter->activated &&
+ iter->interface.set_dependency_module_command) {
+ try {
+ int ret = iter->interface.set_dependency_module_command(command.c_str());
+ if (0 != ret) {
+ LOGE("[ERROR] Fail to set dependency module command, ret(%d) : %s",
+ ret, iter->engine_name.c_str());
+ }
+ } catch (const std::exception& e) {
+ MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+ iter->engine_name.c_str(), e.what());
+ }
+ }
+ }
+}
+
+bool CWakeupEngineManager::on_wakeup_event(string engine_name, mas_wakeup_event_info info)
+{
+ MWR_LOGD("[ENTER]");
+
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_wakeup_event(engine_name, info)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+
+ return true;
+}
+
+bool CWakeupEngineManager::on_speech_status(string engine_name, mas_speech_status_e status)
+{
+ MWR_LOGD("[ENTER]");
+
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_speech_status(engine_name, status)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+
+ return true;
+}
+
+bool CWakeupEngineManager::on_error(string engine_name, int error_code, string error_message)
+{
+ MWR_LOGD("[ENTER]");
+
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_error(engine_name, error_code, error_message)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+
+ return true;
+}
+
+bool CWakeupEngineManager::on_audio_data_require_status(string engine_name, bool require)
+{
+ MWR_LOGI("[ENTER] %s, %d", engine_name.c_str(), require);
+
+ bool found = false;
+ // LOCK REQUIRED
+ int count = 0;
+ for (auto& info : mEngineInfo) {
+ if (info.engine_name.compare(engine_name) == 0) {
+ found = true;
+ info.audio_data_require_status = require;
+ }
+ if (info.activated && info.audio_data_require_status) {
+ count++;
+ }
+ }
+ MWR_LOGD("count : %d", count);
+ if (count > 0) {
+ mAudioDataRequired = true;
+ } else {
+ mAudioDataRequired = false;
+ }
+
+ if (found) {
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_audio_data_require_status(engine_name, require)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+ // UNLOCK REQUIRED
+ return true;
+}
+
+bool CWakeupEngineManager::on_wakeup_engine_command(string engine_name, mas_wakeup_engine_command_target_e target, string assistant_name, string command)
+{
+ MWR_LOGI("[ENTER] : %s %d %s %s",
+ engine_name.c_str(), target, assistant_name.c_str(), command.c_str());
+
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_DEPENDENCY_MODULE == target) {
+ if (!observer->on_wakeup_engine_command(target, engine_name, assistant_name, command)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ } else {
+ 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) ||
+ MAS_WAKEUP_ENGINE_COMMAND_TARGET_ALL_ASSISTANTS == target) {
+ MWR_LOGI("Calling on_wakeup_engine_command for %s", assistant.c_str());
+ if (!observer->on_wakeup_engine_command(target, engine_name, assistant, command)) {
+ LOGE("[Recorder WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+void CWakeupEngineManager::add_engine(string name, string path)
+{
+ MWR_LOGE("Name (%s), Filepath(%s)", name.c_str(), path.c_str());
+
+ char* error = NULL;
+ EngineInfo info;
+ info.engine_handle = dlopen(path.c_str(), RTLD_LAZY);
+ if (nullptr != (error = dlerror()) || nullptr == info.engine_handle) {
+ MWR_LOGE("[ERROR] Fail to dlopen(%s), error(%s)", path.c_str(), error);
+ if (info.engine_handle) dlclose(info.engine_handle);
+ info.engine_handle = nullptr;
+ return;
+ }
+
+ /* Interfaces without version information */
+ info.interface.initialize =
+ (wakeup_engine_initialize)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_INITIALIZE);
+ info.interface.deinitialize =
+ (wakeup_engine_deinitialize)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_DEINITIALIZE);
+ info.interface.activate =
+ (wakeup_engine_activate)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_ACTIVATE);
+ info.interface.deactivate =
+ (wakeup_engine_deactivate)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_DEACTIVATE);
+ info.interface.add_wakeup_word =
+ (wakeup_engine_add_wakeup_word)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_ADD_WAKEUP_WORD);
+ info.interface.remove_wakeup_word =
+ (wakeup_engine_remove_wakeup_word)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_REMOVE_WAKEUP_WORD);
+ info.interface.add_language =
+ (wakeup_engine_add_language)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_ADD_LANGUAGE);
+ info.interface.set_language =
+ (wakeup_engine_set_language)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_LANGUAGE);
+ info.interface.update_manager_state =
+ (wakeup_engine_update_manager_state)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_UPDATE_MANAGER_STATE);
+ info.interface.update_recognition_result =
+ (wakeup_engine_update_recognition_result)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_UPDATE_RECOGNITION_RESULT);
+ info.interface.set_audio_format =
+ (wakeup_engine_set_audio_format)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_AUDIO_FORMAT);
+ info.interface.get_audio_format =
+ (wakeup_engine_get_audio_format)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_AUDIO_FORMAT);
+ info.interface.feed_audio_data =
+ (wakeup_engine_feed_audio_data)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_FEED_AUDIO_DATA);
+ info.interface.get_utterance_data_count =
+ (wakeup_engine_get_utterance_data_count)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA_COUNT);
+ info.interface.get_utterance_data =
+ (wakeup_engine_get_utterance_data)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_UTTERANCE_DATA);
+ info.interface.get_wake_word_data_count =
+ (wakeup_engine_get_wake_word_data_count)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA_COUNT);
+ info.interface.get_wake_word_data =
+ (wakeup_engine_get_wake_word_data)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_WAKE_WORD_DATA);
+ info.interface.set_assistant_specific_command =
+ (wakeup_engine_set_assistant_specific_command)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_ASSISTANT_SPECIFIC_COMMAND);
+ info.interface.set_wake_word_audio_require_flag =
+ (wakeup_engine_set_wake_word_audio_require_flag)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_WAKE_WORD_AUDIO_REQUIRE_FLAG);
+ info.interface.set_wakeup_event_callback =
+ (wakeup_engine_set_wakeup_event_callback)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_WAKEUP_EVENT_CALLBACK);
+ info.interface.set_speech_status_callback =
+ (wakeup_engine_set_speech_status_callback)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_SPEECH_STATUS_CALLBACK);
+ info.interface.set_error_callback =
+ (wakeup_engine_set_error_callback)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_ERROR_CALLBACK);
+ 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 =
+ (wakeup_engine_get_version)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_GET_VERSION);
+ info.interface.set_dependency_module_command =
+ (wakeup_engine_set_dependency_module_command)dlsym(info.engine_handle,
+ MA_WAKEUP_ENGINE_FUNC_SET_DEPENDENCY_MODULE_COMMAND);
+
+ if (info.interface.initialize == nullptr) {
+ MWR_LOGE("[ERROR] Initialize interface does not exist, skipping %s", path.c_str());
+ if (info.engine_handle) dlclose(info.engine_handle);
+ info.engine_handle = nullptr;
+ return;
+ }
+
+ info.version = 0;
+ info.engine_path = path;
+ info.engine_name = name;
+
+ info.activated = false;
+ info.audio_data_require_status = false;
+
+ /* All the necessary information has already been set properly */
+ mEngineInfo.push_back(info);
+
+ /* Workaround for registering C-style callbacks */
+ typedef struct {
+ CWakeupEngineManager *manager;
+ string engine_name;
+ } CallbackUserData;
+
+ static deque<CallbackUserData> callback_user_data;
+
+ CallbackUserData user_data;
+ user_data.manager = this;
+ user_data.engine_name = info.engine_name;
+ callback_user_data.push_back(user_data);
+
+ MWR_LOGI("Initializing wakeup engine : %s %p %p",
+ info.engine_path.c_str(),
+ info.interface.initialize,
+ &callback_user_data.back());
+
+ try {
+ if (info.interface.set_wakeup_event_callback) {
+ info.interface.set_wakeup_event_callback(
+ [](mas_wakeup_event_info info, void* user_data) {
+ MWR_LOGI("user_data : %p", 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) {
+ MWR_LOGI("user_data : %p", 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_wakeup_engine_command_callback) {
+ info.interface.set_wakeup_engine_command_callback(
+ [](mas_wakeup_engine_command_target_e target,
+ const char* assistant_name, const char* command, void* user_data) {
+ MWR_LOGI("user_data : %p", 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, target, (assistant_name ? assistant_name : ""), command);
+ }, &(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;
+ }
+ }
+ } catch (const std::exception& e) {
+ MWR_LOGE("[ERROR] wakeup engine %s threw exception : %s",
+ info.engine_name.c_str(), e.what());
+ }
+}
+
+void CWakeupEngineManager::add_engine_directory(string name, string path)
+{
+ if (0 == path.size()) return;
+
+ DIR* dp = opendir(path.c_str());
+ if (NULL == dp) {
+ MWR_LOGD("Failed opening directory : %s", path.c_str());
+ } else {
+ struct dirent *dirp = NULL;
+ string filepath;
+ do {
+ dirp = readdir(dp);
+
+ if (NULL != dirp) {
+ if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
+ continue;
+
+ if (DT_REG != dirp->d_type) /* If not a regular file */
+ continue;
+
+ filepath = path;
+ filepath += "/";
+ filepath += dirp->d_name;
+
+ if (filepath.length() >= _POSIX_PATH_MAX) {
+ MWR_LOGD("File path is too long : %s", filepath.c_str());
+ closedir(dp);
+ return;
+ }
+ add_engine(name, filepath);
+ }
+ } while (NULL != dirp);
+
+ closedir(dp);
+ }
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "wakeup_manager.h"
+#include "wakeup_manager_main.h"
+#include "wakeup_policy_default.h"
+#include "wakeup_policy_external.h"
+#include "dependency_resolver.h"
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+
+#include <boost/optional.hpp>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+static bool check_language_valid(string language)
+{
+ bool valid = true;
+ if (0 == language.length()) {
+ valid = false;
+ }
+ return valid;
+}
+
+static bool initialize_wakeup_event_info(mas_wakeup_event_info* wakeup_info)
+{
+ bool ret = false;
+ if (wakeup_info) {
+ ret = true;
+
+ wakeup_info->wakeup_appid = nullptr;
+ wakeup_info->wakeup_word = nullptr;
+ wakeup_info->wakeup_language = nullptr;
+ wakeup_info->wakeup_voice_id = nullptr;
+ wakeup_info->wakeup_engine = nullptr;
+ wakeup_info->wakeup_confidence_score = 0.0f;
+
+ wakeup_info->wakeup_start_time = 0;
+ wakeup_info->wakeup_end_time = 0L;
+ wakeup_info->wakeup_time_valid = false;
+
+ wakeup_info->extra_data = nullptr;
+ wakeup_info->extra_data_length = 0;
+ wakeup_info->extra_data_description = nullptr;
+ }
+ return ret;
+}
+
+static map<string, string> get_custom_vconf_keys()
+{
+ map<string, string> vconf_keys;
+ char* custom_key = NULL;
+
+ vconf_keys.clear();
+ dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID, &custom_key);
+ vconf_keys.insert({WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID, custom_key ? custom_key : WAKEUP_VCONF_KEY_DEFAULT_ASSISTANT_APPID});
+
+ if (custom_key) {
+ free(custom_key);
+ custom_key = nullptr;
+ }
+
+ dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS, &custom_key);
+ vconf_keys.insert({WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS, custom_key ? custom_key : WAKEUP_VCONF_KEY_ENABLED_ASSISTANTS});
+
+ if (custom_key) {
+ free(custom_key);
+ custom_key = nullptr;
+ }
+
+ dependency_resolver_get_custom_vconf_key(WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED, &custom_key);
+ vconf_keys.insert({WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED, custom_key ? custom_key : WAKEUP_VCONF_KEY_WAKE_WORD_DETECTION_ENABLED});
+
+ if (custom_key) {
+ free(custom_key);
+ custom_key = nullptr;
+ }
+
+ return vconf_keys;
+}
+
+CWakeupManager::CWakeupManager(IWakeupEventObserver* wakeup_observer, ISettingValueObserver* setting_observer)
+{
+ initialize_wakeup_event_info(&mLastWakeupEventInfo);
+
+ if (wakeup_observer) {
+ subscribe_wakeup_observer(wakeup_observer);
+ }
+ if (setting_observer) {
+ subscribe_setting_observer(setting_observer);
+ }
+}
+
+CWakeupManager::~CWakeupManager()
+{
+ MWR_LOGI("Wakeup Manager is now being destroyed");
+}
+
+void CWakeupManager::initialize_wakeup_policy()
+{
+ mWakeupPolicy.reset(new CWakeupPolicyExternal{&mPolicyEventObserver});
+ if (nullptr == mWakeupPolicy || !(mWakeupPolicy->valid())) {
+ mWakeupPolicy.reset(new CWakeupPolicyDefault{&mPolicyEventObserver});
+
+ /* Default Policy specific initialization */
+ CWakeupPolicyDefault *policy =
+ dynamic_cast<CWakeupPolicyDefault*>(mWakeupPolicy.get());
+ if (policy) {
+ int priority = 0;
+
+ policy->set_delay(mWakeupSettings.get_wakeup_policy_delay());
+ MWR_LOGD("Setting Delay : %f", mWakeupSettings.get_wakeup_policy_delay());
+ for (const auto& assistant : mWakeupSettings.get_wakeup_policy_priority()) {
+ policy->set_assistant_priority(assistant, ++priority);
+ MWR_LOGD("Setting Priority : %d %s", priority, assistant.c_str());
+ }
+ }
+ }
+}
+
+bool CWakeupManager::initialize()
+{
+ MWR_LOGE("[ENTER]");
+ std::cerr << "WakeupManager Initialize" << std::endl;
+
+ mPolicyEventObserver.set_wakeup_manager(this);
+ mEngineEventObserver.set_wakeup_manager(this);
+ mAudioEventObserver.set_wakeup_manager(this);
+ mSettingsEventObserver.set_wakeup_manager(this);
+
+ mas_dependency_plugin_proxy_interface interface;
+ interface.process_event = wakeup_manager_process_plugin_event;
+ interface.feed_audio_data = wakeup_manager_feed_audio_data;
+ interface.send_command = wakeup_manager_set_dependency_module_command;
+ interface.wakeup_assistant = wakeup_manager_wakeup_assistant;
+
+ dependency_resolver_initialize(interface);
+
+ mWakeupSettings.subscribe(&mSettingsEventObserver);
+ mWakeupSettings.initialize(get_custom_vconf_keys());
+
+ mAudioEventObserver.set_wakeup_engine_manager(&mWakeupEngineManager);
+ mAudioManager.subscribe(&mAudioEventObserver);
+ mAudioManager.initialize();
+
+ mWakeupEngineManager.subscribe(&mEngineEventObserver);
+ mWakeupEngineManager.initialize();
+
+ mAssistantConfigManager.initialize();
+
+ initialize_wakeup_policy();
+ start_periodic_monitor_timer();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::deinitialize()
+{
+ MWR_LOGE("[ENTER]");
+ std::cerr << "WakeupManager Deinitialize" << std::endl;
+
+ stop_periodic_monitor_timer();
+ stop_streaming_duration_timer();
+
+ dependency_resolver_deinitialize();
+
+ mAssistantConfigManager.deinitialize();
+
+ mWakeupEngineManager.unsubscribe(&mEngineEventObserver);
+ mWakeupEngineManager.deinitialize();
+
+ mAudioManager.unsubscribe(&mAudioEventObserver);
+ mAudioManager.deinitialize();
+
+ mWakeupSettings.deinitialize();
+ mAssistantLanguageInfo.clear();
+
+ MWR_LOGE("[END]");
+ return true;
+}
+
+void CWakeupManager::subscribe_wakeup_observer(IWakeupEventObserver *observer)
+{
+ mWakeupObservers.push_back(observer);
+}
+
+void CWakeupManager::unsubscribe_wakeup_observer(IWakeupEventObserver *observer)
+{
+ auto iter = find(mWakeupObservers.begin(), mWakeupObservers.end(), observer);
+ if (iter != mWakeupObservers.end()) {
+ mWakeupObservers.erase(iter);
+ }
+}
+
+void CWakeupManager::subscribe_setting_observer(ISettingValueObserver* observer)
+{
+ mSettingObservers.push_back(observer);
+}
+
+void CWakeupManager::unsubscribe_setting_observer(ISettingValueObserver* observer)
+{
+ auto iter = find(mSettingObservers.begin(), mSettingObservers.end(), observer);
+ if (iter != mSettingObservers.end()) {
+ mSettingObservers.erase(iter);
+ }
+}
+
+bool CWakeupManager::activate(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (WAKEUP_MANAGER_STATE_INACTIVE != mWakeupManagerState)
+ return false;
+
+ /* Activate assistants that supports current voice input language */
+ set_language(mWakeupSettings.get_current_language());
+
+ change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
+ if (mWakeupEngineManager.get_audio_data_required()) {
+ mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ mAudioManager.start_recording(true);
+ }
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::deactivate(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManagerState)
+ return false;
+
+ mAudioManager.stop_recording(true);
+ mRecordingByVoiceKey = false;
+ change_manager_state(WAKEUP_MANAGER_STATE_INACTIVE);
+
+ stop_streaming_utterance_data();
+ stop_streaming_previous_utterance_data();
+ stop_streaming_follow_up_data();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::add_assistant_language(string appid, string language)
+{
+ MWR_LOGI("[ENTER]");
+ bool found = false;
+ for (auto& info : mAssistantLanguageInfo) {
+ if(0 == info.appid.compare(appid)) {
+ info.languageList.push_back(language);
+ found = true;
+ }
+ }
+ if(false == found) {
+ AssistantLanguageInfo info;
+ info.appid = appid;
+ info.languageList.push_back(language);
+ mAssistantLanguageInfo.push_back(info);
+ }
+ if (0 == mCurrentLanguage.compare(language)) {
+ mAssistantSupportsCurrentLanguage[appid] = true;
+ if (true == mAssistantEnabled[appid]) {
+ mWakeupEngineManager.set_assistant_activated(appid, true);
+ }
+ }
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::add_assistant_wakeup_word(string appid, string wakeup_word, string language)
+{
+ MWR_LOGI("[ENTER]");
+
+ mWakeupEngineManager.engine_add_wakeup_word(appid, wakeup_word, language);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::remove_assistant_wakeup_word(string appid, string wakeup_word, string language)
+{
+ MWR_LOGI("[ENTER]");
+
+ mWakeupEngineManager.engine_remove_wakeup_word(appid, wakeup_word, language);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::add_assistant_wakeup_engine(string appid, string engine)
+{
+ MWR_LOGI("[ENTER] %s %s", appid.c_str(), engine.c_str());
+
+ vector<string> disabled_assistants = mWakeupSettings.get_wake_word_disabled_assistants();
+ auto iter = find(disabled_assistants.begin(), disabled_assistants.end(), appid);
+ if (iter != disabled_assistants.end())
+ return true;
+
+ bool found = false;
+ if (mWakeupSettings.get_multiple_mode()) {
+ vector<string> assistants = mWakeupSettings.get_enabled_assistants();
+ 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;
+}
+
+bool CWakeupManager::set_assistant_language(string appid, string language)
+{
+ MWR_LOGI("[ENTER] : %s, %s", appid.c_str(), language.c_str());
+
+ mWakeupEngineManager.set_assistant_language(appid, language);
+ mAssistantConfigManager.set_assistant_language(appid, language);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_assistant_enabled(string appid, bool enabled)
+{
+ MWR_LOGI("[ENTER]");
+
+ mAssistantEnabled[appid] = enabled;
+ bool activated = enabled;
+ if (false == mAssistantSupportsCurrentLanguage[appid]) {
+ activated = false;
+ }
+ if (0 == appid.compare(mWakeupSettings.get_default_assistant_appid())) {
+ activated = true;
+ }
+ mWakeupEngineManager.set_assistant_activated(appid, activated);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_default_assistant(string appid)
+{
+ MWR_LOGE("[ENTER] %s %s", appid.c_str(), mCurrentDefaultAssistant.c_str());
+
+ /* Passing 'expected' as true since MAS is changing the default assistant config */
+ process_default_assistant_changed(appid, true);
+
+ mWakeupSettings.set_default_assistant_appid(appid);
+
+ return true;
+}
+
+bool CWakeupManager::process_default_assistant_changed(string appid, bool expected)
+{
+ MWR_LOGE("[ENTER] %s %s", appid.c_str(), mCurrentDefaultAssistant.c_str());
+
+ if (mCurrentDefaultAssistant.compare(appid) == 0) {
+ MWR_LOGE("Default assistant appid not changed, ignoring...");
+ return false;
+ }
+
+ if (mWakeupManagerState == WAKEUP_MANAGER_STATE_UTTERANCE ||
+ mWakeupManagerState == WAKEUP_MANAGER_STATE_PROCESSING) {
+ if (expected) {
+ stop_streaming_utterance_data();
+ stop_streaming_previous_utterance_data();
+ stop_streaming_follow_up_data();
+
+ mWakeupEngineManager.update_recognition_result(appid, MA_RECOGNITION_RESULT_EVENT_ERROR);
+ } else {
+ /* If this is an unexpected change, invalidate previous recognition process */
+ update_recognition_result(mCurrentDefaultAssistant, MA_RECOGNITION_RESULT_EVENT_ERROR);
+ }
+ }
+
+ /* Check if previous default assistant has to be deactivated */
+ bool activated = true;
+ if (false == mAssistantSupportsCurrentLanguage[mCurrentDefaultAssistant]) {
+ activated = false;
+ }
+ if (false == mAssistantEnabled[mCurrentDefaultAssistant]) {
+ activated = false;
+ }
+ mWakeupEngineManager.set_assistant_activated(mCurrentDefaultAssistant, activated);
+
+ /* New default assistant has to be activated no matter what */
+ mWakeupEngineManager.set_assistant_activated(appid, true);
+
+ mCurrentDefaultAssistant = appid;
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+string CWakeupManager::get_default_assistant()
+{
+ return mWakeupSettings.get_default_assistant_appid();
+}
+
+bool CWakeupManager::get_assistant_enabled(string appid)
+{
+ return mAssistantEnabled[appid];
+}
+
+bool CWakeupManager::set_language(string language)
+{
+ bool valid = false;
+ MWR_LOGI("[ENTER] : %s", language.c_str());
+
+ if (check_language_valid(language)) {
+ mCurrentLanguage = language;
+ valid = true;
+ } else {
+ MWR_LOGE("[ERROR] Invalid language (%s)", language.c_str());
+ }
+
+ for (auto& info : mAssistantLanguageInfo) {
+ bool disable = false;
+ if (valid) {
+ bool supported = false;
+ if (info.languageList.end() !=
+ find(info.languageList.begin(), info.languageList.end(), language)) {
+ supported = true;
+ }
+ mAssistantSupportsCurrentLanguage[info.appid] = supported;
+ /* Disable this assistant if language not supported */
+ if (!supported) disable = true;
+ } else {
+ /* If current language is not valid, assume all languages support it */
+ mAssistantSupportsCurrentLanguage[info.appid] = true;
+ }
+
+ if (false == mAssistantEnabled[info.appid]) {
+ disable = true;
+ }
+ if (0 == info.appid.compare(mWakeupSettings.get_default_assistant_appid())) {
+ /* Default Assistant should be activated no matter what */
+ disable = false;
+ }
+ mWakeupEngineManager.set_assistant_activated(info.appid, !disable);
+ std::string assistant_language;
+ int ret = mAssistantConfigManager.get_assistant_language(info.appid, assistant_language);
+ if (0 != ret || !check_language_valid(assistant_language)) {
+ mWakeupEngineManager.set_assistant_language(info.appid, language);
+ } else {
+ mWakeupEngineManager.set_assistant_language(info.appid, assistant_language);
+ }
+ }
+
+ MWR_LOGD("[END]");
+ return valid;
+}
+
+bool CWakeupManager::get_recording_by_voice_key()
+{
+ return mRecordingByVoiceKey;
+}
+
+void CWakeupManager::set_recording_by_voice_key(bool recording)
+{
+ mRecordingByVoiceKey = recording;
+}
+
+STREAMING_MODE CWakeupManager::get_streaming_mode()
+{
+ return mStreamingMode;
+}
+
+bool CWakeupManager::set_streaming_mode(STREAMING_MODE mode)
+{
+ lock_guard<mutex> lock(mMutex);
+ mStreamingMode = mode;
+ return true;
+}
+
+bool CWakeupManager::change_manager_state(wakeup_manager_state_e state)
+{
+ MWR_LOGI("[ENTER] : %d", state);
+ mWakeupManagerState = state;
+ mWakeupEngineManager.update_manager_state(state);
+ for (const auto& observer : mWakeupObservers) {
+ observer->on_wakeup_service_state_changed((ma_service_state_e)state);
+ }
+ return true;
+}
+
+wakeup_manager_state_e CWakeupManager::get_manager_state()
+{
+ return mWakeupManagerState;
+}
+
+bool CWakeupManager::update_voice_feedback_state(string appid, bool state)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (state) {
+ if (WAKEUP_MANAGER_STATE_LISTENING == mWakeupManagerState ||
+ WAKEUP_MANAGER_STATE_PROCESSING == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_VOICE_FEEDBACK);
+ }
+ } else {
+ if (WAKEUP_MANAGER_STATE_VOICE_FEEDBACK == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
+ }
+ }
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_assistant_specific_command(string appid, string command)
+{
+ MWR_LOGI("[ENTER]");
+
+ /*
+ static const string voice_key_pressed{"voice_key_pressed"};
+ static const string voice_key_released{"voice_key_released"};
+
+ if (0 == command.compare(voice_key_pressed)) {
+ process_event(MA_PLUGIN_EVENT_VOICE_KEY_PRESSED, NULL, 0);
+ } else if (0 == command.compare(voice_key_released)) {
+ process_event(MA_PLUGIN_EVENT_VOICE_KEY_RELEASED, NULL, 0);
+ }
+ */
+
+ mWakeupEngineManager.engine_set_assistant_specific_command(appid, command);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_background_volume(string appid, double ratio)
+{
+ MWR_LOGD("[DEBUG] set background volume (%f)", ratio);
+
+ int ret = 0;
+ mAudioManager.set_background_volume(ratio);
+ return ret;
+}
+
+bool CWakeupManager::update_recognition_result(string appid, int result)
+{
+ MWR_LOGI("[ENTER]");
+
+ stop_streaming_utterance_data();
+ stop_streaming_previous_utterance_data();
+ stop_streaming_follow_up_data();
+
+ mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ mWakeupEngineManager.update_recognition_result(appid, result);
+ if (WAKEUP_MANAGER_STATE_PROCESSING == mWakeupManagerState ||
+ WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
+ }
+ MWR_LOGD("[END]");
+ return true;
+}
+
+static long long get_current_milliseconds_after_epoch()
+{
+ auto now = chrono::steady_clock::now();
+ auto now_ms = chrono::time_point_cast<chrono::milliseconds>(now);
+ /* number of milliseconds since the epoch of system_clock */
+ auto value = now_ms.time_since_epoch();
+
+ return value.count();
+}
+
+bool CWakeupManager::process_plugin_event(mas_plugin_event_e event, void* data, int len)
+{
+ MWR_LOGE("[ENTER] : %d", event);
+ if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManagerState)
+ return false;
+
+ bool start_recording = false;
+ bool stop_recording = false;
+
+ boost::optional<ma_voice_key_status_e> next_voice_key_status;
+ if (MAS_PLUGIN_EVENT_VOICE_KEY_PRESSED == event) {
+ if (STREAMING_MODE::FOLLOW_UP == mStreamingMode) {
+ MWR_LOGE("Voice key pressed, but currently streaming follow_up audio");
+ } else {
+ if (VOICE_KEY_SUPPORT_MODE_NONE != mCurrentVoiceKeySupportMode) {
+ start_recording = true;
+ }
+ }
+ next_voice_key_status = MA_VOICE_KEY_STATUS_PRESSED;
+ } else if (MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_PUSH == event) {
+ if (VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK == mCurrentVoiceKeySupportMode ||
+ VOICE_KEY_SUPPORT_MODE_ALL == mCurrentVoiceKeySupportMode) {
+ stop_recording = true;
+ }
+ next_voice_key_status = MA_VOICE_KEY_STATUS_RELEASED_AFTER_PUSH;
+ } else if (MAS_PLUGIN_EVENT_VOICE_KEY_RELEASED_AFTER_TAP == event) {
+ if (VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK == mCurrentVoiceKeySupportMode) {
+ stop_recording = true;
+ }
+ next_voice_key_status = MA_VOICE_KEY_STATUS_RELEASED_AFTER_TAP;
+ }
+
+ if (start_recording) {
+ mRecordingByVoiceKey = true;
+
+ mAudioManager.stop_recording(true);
+
+ stop_streaming_utterance_data();
+ stop_streaming_previous_utterance_data();
+ stop_streaming_follow_up_data();
+
+ mAudioManager.clear_audio_data();
+ change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
+
+ /* Start recorder thread using appropriate recording device */
+ mAudioManager.set_recording_session(RECORDING_SESSION_UTTERANCE);
+ mAudioManager.start_recording(true);
+
+ /* Wakeup default assistant */
+ /* TODO: apply conversation timeout for selecting assistant here */
+ mas_wakeup_event_info wakeup_info;
+ initialize_wakeup_event_info(&wakeup_info);
+ /* Make sure to use background data */
+ wakeup_info.wakeup_time_valid = true;
+ wakeup_info.wakeup_end_time = get_current_milliseconds_after_epoch();
+ wakeup_info.wakeup_engine = WAKEUP_ENGINE_VOICE_KEY;
+
+ std::string default_assistant_appid = mWakeupSettings.get_default_assistant_appid();
+ wakeup_info.wakeup_appid = default_assistant_appid.c_str();
+ MWR_LOGD("wakeup_appid : %s", wakeup_info.wakeup_appid);
+
+ set_last_wakeup_event_info(wakeup_info);
+ mWakeupEngineManager.set_selected_wakeup_info(wakeup_info);
+ for (const auto& observer : mWakeupObservers) {
+ observer->on_wakeup(wakeup_info);
+ }
+ }
+ if (stop_recording) {
+ mRecordingByVoiceKey = false;
+
+ stop_streaming_duration_timer();
+ mAudioManager.finalize_audio_data();
+
+ if (STREAMING_MODE::UTTERANCE == mStreamingMode) {
+ change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
+ } else {
+ change_manager_state(WAKEUP_MANAGER_STATE_LISTENING);
+ }
+
+ mAudioManager.stop_recording(true);
+ mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ if (mWakeupEngineManager.get_audio_data_required()) {
+ /* Restart recorder thread using appropriate recording device */
+ mAudioManager.start_recording(true);
+ }
+ }
+
+ if (next_voice_key_status) {
+ update_voice_key_status(*next_voice_key_status);
+ }
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+void CWakeupManager::set_streaming_completed(bool completed)
+{
+ MWR_LOGI("[ENTER] : %d", completed);
+ mStreamingCompleted.store(completed);
+
+ /* When Streaming completes, update pending voice key status */
+ update_pending_voice_key_status();
+}
+
+void CWakeupManager::start_voice_key_status_update_timer()
+{
+ const float VOICE_KEY_STATUS_UPDATE_INTERVAL = 5.0f;
+
+ if (mVoiceKeyStatusUpdateTimer) {
+ ecore_timer_del(mVoiceKeyStatusUpdateTimer);
+ }
+
+ mVoiceKeyStatusUpdateTimer = ecore_timer_add(VOICE_KEY_STATUS_UPDATE_INTERVAL,
+ [](void *data) {
+ MAS_LOGE("voice_key_status_update_timer expired");
+ auto manager = static_cast<CWakeupManager*>(data);
+ manager->update_pending_voice_key_status();
+ return ECORE_CALLBACK_CANCEL;
+ }, static_cast<void*>(this));
+}
+
+void CWakeupManager::update_pending_voice_key_status()
+{
+ MAS_LOGI("[ENTER]");
+ if (mVoiceKeyStatusUpdateTimer) {
+ ecore_timer_del(mVoiceKeyStatusUpdateTimer);
+ mVoiceKeyStatusUpdateTimer = nullptr;
+ }
+ if (mPendingVoiceKeyStatus) {
+ for (const auto& observer : mWakeupObservers) {
+ observer->on_voice_key_status_changed(*mPendingVoiceKeyStatus);
+ }
+ mPendingVoiceKeyStatus = boost::none;
+ }
+}
+
+void CWakeupManager::update_voice_key_status(ma_voice_key_status_e status)
+{
+ MWR_LOGI("status : %d", status);
+ if (mPendingVoiceKeyStatus) {
+ for (const auto& observer : mWakeupObservers) {
+ observer->on_voice_key_status_changed(*mPendingVoiceKeyStatus);
+ }
+ mPendingVoiceKeyStatus = boost::none;
+ }
+
+ /* If streaming has not been completed yet after pressed event,
+ * postpone the status update until streaming is completed */
+ bool postpone = false;
+ if (status == MA_VOICE_KEY_STATUS_RELEASED_AFTER_PUSH) {
+ if (!mStreamingCompleted.load()) {
+ postpone = true;
+ }
+ }
+
+ if (postpone) {
+ mPendingVoiceKeyStatus = status;
+ start_voice_key_status_update_timer();
+ } else {
+ for (const auto& observer : mWakeupObservers) {
+ observer->on_voice_key_status_changed(status);
+ }
+ }
+
+ if (status == MA_VOICE_KEY_STATUS_PRESSED) {
+ mStreamingCompleted.store(false);
+ }
+}
+
+vector<IWakeupEventObserver*> CWakeupManager::get_wakeup_observers()
+{
+ return mWakeupObservers;
+}
+
+void CWakeupManager::set_last_wakeup_event_info(mas_wakeup_event_info wakeup_info)
+{
+ mLastWakeupEventInfo = wakeup_info;
+ mLastWakeupEventID++;
+}
+
+vector<ISettingValueObserver*> CWakeupManager::get_setting_observers()
+{
+ return mSettingObservers;
+}
+
+static Eina_Bool streaming_duration_expired(void *data)
+{
+ MWR_LOGW("[ENTER]");
+ CWakeupManager *wakeup_manager = static_cast<CWakeupManager*>(data);
+ if (nullptr == wakeup_manager) return ECORE_CALLBACK_CANCEL;
+
+ wakeup_manager->set_streaming_duration_timer(nullptr);
+
+ CAudioManager *audio_manager = wakeup_manager->get_audio_manager();
+ CWakeupEngineManager *engine_manager = wakeup_manager->get_engine_manager();
+
+ if (nullptr == audio_manager) return ECORE_CALLBACK_CANCEL;
+ if (nullptr == engine_manager) return ECORE_CALLBACK_CANCEL;
+
+ switch(wakeup_manager->get_streaming_mode()) {
+ case STREAMING_MODE::UTTERANCE:
+ audio_manager->stop_streaming_current_utterance_data();
+ engine_manager->stop_streaming_current_utterance_data();
+ break;
+ case STREAMING_MODE::PREVIOUS_UTTERANCE:
+ audio_manager->stop_streaming_previous_utterance_data();
+ break;
+ case STREAMING_MODE::FOLLOW_UP:
+ audio_manager->stop_streaming_follow_up_data();
+ audio_manager->stop_recording(true);
+ wakeup_manager->set_recording_by_voice_key(false);
+ audio_manager->clear_audio_data();
+ break;
+ }
+
+ wakeup_manager->set_streaming_mode(STREAMING_MODE::NONE);
+
+ if (WAKEUP_MANAGER_STATE_UTTERANCE == wakeup_manager->get_manager_state()) {
+ audio_manager->stop_recording(true);
+ wakeup_manager->set_recording_by_voice_key(false);
+ audio_manager->set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ if (engine_manager->get_audio_data_required()) {
+ /* Restart recorder thread using appropriate recording device */
+ audio_manager->start_recording(true);
+ }
+ wakeup_manager->change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
+ }
+
+ return ECORE_CALLBACK_CANCEL;
+}
+
+bool CWakeupManager::start_streaming_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+
+ if (mCurrentStreamingSessionID == mLastWakeupEventID) {
+ MWR_LOGW("Streaming already started for this session");
+ return false;
+ }
+
+ mCurrentStreamingSessionID = mLastWakeupEventID;
+
+ mAudioManager.stop_streaming_current_utterance_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ mStreamingMode = STREAMING_MODE::UTTERANCE;
+
+ bool streaming_by_manager = true;
+ if (false == mLastWakeupEventInfo.wakeup_time_valid) {
+ mWakeupEngineManager.start_streaming_current_utterance_data();
+ streaming_by_manager = false;
+ } else {
+ mAudioManager.start_streaming_current_utterance_data(mLastWakeupEventInfo.wakeup_end_time);
+ }
+
+ stop_streaming_duration_timer();
+ if (streaming_by_manager) {
+ start_streaming_duration_timer();
+ }
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::stop_streaming_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+
+ if (STREAMING_MODE::UTTERANCE != mStreamingMode) return false;
+
+ mAudioManager.stop_streaming_current_utterance_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ if (mStreamingDurationTimer) {
+ stop_streaming_duration_timer();
+ }
+ if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
+ mAudioManager.stop_recording(true);
+ mRecordingByVoiceKey = false;
+ mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ if (mWakeupEngineManager.get_audio_data_required()) {
+ /* Restart recorder thread using appropriate recording device */
+ mAudioManager.start_recording(true);
+ }
+ }
+
+ mStreamingMode = STREAMING_MODE::NONE;
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::start_streaming_follow_up_data()
+{
+ MWR_LOGI("[ENTER]");
+
+ mAudioManager.stop_streaming_follow_up_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ mStreamingMode = STREAMING_MODE::FOLLOW_UP;
+
+ /* For the follow up streaming, audio data should be recorded from now on */
+ mAudioManager.stop_recording(true);
+ mAudioManager.clear_audio_data();
+ change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
+ mAudioManager.set_recording_session(RECORDING_SESSION_FOLLOW_UP);
+ mAudioManager.start_recording(true);
+
+ mAudioManager.start_streaming_follow_up_data();
+
+ stop_streaming_duration_timer();
+ start_streaming_duration_timer();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::stop_streaming_follow_up_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (STREAMING_MODE::FOLLOW_UP != mStreamingMode) return false;
+
+ mAudioManager.stop_streaming_follow_up_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ if (mStreamingDurationTimer) {
+ stop_streaming_duration_timer();
+ }
+
+ if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
+ mAudioManager.stop_recording(true);
+ mRecordingByVoiceKey = false;
+ mAudioManager.set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ if (mWakeupEngineManager.get_audio_data_required()) {
+ /* Restart recorder thread using appropriate recording device */
+ mAudioManager.start_recording(true);
+ }
+ }
+
+ mStreamingMode = STREAMING_MODE::NONE;
+
+ mAudioManager.clear_audio_data();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::start_streaming_previous_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+
+ mAudioManager.stop_streaming_previous_utterance_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ mStreamingMode = STREAMING_MODE::PREVIOUS_UTTERANCE;
+ mAudioManager.start_streaming_previous_utterance_data();
+
+ stop_streaming_duration_timer();
+ start_streaming_duration_timer();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::stop_streaming_previous_utterance_data()
+{
+ MWR_LOGI("[ENTER]");
+ if (STREAMING_MODE::PREVIOUS_UTTERANCE != mStreamingMode) return false;
+
+ mAudioManager.stop_streaming_previous_utterance_data();
+ mWakeupEngineManager.stop_streaming_current_utterance_data();
+
+ if (mStreamingDurationTimer) {
+ stop_streaming_duration_timer();
+ }
+
+ if (WAKEUP_MANAGER_STATE_UTTERANCE == mWakeupManagerState) {
+ change_manager_state(WAKEUP_MANAGER_STATE_PROCESSING);
+ }
+
+ mStreamingMode = STREAMING_MODE::NONE;
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::get_audio_format(int* rate, int* channel, int* audio_type)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (!audio_type || !rate || !channel) {
+ MWR_LOGE("[ERROR] Invalid parameter");
+ return false;
+ }
+
+ dependency_resolver_get_audio_format(rate, channel, audio_type);
+
+ MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
+ return true;
+}
+
+bool CWakeupManager::get_audio_source_type(char** type)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (!type) {
+ MWR_LOGE("[ERROR] Invalid parameter");
+ return false;
+ }
+
+ dependency_resolver_get_audio_source_type(type);
+
+ MWR_LOGD("[END] type(%s)", *type);
+ return true;
+}
+
+bool CWakeupManager::set_wake_word_audio_require_flag(bool require)
+{
+ MWR_LOGI("[ENTER]");
+
+ mWakeupEngineManager.set_wake_word_audio_require_flag(require);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_voice_key_tap_duration(float duration)
+{
+ MWR_LOGI("[ENTER]");
+
+ dependency_resolver_set_voice_key_tap_duration(duration);
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::unset_voice_key_tap_duration()
+{
+ MWR_LOGI("[ENTER]");
+
+ dependency_resolver_unset_voice_key_tap_duration();
+
+ MWR_LOGD("[END]");
+ return true;
+}
+
+bool CWakeupManager::set_voice_key_support_mode(VOICE_KEY_SUPPORT_MODE mode)
+{
+ MWR_LOGI("Voice key support mode : %d", mode);
+ mCurrentVoiceKeySupportMode = mode;
+
+ char* support_mode = NULL;
+ switch (mode)
+ {
+ case VOICE_KEY_SUPPORT_MODE_NONE:
+ support_mode = strdup("none");
+ break;
+ case VOICE_KEY_SUPPORT_MODE_PUSH_TO_TALK:
+ support_mode = strdup("push_to_talk");
+ break;
+ case VOICE_KEY_SUPPORT_MODE_TAP_TO_TALK:
+ support_mode = strdup("tap_to_talk");
+ break;
+ case VOICE_KEY_SUPPORT_MODE_ALL:
+ support_mode = strdup("all");
+ break;
+ default:
+ support_mode = strdup("none");
+ break;
+ }
+
+ dependency_resolver_set_voice_key_support_mode(support_mode);
+
+ if (support_mode)
+ free(support_mode);
+
+ return true;
+}
+
+CWakeupPolicy* CWakeupManager::get_wakeup_policy()
+{
+ return mWakeupPolicy.get();
+}
+
+CWakeupEngineManager* CWakeupManager::get_engine_manager()
+{
+ return &mWakeupEngineManager;
+}
+
+CAudioManager* CWakeupManager::get_audio_manager()
+{
+ return &mAudioManager;
+}
+
+CWakeupSettings* CWakeupManager::get_wakeup_settings()
+{
+ return &mWakeupSettings;
+}
+
+void CWakeupManager::feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
+{
+ const std::chrono::seconds interval(5);
+ static auto last = std::chrono::steady_clock::now();
+ auto now = std::chrono::steady_clock::now();
+ if (now - last > interval) {
+ std::cerr << "Feeding Audio : " << len << std::endl;
+ last = now;
+ }
+
+ mAudioManager.feed_audio_data(event, buffer, len);
+}
+
+void CWakeupManager::set_dependency_module_command(string engine_name, string command)
+{
+ mWakeupEngineManager.engine_set_dependency_module_command(engine_name, command);
+}
+
+static Eina_Bool periodic_monitor_func(void *data)
+{
+ std::cerr << "MAS PERIODIC HEALTH CHECK" << std::endl;
+ return ECORE_CALLBACK_RENEW;
+}
+
+void CWakeupManager::start_periodic_monitor_timer()
+{
+ MWR_LOGI("MONITOR_TIMER START");
+ mPeriodicMonitorTimer = ecore_timer_add(
+ 30.0f,
+ periodic_monitor_func, nullptr);
+}
+
+void CWakeupManager::stop_periodic_monitor_timer()
+{
+ if (mPeriodicMonitorTimer) {
+ ecore_timer_del(mPeriodicMonitorTimer);
+ mPeriodicMonitorTimer = nullptr;
+ }
+}
+
+void CWakeupManager::start_streaming_duration_timer()
+{
+ MWR_LOGI("DURATION_TIMER START");
+ ecore_main_loop_thread_safe_call_async([](void* data) {
+ MWR_LOGI("DURATION_TIMER START - async");
+ CWakeupManager* manager = static_cast<CWakeupManager*>(data);
+ if (!manager) return;
+
+ CWakeupSettings *settings = manager->get_wakeup_settings();
+ if (settings) {
+ Ecore_Timer* timer = ecore_timer_add(
+ settings->get_streaming_duration_max(),
+ streaming_duration_expired, manager);
+ manager->set_streaming_duration_timer(timer);
+ MWR_LOGI("DURATION_TIMER STARTED : %p", timer);
+ }
+ }, this);
+}
+
+void CWakeupManager::stop_streaming_duration_timer()
+{
+ MWR_LOGI("DURATION_TIMER STOP");
+ if (mStreamingDurationTimer) {
+ MWR_LOGI("DURATION_TIMER STOP - has timer");
+ ecore_main_loop_thread_safe_call_async([](void* data) {
+ MWR_LOGI("DURATION_TIMER STOP - async");
+ CWakeupManager* manager = static_cast<CWakeupManager*>(data);
+ if (!manager) return;
+
+ Ecore_Timer* timer = manager->get_streaming_duration_timer();
+ void* ret = ecore_timer_del(timer);
+ MWR_LOGI("DURATION_TIMER EXISTS : %p %p", timer, ret);
+ manager->set_streaming_duration_timer(nullptr);
+ }, this);
+ }
+}
+
+void CWakeupManager::set_streaming_duration_timer(Ecore_Timer* timer)
+{
+ MWR_LOGI("DURATION_TIMER SET : %p", timer);
+ mStreamingDurationTimer = timer;
+}
+
+Ecore_Timer* CWakeupManager::get_streaming_duration_timer()
+{
+ return mStreamingDurationTimer;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info)
+{
+ MWR_LOGI("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+ if (nullptr == wakeup_info.wakeup_appid) return false;
+
+ if (0 != mWakeupManager->get_default_assistant().compare(wakeup_info.wakeup_appid)) {
+ if (false == mWakeupManager->get_assistant_enabled(string{wakeup_info.wakeup_appid})) {
+ MWR_LOGE("Wakeup event with deactivated appid : %s", wakeup_info.wakeup_appid);
+ return false;
+ }
+ }
+
+ CWakeupPolicy* policy = mWakeupManager->get_wakeup_policy();
+ if (policy) {
+ policy->wakeup_candidate(wakeup_info);
+ }
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_speech_status(string engine_name, mas_speech_status_e status)
+{
+ MWR_LOGI("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_error(string engine_name, int error_code, string error_message)
+{
+ MWR_LOGI("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_audio_data_require_status(string engine_name, bool require)
+{
+ MWR_LOGI("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+ if (WAKEUP_MANAGER_STATE_INACTIVE == mWakeupManager->get_manager_state()) return false;
+
+ CAudioManager *audio_manager = mWakeupManager->get_audio_manager();
+ CWakeupEngineManager *engine_manager = mWakeupManager->get_engine_manager();
+
+ if (audio_manager && engine_manager) {
+ if (engine_manager->get_audio_data_required()) {
+ if (mWakeupManager->get_recording_by_voice_key() != true) {
+ audio_manager->set_recording_session(RECORDING_SESSION_WAKE_WORD);
+ audio_manager->start_recording(true);
+ }
+ } else {
+ if (mWakeupManager->get_recording_by_voice_key() != true) {
+ audio_manager->stop_recording(true);
+ }
+ }
+ }
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_streaming_audio_data(
+ mas_speech_streaming_event_e event, void* buffer, unsigned int len)
+{
+ if (nullptr == mWakeupManager) return false;
+
+ vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+ for (const auto& observer : observers) {
+ observer->on_streaming_audio_data(event, buffer, len);
+ }
+
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_audio_streaming_data_section(
+ ma_audio_streaming_data_section_e section)
+{
+ if (nullptr == mWakeupManager) return false;
+
+ vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+ for (const auto& observer : observers) {
+ observer->on_audio_streaming_data_section(section);
+ }
+
+ return true;
+}
+
+bool CWakeupManager::CEngineEventObserver::on_wakeup_engine_command(
+ mas_wakeup_engine_command_target_e target, string engine_name, string assistant_name, string command)
+{
+ if (nullptr == mWakeupManager) return false;
+
+ if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_DEPENDENCY_MODULE == target) {
+ dependency_resolver_process_wakeup_engine_command(engine_name.c_str(), command.c_str());
+ }
+
+ if (MAS_WAKEUP_ENGINE_COMMAND_TARGET_ALL_ASSISTANTS == target ||
+ MAS_WAKEUP_ENGINE_COMMAND_TARGET_SPECIFIC_ASSISTANT == target) {
+ vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+ for (const auto& observer : observers) {
+ observer->on_wakeup_engine_command(target, assistant_name.c_str(), command.c_str());
+ }
+ }
+
+ return true;
+}
+
+void CWakeupManager::CPolicyEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
+{
+ if (nullptr == mWakeupManager) return;
+
+ CAudioManager *audio_manager = mWakeupManager->get_audio_manager();
+ CWakeupEngineManager *engine_manager = mWakeupManager->get_engine_manager();
+ CWakeupSettings* settings = mWakeupManager->get_wakeup_settings();
+ if (nullptr == audio_manager || nullptr == engine_manager || nullptr == settings) return;
+
+ if (wakeup_info.wakeup_appid && strlen(wakeup_info.wakeup_appid) > 0) {
+ mWakeupManager->set_default_assistant(wakeup_info.wakeup_appid);
+ }
+
+ mWakeupManager->stop_streaming_utterance_data();
+ mWakeupManager->stop_streaming_previous_utterance_data();
+ mWakeupManager->stop_streaming_follow_up_data();
+ mWakeupManager->change_manager_state(WAKEUP_MANAGER_STATE_UTTERANCE);
+
+ mWakeupManager->set_last_wakeup_event_info(wakeup_info);
+ engine_manager->set_selected_wakeup_info(wakeup_info);
+ vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+ for (const auto& observer : observers) {
+ observer->on_wakeup(wakeup_info);
+ }
+
+ audio_manager->set_recording_session(RECORDING_SESSION_UTTERANCE);
+}
+
+bool CWakeupManager::CAudioEventObserver::on_recording_audio_data(long time, void* data, int len)
+{
+ if (nullptr == mWakeupManager) return false;
+ if (nullptr == mEngineManager) return false;
+
+ if (false == mEngineManager->get_audio_data_required()) return false;
+
+ if (mWakeupManager->get_recording_by_voice_key() != true) {
+ /* When follow-up streaming in progress, no need to feed audio data to wakeup engines */
+ if (STREAMING_MODE::FOLLOW_UP != mWakeupManager->get_streaming_mode()) {
+ mEngineManager->engine_feed_audio_data(time, data, len);
+ }
+ }
+
+ return true;
+}
+
+bool CWakeupManager::CAudioEventObserver::on_streaming_audio_data(
+ mas_speech_streaming_event_e event, void* buffer, unsigned int len)
+{
+ if (nullptr == mWakeupManager) return false;
+
+ vector<IWakeupEventObserver*> observers = mWakeupManager->get_wakeup_observers();
+ for (const auto& observer : observers) {
+ observer->on_streaming_audio_data(event, buffer, len);
+ }
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
+ mWakeupManager->set_streaming_mode(STREAMING_MODE::NONE);
+ mWakeupManager->stop_streaming_duration_timer();
+
+ mWakeupManager->set_streaming_completed(true);
+ }
+
+ return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_voice_input_language_changed(
+ const char* language)
+{
+ if (nullptr == mWakeupManager || nullptr == language) return false;
+ mWakeupManager->set_language(std::string(language));
+ vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+ for (const auto& observer : observers) {
+ observer->on_value_changed();
+ }
+ return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_assistant_enabled_info_changed(
+ const char* appid, bool enabled)
+{
+ MWR_LOGE("[ENTER]");
+ if (nullptr == mWakeupManager || nullptr == appid) return false;
+ mWakeupManager->set_assistant_enabled(std::string(appid), enabled);
+ vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+ for (const auto& observer : observers) {
+ if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
+ observer->on_loaded_wakeup_engine_changed();
+ else
+ observer->on_value_changed();
+ }
+ MWR_LOGE("[END]");
+ return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_default_assistant_appid_changed(
+ const char* appid)
+{
+ MWR_LOGE("[ENTER]");
+ if (nullptr == mWakeupManager || nullptr == appid) return false;
+ /* Passing 'expected' as false since the change was occurred outside of MAS */
+ mWakeupManager->process_default_assistant_changed(std::string(appid), false);
+ vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+ for (const auto& observer : observers) {
+ if (mWakeupManager->get_wakeup_settings()->get_multiple_mode())
+ observer->on_value_changed();
+ else
+ observer->on_loaded_wakeup_engine_changed();
+ }
+ MWR_LOGE("[END]");
+ return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_multiple_mode_changed()
+{
+ MWR_LOGE("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+ vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+ for (const auto& observer : observers) {
+ observer->on_loaded_wakeup_engine_changed();
+ }
+ MWR_LOGE("[END]");
+ return true;
+}
+
+bool CWakeupManager::CSettingsEventObserver::on_wake_word_detection_enabled_info_changed()
+{
+ MWR_LOGE("[ENTER]");
+ if (nullptr == mWakeupManager) return false;
+ vector<ISettingValueObserver*> observers = mWakeupManager->get_setting_observers();
+ for (const auto& observer : observers) {
+ observer->on_loaded_wakeup_engine_changed();
+ }
+ MWR_LOGE("[END]");
+ return true;
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+/*
+ * Copyright 2018-2019 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "wakeup_manager_wrapper.h"
+#include "wakeup_manager_main.h"
+#include "wakeup_manager.h"
+
+#include <memory>
+
+#if 0
+#define BUF_SAVE_MODE
+#endif
+#if 0
+#define BUF_LOAD_MODE
+#endif
+
+#ifdef BUF_SAVE_MODE
+static char g_temp_file_name[128] = {'\0', };
+
+static FILE* g_pFile = NULL;
+
+static int g_count = 1;
+#endif
+
+#ifdef BUF_LOAD_MODE
+static FILE* g_pFile = NULL;
+#endif
+
+using namespace multiassistant::wakeup;
+
+static wakeup_service_wakeup_event_cb g_wakeup_event_cb;
+static void* g_wakeup_event_user_data;
+
+static wakeup_service_speech_streaming_cb g_utterance_streaming_cb;
+static void* g_utterance_streaming_user_data;
+
+static wakeup_service_speech_streaming_cb g_previous_utterance_streaming_cb;
+static void* g_previous_utterance_streaming_user_data;
+
+static wakeup_service_speech_streaming_cb g_follow_up_streaming_cb;
+static void* g_follow_up_streaming_user_data;
+
+static wakeup_service_speech_status_cb g_speech_status_cb;
+static void* g_speech_status_user_data;
+
+static wakeup_service_setting_changed_cb g_setting_changed_cb;
+static void* g_setting_changed_user_data;
+
+static wakeup_service_error_cb g_error_cb;
+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;
+
+static wakeup_service_state_changed_cb g_wakeup_service_state_changed_cb;
+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;
+ void on_streaming_audio_data(
+ mas_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(
+ mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command) override;
+ void on_wakeup_service_state_changed(ma_service_state_e state) override;
+ void on_voice_key_status_changed(ma_voice_key_status_e status) override;
+};
+
+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;
+static std::unique_ptr<CSettingValueObserver> g_setting_value_observer;
+static std::unique_ptr<CWakeupManager> g_wakeup_manager;
+
+int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
+
+#ifdef BUF_LOAD_MODE
+static Eina_Bool file_read_feed(void *data)
+{
+ if (g_pFile == NULL) {
+ g_pFile = fopen("/tmp/ma_feed_file", "rb");
+ if (g_pFile == NULL) return EINA_FALSE;
+ }
+
+ if (feof(g_pFile)) {
+ fclose(g_pFile);
+ return EINA_FALSE;
+ }
+
+ const size_t BUFFER_SIZE = 4096;
+ unsigned char buffer[BUFFER_SIZE];
+ size_t len = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, g_pFile);
+ wakeup_manager_feed_audio_data(MAS_SPEECH_STREAMING_EVENT_CONTINUE, buffer, len);
+
+ return EINA_TRUE;
+}
+#endif
+
+int wakeup_manager_initialize(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ try {
+ g_wakeup_event_observer.reset(new CWakeupEventObserver);
+ g_setting_value_observer.reset(new CSettingValueObserver);
+ if (NULL == g_wakeup_event_observer || NULL == g_setting_value_observer) {
+ return -1;
+ }
+ g_wakeup_manager.reset(new CWakeupManager(g_wakeup_event_observer.get(), g_setting_value_observer.get()));
+ if (NULL == g_wakeup_manager) {
+ return -1;
+ }
+ } catch (const std::exception& e) {
+ MWR_LOGE("Exception caught : %s", e.what());
+ return -1;
+ }
+
+ g_wakeup_event_cb = NULL;
+ g_wakeup_event_user_data = NULL;
+
+ g_utterance_streaming_cb = NULL;
+ g_utterance_streaming_user_data = NULL;
+
+ g_follow_up_streaming_cb = NULL;
+ g_follow_up_streaming_user_data = NULL;
+
+ g_speech_status_cb = NULL;
+ g_speech_status_user_data = NULL;
+
+ g_setting_changed_cb = NULL;
+ g_setting_changed_user_data = NULL;
+
+ 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_service_state_changed_cb = NULL;
+ g_wakeup_service_state_changed_user_data = NULL;
+
+ 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]");
+
+#ifdef BUF_SAVE_MODE
+ if (g_pFile) {
+ fclose(g_pFile);
+ g_pFile = NULL;
+ } else {
+ MWR_LOGD("[Recorder Info] File not found!");
+ }
+
+ while (1) {
+ snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/wakeup_manager_%d_%d", getpid(), g_count);
+ int ret = access(g_temp_file_name, 0);
+
+ if (0 == ret) {
+ MWR_LOGD("[Recorder ERROR] File is already exist");
+ if (0 == remove(g_temp_file_name)) {
+ MWR_LOGD("[Recorder] Remove file");
+ break;
+ } else {
+ g_count++;
+ }
+ } else {
+ break;
+ }
+ }
+
+ MWR_LOGD("[Recorder] Temp file name=[%s]", g_temp_file_name);
+
+ /* open test file */
+ g_pFile = fopen(g_temp_file_name, "wb+x");
+ if (!g_pFile) {
+ MWR_LOGD("[Recorder ERROR] File not found!");
+ }
+ g_count++;
+#endif
+
+#ifdef BUF_LOAD_MODE
+ Ecore_Timer* timer = ecore_timer_add(0.01f, file_read_feed, NULL);
+#endif
+ return 0;
+}
+
+int wakeup_manager_deinitialize(void)
+{
+ MWR_LOGI("[ENTER]");
+
+#ifdef BUF_SAVE_MODE
+ if (g_pFile) {
+ MWR_LOGE("[Recorder SUCCESS] File Close");
+ fclose(g_pFile);
+ g_pFile = NULL;
+ }
+#endif
+
+ if (nullptr == g_wakeup_manager) return -1;
+
+ try {
+ g_wakeup_manager->deinitialize();
+ g_wakeup_manager.reset();
+
+ g_wakeup_event_observer.reset();
+ g_setting_value_observer.reset();
+ } catch (const std::exception& e) {
+ MWR_LOGE("Exception caught : %s", e.what());
+ return -1;
+ }
+
+ MWR_LOGI("[END]");
+ return 0;
+}
+
+int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size)
+{
+ if (NULL == settings || NULL == struct_size) {
+ MWR_LOGD("[ERROR] Parameter is invalid, settings(%p), struct_size(%p)", settings, struct_size);
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ CWakeupSettings* wakeup_settings = g_wakeup_manager->get_wakeup_settings();
+ if (wakeup_settings) {
+ const int PLUGIN_VERSION = 1;
+ static ma_plugin_settings current_settings;
+ current_settings.plugin_version = PLUGIN_VERSION;
+ current_settings.ui_panel_enabled = wakeup_settings->get_ui_panel_enabled();
+ *struct_size = sizeof(current_settings);
+ *settings = ¤t_settings;
+ }
+
+ return 0;
+}
+
+int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == appid || NULL == wakeup_word) {
+ MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->add_assistant_wakeup_word(
+ string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == appid || NULL == wakeup_word) {
+ MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->remove_assistant_wakeup_word(
+ string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_add_assistant_language(const char* appid, const char* language)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == appid || NULL == language) {
+ MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->add_assistant_language(string{appid}, string{language});
+
+ MWR_LOGD("[DEBUG] language(%s)", language);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_add_assistant_wakeup_engine(const char* appid, const char* engine)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == appid || NULL == engine) {
+ MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup engine(%s)", appid, engine);
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ MWR_LOGD("[DEBUG] appid(%s), wakeup engine(%s)", appid, engine);
+ g_wakeup_manager->add_assistant_wakeup_engine(string{appid}, string{engine});
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_default_assistant(const char* appid)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == appid) {
+ MWR_LOGD("[ERROR] Parameter is NULL");
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ MWR_LOGD("[DEBUG] default_assistant appid(%s)", appid);
+ g_wakeup_manager->set_default_assistant(string{appid});
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_get_default_assistant(const char** appid)
+{
+ static string default_assistant;
+
+ if (nullptr == g_wakeup_manager) return -1;
+ default_assistant = g_wakeup_manager->get_default_assistant();
+
+ if (default_assistant.empty()) {
+ *appid = nullptr;
+ } else {
+ *appid = default_assistant.c_str();
+ }
+ return 0;
+}
+
+int wakeup_manager_set_language(const char* language)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == language) {
+ MWR_LOGD("[ERROR] Parameter is NULL");
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_language(string{language});
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_change_state(wakeup_manager_state_e state)
+{
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->change_manager_state(state);
+ return 0;
+}
+
+int wakeup_manager_activate(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->activate();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_deactivate(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->deactivate();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_update_voice_feedback_state(const char* appid, int state)
+{
+ MWR_LOGI("[ENTER]");
+
+ string appid_string;
+ if (NULL == appid) {
+ MWR_LOGD("[ERROR] Parameter is NULL");
+ } else {
+ appid_string = appid;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->update_voice_feedback_state(appid_string, state);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_assistant_specific_command(const char* appid, const char* command)
+{
+ MWR_LOGI("[ENTER]");
+
+ string appid_string;
+ string command_string;
+ if (NULL == appid || NULL == command) {
+ MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), command(%s)", appid, command);
+ }
+ if (appid) appid_string = appid;
+ if (command) command_string = command;
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_assistant_specific_command(appid_string, command_string);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_background_volume(const char* appid, double ratio)
+{
+ MWR_LOGI("[ENTER]");
+
+ string appid_string;
+ if (NULL == appid) {
+ MWR_LOGD("[ERROR] Parameter is NULL");
+ } else {
+ appid_string = appid;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_background_volume(appid_string, ratio);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_update_recognition_result(const char* appid, int result)
+{
+ MWR_LOGI("[ENTER]");
+
+ string appid_string;
+ if (NULL == appid) {
+ MWR_LOGD("[ERROR] Parameter is NULL");
+ } else {
+ appid_string = appid;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->update_recognition_result(appid_string, result);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_process_plugin_event(mas_plugin_event_e event, void* data, int len)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->process_plugin_event(event, data, len);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_start_streaming_utterance_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->start_streaming_utterance_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_stop_streaming_utterance_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->stop_streaming_utterance_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_start_streaming_follow_up_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->start_streaming_follow_up_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_stop_streaming_follow_up_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->stop_streaming_follow_up_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_start_streaming_previous_utterance_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->start_streaming_previous_utterance_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_stop_streaming_previous_utterance_data(void)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->stop_streaming_previous_utterance_data();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_get_audio_format(int* rate, int* channel, int* audio_type)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (!audio_type || !rate || !channel) {
+ MWR_LOGE("[ERROR] Invalid parameter");
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->get_audio_format(rate, channel, audio_type);
+
+ MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
+ return 0;
+}
+
+int wakeup_manager_get_audio_source_type(char** type)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (!type) {
+ MWR_LOGE("[ERROR] Invalid parameter");
+ return -1;
+ }
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->get_audio_source_type(type);
+
+ MWR_LOGD("[END] type(%s)", *type);
+ return 0;
+}
+
+int wakeup_manager_set_voice_key_tap_duration(float duration)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_voice_key_tap_duration(duration);
+
+ MWR_LOGD("[END] duration(%f)", duration);
+ return 0;
+}
+
+int wakeup_manager_unset_voice_key_tap_duration()
+{
+ MWR_LOGI("[ENTER]");
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->unset_voice_key_tap_duration();
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_voice_key_support_mode(int mode)
+{
+ MWR_LOGI("[ENTER] : %d", mode);
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_voice_key_support_mode(static_cast<VOICE_KEY_SUPPORT_MODE>(mode));
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_wake_word_audio_require_flag(bool require)
+{
+ MWR_LOGI("[ENTER] : %d", require);
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_wake_word_audio_require_flag(require);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_assistant_language(const char* appid, const char* language)
+{
+ MWR_LOGI("[ENTER]");
+
+ string appid_string;
+ string language_string;
+ if (NULL == appid || NULL == language) {
+ MWR_LOGE("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
+ return -1;
+ }
+ appid_string = appid;
+ language_string = language;
+
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_assistant_language(appid_string, language_string);
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_wakeup_event_cb = callback;
+ g_wakeup_event_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_utterance_streaming_cb = callback;
+ g_utterance_streaming_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_previous_utterance_streaming_cb = callback;
+ g_previous_utterance_streaming_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_follow_up_streaming_cb = callback;
+ g_follow_up_streaming_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_speech_status_cb = callback;
+ g_speech_status_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_setting_changed_cb = callback;
+ g_setting_changed_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_error_cb = callback;
+ g_error_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_streaming_section_changed_cb = callback;
+ g_streaming_section_changed_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data)
+{
+ MWR_LOGI("[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_set_wakeup_service_state_changed_callback(wakeup_service_state_changed_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_wakeup_service_state_changed_cb = callback;
+ g_wakeup_service_state_changed_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ return 0;
+}
+
+int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data)
+{
+ MWR_LOGI("[ENTER]");
+
+ if (NULL == callback) {
+ MWR_LOGE("[ERROR] Input parameter is NULL");
+ return -1;
+ }
+
+ g_wakeup_service_voice_key_status_changed_cb = callback;
+ g_wakeup_service_voice_key_status_changed_user_data = user_data;
+
+ MWR_LOGD("[END]");
+ 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;
+
+#ifdef BUF_SAVE_MODE
+ static int num = 0;
+ const int MAXIMUM_NUM = 1000;
+ if (g_pFile && num++ < MAXIMUM_NUM)
+ fwrite(buffer, 1, len, g_pFile);
+#endif
+
+ g_wakeup_manager->feed_audio_data(event, buffer, len);
+
+ return 0;
+}
+
+int wakeup_manager_set_dependency_module_command(const char* engine_name, const char* command)
+{
+ if (nullptr == g_wakeup_manager) return -1;
+ g_wakeup_manager->set_dependency_module_command(
+ engine_name ? engine_name : "",
+ command ? command : "");
+ return 0;
+}
+
+int wakeup_manager_wakeup_assistant(const mas_wakeup_event_info* wakeup_info)
+{
+ if (nullptr == g_wakeup_manager) return -1;
+ CWakeupPolicy* policy = g_wakeup_manager->get_wakeup_policy();
+ if (policy) policy->select_candidate(*wakeup_info);
+ return 0;
+}
+
+void CWakeupEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
+{
+ if (NULL != g_wakeup_event_cb) {
+ g_wakeup_event_cb(wakeup_info, g_wakeup_event_user_data);
+ }
+}
+
+void CWakeupEventObserver::on_streaming_audio_data(
+ mas_speech_streaming_event_e event, void* buffer, unsigned int len)
+{
+ if (MAS_SPEECH_STREAMING_EVENT_START == event) {
+ MWR_LOGI("streaming_cb START");
+ }
+ if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
+ MWR_LOGI("streaming_cb FINISH");
+ }
+ if (NULL != g_utterance_streaming_cb) {
+ g_utterance_streaming_cb(event, buffer, len, g_utterance_streaming_user_data);
+ } else {
+ MWR_LOGI("[INFO] No service streaming callback");
+ }
+}
+
+void CWakeupEventObserver::on_audio_streaming_data_section(
+ ma_audio_streaming_data_section_e section)
+{
+ if (g_streaming_section_changed_cb) {
+ g_streaming_section_changed_cb(section, g_streaming_section_changed_user_data);
+ }
+}
+
+void CWakeupEventObserver::on_wakeup_engine_command(
+ mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command)
+{
+ if (g_wakeup_engine_command_cb) {
+ g_wakeup_engine_command_cb(target, assistant_name, command, g_wakeup_engine_command_user_data);
+ }
+}
+
+void CWakeupEventObserver::on_wakeup_service_state_changed(ma_service_state_e state)
+{
+ if (g_wakeup_service_state_changed_cb) {
+ g_wakeup_service_state_changed_cb(state, g_wakeup_service_state_changed_user_data);
+ }
+}
+
+void CWakeupEventObserver::on_voice_key_status_changed(ma_voice_key_status_e status)
+{
+ if (g_wakeup_service_voice_key_status_changed_cb) {
+ g_wakeup_service_voice_key_status_changed_cb(status, g_wakeup_service_voice_key_status_changed_user_data);
+ }
+}
+
+void CSettingValueObserver::on_value_changed()
+{
+ if (g_setting_changed_cb) {
+ 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);
+ }
+}
--- /dev/null
+#include "wakeup_policy.h"
+#include "wakeup_policy_impl.h"
+
+#include <vector>
+#include <algorithm>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+void CWakeupPolicyImpl::subscribe(IPolicyEventObserver *observer)
+{
+ mObservers.push_back(observer);
+}
+
+void CWakeupPolicyImpl::unsubscribe(IPolicyEventObserver *observer)
+{
+ auto iter = find(mObservers.begin(), mObservers.end(), observer);
+ if (iter != mObservers.end()) {
+ mObservers.erase(iter);
+ }
+}
+
+void CWakeupPolicyImpl::wakeup(mas_wakeup_event_info wakeup_info)
+{
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ observer->on_wakeup(wakeup_info);
+ }
+ }
+}
+
+CWakeupPolicy::CWakeupPolicy()
+{
+ mImpl.reset(new CWakeupPolicyImpl);
+}
+
+CWakeupPolicy::~CWakeupPolicy()
+{
+}
+
+CWakeupPolicy::CWakeupPolicy(IPolicyEventObserver *observer) : CWakeupPolicy()
+{
+ subscribe(observer);
+}
+
+void CWakeupPolicy::subscribe(IPolicyEventObserver *observer)
+{
+ if (mImpl) mImpl->subscribe(observer);
+}
+
+void CWakeupPolicy::unsubscribe(IPolicyEventObserver *observer)
+{
+ if (mImpl) mImpl->unsubscribe(observer);
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+#include "wakeup_policy_default.h"
+#include "wakeup_policy_impl.h"
+#include "wakeup_manager_main.h"
+
+#include <vector>
+
+#include <Eina.h>
+#include <dlog.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+CWakeupPolicyDefault::CWakeupPolicyDefault(IPolicyEventObserver *observer)
+ : CWakeupPolicy(observer)
+{
+}
+
+CWakeupPolicyDefault::~CWakeupPolicyDefault()
+{
+ if (mTimer) {
+ ecore_timer_del(mTimer);
+ mTimer = nullptr;
+ }
+}
+
+bool CWakeupPolicyDefault::valid()
+{
+ return true;
+}
+
+void CWakeupPolicyDefault::set_assistant_priority(string appid, int priority)
+{
+ PRIORITY_INFO info;
+ info.appid = appid;
+ info.priority = priority;
+
+ MWR_LOGD("Setting assistant priority : %s %d", appid.c_str(), priority);
+ mPriorityInfos.push_back(info);
+}
+
+void CWakeupPolicyDefault::set_delay(float seconds)
+{
+ MWR_LOGD("Setting delay : %f", seconds);
+ mDelaySeconds = seconds;
+}
+
+float CWakeupPolicyDefault::get_delay()
+{
+ return mDelaySeconds;
+}
+
+void CWakeupPolicyDefault::set_timer(Ecore_Timer* timer)
+{
+ mTimer = timer;
+}
+
+Ecore_Timer* CWakeupPolicyDefault::get_timer()
+{
+ return mTimer;
+}
+
+static Eina_Bool timer_func(void *data)
+{
+ MWR_LOGD("[ENTER]");
+ if (data) {
+ CWakeupPolicyDefault *policy = static_cast<CWakeupPolicyDefault*>(data);
+ policy->timer_expired();
+ policy->set_timer(nullptr);
+ }
+ return ECORE_CALLBACK_CANCEL;
+}
+
+void CWakeupPolicyDefault::wakeup_candidate(mas_wakeup_event_info wakeup_info)
+{
+ MWR_LOGI("[ENTER]");
+ mas_wakeup_event_info_wrapper wrapper;
+ wrapper.info = wakeup_info;
+ if (wakeup_info.wakeup_appid) wrapper.wakeup_appid = wakeup_info.wakeup_appid;
+ if (wakeup_info.wakeup_word) wrapper.wakeup_word = wakeup_info.wakeup_word;
+ if (wakeup_info.wakeup_language) wrapper.wakeup_language = wakeup_info.wakeup_language;
+ if (wakeup_info.wakeup_voice_id) wrapper.wakeup_voice_id = wakeup_info.wakeup_voice_id;
+ 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;
+
+ 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);
+ if (nullptr == mTimer) {
+ ecore_main_loop_thread_safe_call_async([](void* data) {
+ /* Assume that choosing the first wakeup event is the default behavior */
+ timer_func(data);
+ }, this);
+ }
+}
+
+void CWakeupPolicyDefault::select_candidate(mas_wakeup_event_info wakeup_info)
+{
+ MWR_LOGE("Default wakeup policy does not support selecting candidate");
+}
+
+void CWakeupPolicyDefault::timer_expired()
+{
+ MWR_LOGD("[ENTER]");
+ if (0 == mWakeupInfos.size()) return;
+
+ mas_wakeup_event_info_wrapper selected = mWakeupInfos.front();
+ LOGD("wake word : %s", selected.wakeup_word.c_str());
+ int selected_priority = -1;
+ for (const auto &wakeup : mWakeupInfos) {
+ for (const auto &info : mPriorityInfos) {
+ if (0 == info.appid.compare(wakeup.wakeup_appid)) {
+ if (info.priority > selected_priority || -1 == selected_priority) {
+ MWR_LOGD("Wakeup with higher priority found : %s, %d",
+ info.appid.c_str(), info.priority);
+ selected = wakeup;
+ selected_priority = info.priority;
+ }
+ }
+ }
+ }
+ selected.info.wakeup_appid = selected.wakeup_appid.c_str();
+ selected.info.wakeup_word = selected.wakeup_word.c_str();
+ 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);
+ mWakeupInfos.clear();
+
+ if (mTimer) {
+ MWR_LOGD("Now deleting timer");
+ ecore_timer_del(mTimer);
+ mTimer = nullptr;
+ }
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+#include "wakeup_policy_external.h"
+#include "wakeup_policy_impl.h"
+
+#include "dependency_resolver.h"
+
+#include <dlog.h>
+
+#ifndef LOG_TAG
+#define LOG_TAG "WakeupPolicyExternal"
+#endif
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+CWakeupPolicyExternal::CWakeupPolicyExternal(IPolicyEventObserver *observer)
+ : CWakeupPolicy(observer)
+{
+}
+
+CWakeupPolicyExternal::~CWakeupPolicyExternal()
+{
+}
+
+bool CWakeupPolicyExternal::valid()
+{
+ bool ret = false;
+ mas_dependency_module_interface* interface = dependency_resolver_get_interface();
+ if (interface) {
+ if (interface->process_wakeup_candidate) {
+ ret = true;
+ }
+ }
+ return ret;
+}
+
+void CWakeupPolicyExternal::wakeup_candidate(mas_wakeup_event_info wakeup_info)
+{
+ dependency_resolver_process_wakeup_candidate(&wakeup_info);
+}
+
+void CWakeupPolicyExternal::select_candidate(mas_wakeup_event_info wakeup_info)
+{
+ if (mImpl) mImpl->wakeup(wakeup_info);
+}
+
+} // wakeup
+} // multiassistant
--- /dev/null
+#include "wakeup_settings.h"
+#include "wakeup_manager_main.h"
+
+#include <sstream>
+#include <algorithm>
+#include <json/json.h>
+
+namespace multiassistant
+{
+namespace wakeup
+{
+
+/* Utility function for checking if an element exists in a container */
+template<class C, class T>
+static auto contains(const C& v, const T& x) -> decltype(end(v), true)
+{
+ return end(v) != find(begin(v), end(v), x);
+}
+
+static string prev_wake_word_enabled;
+
+CWakeupSettings::CWakeupSettings()
+{
+}
+
+CWakeupSettings::~CWakeupSettings()
+{
+}
+
+static void wakeup_setting_input_language_changed_cb(keynode_t* node, void* data)
+{
+ MWR_LOGD("[ENTER]");
+ if (nullptr == node) return;
+
+ CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
+ if (nullptr == settings) return;
+
+ if (VCONF_TYPE_STRING == node->type) {
+ const char* value = static_cast<const char*>(node->value.s);
+ const auto& observers = settings->get_observers();
+ for (const auto& observer : observers) {
+ if (observer) {
+ if (!observer->on_voice_input_language_changed(value)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ } else {
+ LOGE("[Settings ERROR] the value type is not string : %d", node->type);
+ }
+}
+
+static void wakeup_setting_streaming_duration_max_changed_cb(keynode_t* node, void* data)
+{
+ MWR_LOGD("[ENTER]");
+ if (nullptr == node) return;
+
+ CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
+ if (nullptr == settings) return;
+
+ if (VCONF_TYPE_DOUBLE == node->type) {
+ double value = static_cast<double>(node->value.d);
+ settings->set_streaming_duration_max(static_cast<float>(value));
+ } else {
+ LOGE("[Settings ERROR] the value type is not string : %d", node->type);
+ }
+}
+
+
+static void wakeup_setting_enabled_assistants_changed_cb(keynode_t* node, void* data)
+{
+ MWR_LOGD("[ENTER]");
+ if (nullptr == node) return;
+
+ CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
+ if (nullptr == settings) return;
+
+ if (VCONF_TYPE_STRING == node->type) {
+ vector<string> newlyAddedAssistants;
+ vector<string> newlyRemovedAssistants;
+ const char* value = static_cast<const char*>(node->value.s);
+ if (value) {
+ vector<string> previouslyEnabledAssistants = settings->get_enabled_assistants();
+ vector<string> currentlyEnabledAssistants;
+ string token;
+ istringstream iss(value);
+ currentlyEnabledAssistants.clear();
+ while (getline(iss, token, ';')) {
+ currentlyEnabledAssistants.push_back(token);
+ MWR_LOGD("enabled_assistants : %s", token.c_str());
+ }
+
+ for (const auto& assistant : currentlyEnabledAssistants) {
+ if (!contains(previouslyEnabledAssistants, assistant)) {
+ newlyAddedAssistants.push_back(assistant);
+ }
+ }
+ for (const auto& assistant : previouslyEnabledAssistants) {
+ if (!contains(currentlyEnabledAssistants, assistant)) {
+ newlyRemovedAssistants.push_back(assistant);
+ }
+ }
+ }
+
+ const auto& observers = settings->get_observers();
+ for (const auto& observer : observers) {
+ if (observer) {
+ for (const auto& assistant : newlyAddedAssistants) {
+ if (!observer->on_assistant_enabled_info_changed(assistant.c_str(), true)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ for (const auto& assistant : newlyRemovedAssistants) {
+ if (!observer->on_assistant_enabled_info_changed(assistant.c_str(), false)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+ } else {
+ LOGE("[Settings ERROR] the value type is not string : %d", node->type);
+ }
+}
+
+static void wakeup_setting_default_assistant_appid_changed_cb(keynode_t* node, void* data)
+{
+ MWR_LOGD("[ENTER]");
+ if (nullptr == node) return;
+
+ CWakeupSettings* settings = static_cast<CWakeupSettings*>(data);
+ if (nullptr == settings) return;
+
+ if (VCONF_TYPE_STRING == node->type) {
+ const char* value = static_cast<const char*>(node->value.s);
+ const auto& observers = settings->get_observers();
+ for (const auto& observer : observers) {
+ if (observer) {
+ if (!observer->on_default_assistant_appid_changed(value)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ } else {
+ LOGE("[Settings ERROR] the value type is not string : %d", node->type);
+ }
+}
+
+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");
+ }
+ }
+ }
+}
+
+static void wakeup_setting_enabled_wake_word_detection_changed_cb(keynode_t* node, void* data)
+{
+ MWR_LOGD("[ENTER]");
+
+ char *vconf_str = vconf_keynode_get_str(node);
+ if (!vconf_str) return;
+
+ MWR_LOGI("vconf value : %s", vconf_str);
+ if (0 == prev_wake_word_enabled.compare(string(vconf_str))) {
+ return;
+ }
+
+ prev_wake_word_enabled = string(vconf_str);
+
+ 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_wake_word_detection_enabled_info_changed()) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+}
+
+void CWakeupSettings::initialize(map<string, string> custom_keys)
+{
+ int vconf_ret;
+ int vconf_bool;
+ double vconf_double;
+
+ mCustomVconfKeys.clear();
+ mCustomVconfKeys = custom_keys;
+
+ char *default_assistant_appid = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str());
+ if (default_assistant_appid) {
+ mDefaultAssistantAppid = default_assistant_appid;
+ MWR_LOGD("default_assistant_appid : %s", mDefaultAssistantAppid.c_str());
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_default_assistant_appid_changed(default_assistant_appid)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ free(default_assistant_appid);
+ default_assistant_appid = nullptr;
+ }
+ vconf_ret = vconf_get_bool(WAKEUP_SETTINGS_KEY_UI_PANEL_ENABLED, &vconf_bool);
+ if (0 == vconf_ret) {
+ mUiPanelEnabled = vconf_bool;
+ MWR_LOGD("ui_panel_enabled : %s", (mUiPanelEnabled ? "true" : "false"));
+ }
+ vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_CONVERSATION_TIMEOUT, &vconf_double);
+ if (0 == vconf_ret) {
+ mConversationTimeout = vconf_double;
+ MWR_LOGD("conversation_timeout : %f", mConversationTimeout);
+ }
+ vconf_ret = vconf_get_bool(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE, &vconf_bool);
+ if (0 == vconf_ret) {
+ mMultipleMode = vconf_bool;
+ MWR_LOGD("multiple_mode : %s", (mMultipleMode ? "true" : "false"));
+ }
+ if (true == mMultipleMode) {
+ char *enabled_assistants = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str());
+ if (enabled_assistants) {
+ string token;
+ istringstream iss(enabled_assistants);
+ mEnabledAssistants.clear();
+ while (getline(iss, token, ';')) {
+ mEnabledAssistants.push_back(token);
+ MWR_LOGD("enabled_assistants : %s", token.c_str());
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_assistant_enabled_info_changed(token.c_str(), true)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ }
+ free(enabled_assistants);
+ enabled_assistants = nullptr;
+ }
+ }
+ char *wakeword_detection_enabled = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str());
+ if (wakeword_detection_enabled) {
+ Json::Reader reader;
+ Json::Value root;
+ mWakeWordDisabledAssistants.clear();
+ if (!reader.parse(wakeword_detection_enabled, root)) {
+ LOGW("[Settings WARNING] Failed to parse Json : %s", reader.getFormattedErrorMessages().c_str());
+ } else {
+ auto member = root.getMemberNames();
+ for (string m : member) {
+ if (0 == root[m].asString().compare("off")) {
+ mWakeWordDisabledAssistants.push_back(m);
+ MWR_LOGD("wake_word_detection_disabled assistant : %s", m.c_str());
+ }
+ }
+ }
+ free(wakeword_detection_enabled);
+ wakeword_detection_enabled = nullptr;
+ }
+ vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_DELAY, &vconf_double);
+ if (0 == vconf_ret) {
+ mWakeupPolicyDelay = vconf_double;
+ MWR_LOGD("conversation_timeout : %f", mWakeupPolicyDelay);
+ }
+ char *wakeup_policy_priority = vconf_get_str(WAKEUP_SETTINGS_KEY_WAKEUP_POLICY_PRIORITY);
+ if (wakeup_policy_priority) {
+ string token;
+ istringstream iss(wakeup_policy_priority);
+ mWakeupPolicyPriority.clear();
+ while (getline(iss, token, ';')) {
+ mWakeupPolicyPriority.push_back(token);
+ MWR_LOGD("wakeup_policy_priority : %s", token.c_str());
+ }
+ free(wakeup_policy_priority);
+ wakeup_policy_priority = nullptr;
+ }
+ vconf_ret = vconf_get_dbl(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX, &vconf_double);
+ if (0 == vconf_ret) {
+ mStreamingDurationMax = vconf_double;
+ MWR_LOGD("streaming_duration_max : %f", mStreamingDurationMax);
+ }
+#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
+ char *voice_input_language = vconf_get_str(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE);
+ if (voice_input_language) {
+ mVoiceInputLanguage = voice_input_language;
+ MWR_LOGD("voice input language : %s", mVoiceInputLanguage.c_str());
+ for (const auto& observer : mObservers) {
+ if (observer) {
+ if (!observer->on_voice_input_language_changed(voice_input_language)) {
+ LOGW("[Settings WARNING] One of the observer returned false");
+ }
+ }
+ }
+ free(voice_input_language);
+ voice_input_language = nullptr;
+ }
+#endif
+
+#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
+ vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE,
+ wakeup_setting_input_language_changed_cb, this);
+#endif
+ vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX,
+ wakeup_setting_streaming_duration_max_changed_cb, this);
+ vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(),
+ wakeup_setting_default_assistant_appid_changed_cb, this);
+ if (true == mMultipleMode) {
+ vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str(),
+ wakeup_setting_enabled_assistants_changed_cb, this);
+ }
+ vconf_notify_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
+ wakeup_setting_multiple_mode_changed_cb, this);
+ vconf_notify_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str(),
+ wakeup_setting_enabled_wake_word_detection_changed_cb, this);
+}
+
+void CWakeupSettings::deinitialize()
+{
+#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
+ vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE,
+ wakeup_setting_input_language_changed_cb);
+#endif
+ vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_STREAMING_DURATION_MAX,
+ wakeup_setting_streaming_duration_max_changed_cb);
+ vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(),
+ wakeup_setting_default_assistant_appid_changed_cb);
+ if (true == mMultipleMode) {
+ vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_ENABLED_ASSISTANTS].c_str(),
+ wakeup_setting_enabled_assistants_changed_cb);
+ }
+ vconf_ignore_key_changed(WAKEUP_SETTINGS_KEY_MULTIPLE_MODE,
+ wakeup_setting_multiple_mode_changed_cb);
+ vconf_ignore_key_changed(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_WAKE_WORD_DETECTION_ENABLED].c_str(),
+ wakeup_setting_enabled_wake_word_detection_changed_cb);
+}
+
+void CWakeupSettings::subscribe(ISettingsEventObserver *observer)
+{
+ mObservers.push_back(observer);
+}
+
+void CWakeupSettings::unsubscribe(ISettingsEventObserver *observer)
+{
+ auto iter = find(mObservers.begin(), mObservers.end(), observer);
+ if (iter != mObservers.end()) {
+ mObservers.erase(iter);
+ }
+}
+
+const vector<ISettingsEventObserver*>& CWakeupSettings::get_observers()
+{
+ return mObservers;
+}
+
+string CWakeupSettings::get_default_assistant_appid()
+{
+ char *vconf_str;
+ vconf_str = vconf_get_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str());
+ MWR_LOGD("vconf default_assistant_appid : %s", vconf_str);
+ if (vconf_str) {
+ mDefaultAssistantAppid = vconf_str;
+ MWR_LOGD("member default_assistant_appid : %s", mDefaultAssistantAppid.c_str());
+ free(vconf_str);
+ vconf_str = nullptr;
+ }
+
+ return mDefaultAssistantAppid;
+}
+
+void CWakeupSettings::set_default_assistant_appid(std::string appid)
+{
+ if (appid.empty()) {
+ MWR_LOGE("appid is NULL");
+ return;
+ }
+ if (appid.compare(get_default_assistant_appid()) == 0) {
+ MWR_LOGE("Default assistant appid not changed, ignoring...");
+ return;
+ }
+ int ret = vconf_set_str(mCustomVconfKeys[WAKEUP_SETTINGS_KEY_DEFAULT_ASSISTANT_APPID].c_str(), appid.c_str());
+ MWR_LOGD("default_assistant_appid : %s, %d", appid.c_str(), ret);
+ mDefaultAssistantAppid = appid;
+}
+
+bool CWakeupSettings::get_ui_panel_enabled()
+{
+ return mUiPanelEnabled;
+}
+
+float CWakeupSettings::get_conversation_timeout()
+{
+ return mConversationTimeout;
+}
+
+bool CWakeupSettings::get_multiple_mode()
+{
+ return mMultipleMode;
+}
+
+vector<string> CWakeupSettings::get_enabled_assistants()
+{
+ return mEnabledAssistants;
+}
+
+float CWakeupSettings::get_wakeup_policy_delay()
+{
+ return mWakeupPolicyDelay;
+}
+
+vector<string> CWakeupSettings::get_wakeup_policy_priority()
+{
+ return mWakeupPolicyPriority;
+}
+
+float CWakeupSettings::get_streaming_duration_max()
+{
+ return mStreamingDurationMax;
+}
+
+void CWakeupSettings::set_streaming_duration_max(float duration)
+{
+ MWR_LOGE("Setting Streaming Duration Max Value : %f", duration);
+ mStreamingDurationMax = duration;
+}
+
+std::string CWakeupSettings::get_current_language(void)
+{
+ std::string result{"en_US"};
+
+#ifdef ENABLE_VOICE_INPUT_LANGUAGE_SETTINGS
+ char* language = vconf_get_str(WAKEUP_SETTINGS_KEY_VOICE_INPUT_LANGUAGE);
+ if (language) {
+ result = language;
+ free(language);
+ }
+#endif
+
+ return result;
+}
+
+vector<string> CWakeupSettings::get_wake_word_disabled_assistants()
+{
+ return mWakeWordDisabledAssistants;
+}
+
+} // wakeup
+} // multiassistant
projects / platform / core / uifw / multi-assistant-service.git / commitdiff