plugins/wakeup-manager/inc/wakeup_manager.h

   1 /*
   2  * Copyright 2018-2019 Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #ifndef _WAKEUP_MANAGER_H_
  19 #define _WAKEUP_MANAGER_H_
  20
  21 #include "wakeup_manager_wrapper.h"
  22 #include "wakeup_settings.h"
  23 #include "wakeup_engine_manager.h"
  24 #include "wakeup_audio_manager.h"
  25 #include "wakeup_policy_default.h"
  26
  27 #include <memory>
  28 #include <map>
  29
  30 namespace multiassistant
  31 {
  32 namespace wakeup
  33 {
  34
  35 using namespace std;
  36
  37 enum class STREAMING_MODE {
  38         NONE,
  39         UTTERANCE,
  40         PREVIOUS_UTTERANCE,
  41         FOLLOW_UP,
  42 };
  43
  44 class IWakeupEventObserver {
  45 public:
  46         virtual ~IWakeupEventObserver() = default;
  47         virtual void on_wakeup(mas_wakeup_event_info wakeup_info) = 0;
  48         virtual void on_streaming_audio_data(
  49                 mas_speech_streaming_event_e event, void* buffer, unsigned int len) = 0;
  50         virtual void on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) = 0;
  51         virtual void on_wakeup_engine_command(
  52                 mas_wakeup_engine_command_target_e target, const char* name, const char* command) = 0;
  53 };
  54
  55 class ISettingValueObserver {
  56 public:
  57         virtual ~ISettingValueObserver() = default;
  58         virtual void on_value_changed() = 0;
  59 };
  60
  61 /* If a wakeup event is raised by pressing a voice key,
  62         the wakeup_engine attribute of wakeup_event_info will have the following value */
  63 #define WAKEUP_ENGINE_VOICE_KEY "voice_key"
  64
  65 class CWakeupManager
  66 {
  67 public:
  68         CWakeupManager(IWakeupEventObserver* wakeup_observer, ISettingValueObserver* setting_observer);
  69         virtual ~CWakeupManager();
  70
  71         CWakeupManager(const CWakeupManager&) = delete;
  72         CWakeupManager& operator=(const CWakeupManager&) = delete;
  73
  74         bool initialize();
  75         bool deinitialize();
  76
  77         void subscribe_wakeup_observer(IWakeupEventObserver* observer);
  78         void unsubscribe_wakeup_observer(IWakeupEventObserver* observer);
  79
  80         void subscribe_setting_observer(ISettingValueObserver* observer);
  81         void unsubscribe_setting_observer(ISettingValueObserver* observer);
  82
  83         bool activate();
  84         bool deactivate();
  85
  86         bool add_assistant_language(string appid, string language);
  87         bool add_assistant_wakeup_word(string appid, string wakeup_word, string language);
  88         bool set_assistant_wakeup_engine(string appid, string engine);
  89         bool set_assistant_language(string appid, string language);
  90
  91         bool set_assistant_enabled(string appid, bool enabled);
  92         bool get_assistant_enabled(string appid);
  93         bool set_default_assistant(string appid);
  94         string get_default_assistant();
  95
  96         bool update_voice_feedback_state(string appid, bool state);
  97         bool send_assistant_specific_command(string appid, string command);
  98         bool set_background_volume(string appid, double ratio);
  99         bool update_recognition_result(string appid, int result);
 100         bool process_event(mas_plugin_event_e event, void* data, int len);
 101         bool get_audio_format(int* rate, int* channel, int* audio_type);
 102         bool get_audio_source_type(char** type);
 103         bool set_language(string language);
 104         bool get_voice_key_pressed();
 105         bool set_wake_word_audio_require_flag(bool require);
 106
 107         STREAMING_MODE get_streaming_mode();
 108         bool set_streaming_mode(STREAMING_MODE mode);
 109
 110         bool start_streaming_utterance_data();
 111         bool stop_streaming_utterance_data();
 112         bool start_streaming_follow_up_data();
 113         bool stop_streaming_follow_up_data();
 114         bool start_streaming_previous_utterance_data();
 115         bool stop_streaming_previous_utterance_data();
 116
 117         CWakeupPolicy* get_wakeup_policy();
 118         CWakeupEngineManager* get_engine_manager();
 119         CAudioManager* get_audio_manager();
 120         CWakeupSettings* get_wakeup_settings();
 121
 122         vector<IWakeupEventObserver*> get_wakeup_observers();
 123         void set_last_wakeup_event_info(mas_wakeup_event_info wakeup_info);
 124
 125         vector<ISettingValueObserver*> get_setting_observers();
 126
 127         bool change_manager_state(wakeup_manager_state_e state);
 128         wakeup_manager_state_e get_manager_state();
 129
 130         void feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
 131         void send_dependency_module_command(string engine_name, string command);
 132 private:
 133         class CEngineEventObserver : public IEngineEventObserver
 134         {
 135         public:
 136                 bool on_wakeup_event(string engine_name, mas_wakeup_event_info wakeup_info) override;
 137                 bool on_speech_status(string engine_name, mas_speech_status_e status) override;
 138                 bool on_error(string engine_name, int error_code, string error_message) override;
 139                 bool on_audio_data_require_status(string engine_name, bool require) override;
 140
 141                 bool on_streaming_audio_data(
 142                         mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
 143                 bool on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) override;
 144                 bool on_wakeup_engine_command(
 145                         mas_wakeup_engine_command_target_e target, string engine, string name, string command) override;
 146
 147                 void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
 148         private:
 149                 CWakeupManager *mWakeupManager{nullptr};
 150         };
 151
 152         class CPolicyEventObserver : public IPolicyEventObserver
 153         {
 154         public:
 155                 void on_wakeup(mas_wakeup_event_info wakeup_info) override;
 156
 157                 void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
 158         private:
 159                 CWakeupManager *mWakeupManager{nullptr};
 160         };
 161
 162         class CAudioEventObserver : public IAudioEventObserver
 163         {
 164         public:
 165                 bool on_recording_audio_data(long time, void* data, int len) override;
 166                 bool on_streaming_audio_data(
 167                         mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
 168
 169                 void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
 170                 void set_wakeup_engine_manager(CWakeupEngineManager *manager) { mEngineManager = manager; }
 171         private:
 172                 CWakeupManager *mWakeupManager{nullptr};
 173                 CWakeupEngineManager *mEngineManager{nullptr};
 174         };
 175
 176         class CSettingsEventObserver : public ISettingsEventObserver
 177         {
 178         public:
 179                 bool on_voice_input_language_changed(const char* language) override;
 180                 bool on_assistant_enabled_info_changed(const char* appid, bool enabled) override;
 181                 bool on_default_assistant_appid_changed(const char* appid) override;
 182
 183                 void set_wakeup_manager(CWakeupManager *manager) { mWakeupManager = manager; }
 184         private:
 185                 CWakeupManager *mWakeupManager{nullptr};
 186         };
 187
 188         void initialize_wakeup_policy();
 189
 190         typedef struct {
 191                 string appid;
 192                 vector<string> languageList;
 193         } AssistantLanguageInfo;
 194         vector<AssistantLanguageInfo> mAssistantLanguageInfo;
 195         map<string, bool> mAssistantSupportsCurrentLanguage;
 196         map<string, bool> mAssistantEnabled;
 197
 198         vector<IWakeupEventObserver*> mWakeupObservers;
 199         vector<ISettingValueObserver*> mSettingObservers;
 200
 201         unique_ptr<CWakeupPolicy> mWakeupPolicy;
 202
 203         CAudioManager mAudioManager;
 204         CWakeupEngineManager mWakeupEngineManager;
 205         CWakeupSettings mWakeupSettings;
 206
 207         CAudioEventObserver mAudioEventObserver;
 208         CEngineEventObserver mEngineEventObserver;
 209         CPolicyEventObserver mPolicyEventObserver;
 210         CSettingsEventObserver mSettingsEventObserver;
 211
 212         thread mEngineDataThread;
 213         atomic_bool mStopEngineDataThread{false};
 214
 215         bool mVoiceKeyPressed{false};
 216         string mCurrentLanguage;
 217         string mCurrentDefaultAssistant;
 218
 219         STREAMING_MODE mStreamingMode{STREAMING_MODE::NONE};
 220         Ecore_Timer* mStreamingDurationTimer{nullptr};
 221
 222         wakeup_manager_state_e mWakeupManagerState{WAKEUP_MANAGER_STATE_INACTIVE};
 223
 224         mas_wakeup_event_info mLastWakeupEventInfo;
 225 };
 226
 227 } // wakeup
 228 } // multiassistant
 229
 230 #endif /* _WAKEUP_MANAGER_H_ */