plugins/wakeup-manager/src/wakeup_manager_wrapper.cpp

   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 #include "wakeup_manager_wrapper.h"
  17 #include "wakeup_manager_main.h"
  18 #include "wakeup_manager.h"
  19
  20 #include <memory>
  21
  22 #if 0
  23 #define BUF_SAVE_MODE
  24 #endif
  25 #if 0
  26 #define BUF_LOAD_MODE
  27 #endif
  28
  29 #ifdef BUF_SAVE_MODE
  30 static char g_temp_file_name[128] = {'\0', };
  31
  32 static FILE* g_pFile = NULL;
  33
  34 static int g_count = 1;
  35 #endif
  36
  37 #ifdef BUF_LOAD_MODE
  38 static FILE* g_pFile = NULL;
  39 #endif
  40
  41 using namespace multiassistant::wakeup;
  42
  43 static wakeup_service_wakeup_event_cb g_wakeup_event_cb;
  44 static void* g_wakeup_event_user_data;
  45
  46 static wakeup_service_speech_streaming_cb g_utterance_streaming_cb;
  47 static void* g_utterance_streaming_user_data;
  48
  49 static wakeup_service_speech_streaming_cb g_previous_utterance_streaming_cb;
  50 static void* g_previous_utterance_streaming_user_data;
  51
  52 static wakeup_service_speech_streaming_cb g_follow_up_streaming_cb;
  53 static void* g_follow_up_streaming_user_data;
  54
  55 static wakeup_service_speech_status_cb g_speech_status_cb;
  56 static void* g_speech_status_user_data;
  57
  58 static wakeup_service_setting_changed_cb g_setting_changed_cb;
  59 static void* g_setting_changed_user_data;
  60
  61 static wakeup_service_error_cb g_error_cb;
  62 static void* g_error_user_data;
  63
  64 static wakeup_service_streaming_section_changed_cb g_streaming_section_changed_cb;
  65 static void* g_streaming_section_changed_user_data;
  66
  67 static wakeup_service_engine_command_cb g_wakeup_engine_command_cb;
  68 static void* g_wakeup_engine_command_user_data;
  69
  70 static wakeup_service_state_changed_cb g_wakeup_service_state_changed_cb;
  71 static void *g_wakeup_service_state_changed_user_data;
  72
  73 static wakeup_service_voice_key_status_changed_cb g_wakeup_service_voice_key_status_changed_cb;
  74 static void *g_wakeup_service_voice_key_status_changed_user_data;
  75
  76 static wakeup_service_loaded_engine_changed_cb g_loaded_engine_changed_cb;
  77 static void *g_loaded_engine_changed_user_data;
  78
  79 class CWakeupEventObserver : public IWakeupEventObserver
  80 {
  81         void on_wakeup(mas_wakeup_event_info wakeup_info) override;
  82         void on_streaming_audio_data(
  83                 mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
  84         void on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) override;
  85         void on_wakeup_engine_command(
  86                 mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command) override;
  87         void on_wakeup_service_state_changed(ma_service_state_e state) override;
  88         void on_voice_key_status_changed(ma_voice_key_status_e status) override;
  89 };
  90
  91 class CSettingValueObserver : public ISettingValueObserver
  92 {
  93         void on_value_changed() override;
  94         void on_loaded_wakeup_engine_changed() override;
  95 };
  96
  97 static std::unique_ptr<CWakeupEventObserver> g_wakeup_event_observer;
  98 static std::unique_ptr<CSettingValueObserver> g_setting_value_observer;
  99 static std::unique_ptr<CWakeupManager> g_wakeup_manager;
 100
 101 int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len);
 102
 103 #ifdef BUF_LOAD_MODE
 104 static Eina_Bool file_read_feed(void *data)
 105 {
 106         if (g_pFile == NULL) {
 107                 g_pFile = fopen("/tmp/ma_feed_file", "rb");
 108                 if (g_pFile == NULL) return EINA_FALSE;
 109         }
 110
 111         if (feof(g_pFile)) {
 112                 fclose(g_pFile);
 113                 return EINA_FALSE;
 114         }
 115
 116         const size_t BUFFER_SIZE = 4096;
 117         unsigned char buffer[BUFFER_SIZE];
 118         size_t len = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, g_pFile);
 119         wakeup_manager_feed_audio_data(MAS_SPEECH_STREAMING_EVENT_CONTINUE, buffer, len);
 120
 121         return EINA_TRUE;
 122 }
 123 #endif
 124
 125 int wakeup_manager_initialize(void)
 126 {
 127         MWR_LOGI("[ENTER]");
 128
 129         try {
 130                 g_wakeup_event_observer.reset(new CWakeupEventObserver);
 131                 g_setting_value_observer.reset(new CSettingValueObserver);
 132                 if (NULL == g_wakeup_event_observer || NULL == g_setting_value_observer) {
 133                         return -1;
 134                 }
 135                 g_wakeup_manager.reset(new CWakeupManager(g_wakeup_event_observer.get(), g_setting_value_observer.get()));
 136                 if (NULL == g_wakeup_manager) {
 137                         return -1;
 138                 }
 139         } catch (const std::exception& e) {
 140                 MWR_LOGE("Exception caught : %s", e.what());
 141                 return -1;
 142         }
 143
 144         g_wakeup_event_cb = NULL;
 145         g_wakeup_event_user_data = NULL;
 146
 147         g_utterance_streaming_cb = NULL;
 148         g_utterance_streaming_user_data = NULL;
 149
 150         g_follow_up_streaming_cb = NULL;
 151         g_follow_up_streaming_user_data = NULL;
 152
 153         g_speech_status_cb = NULL;
 154         g_speech_status_user_data = NULL;
 155
 156         g_setting_changed_cb = NULL;
 157         g_setting_changed_user_data = NULL;
 158
 159         g_error_cb = NULL;
 160         g_error_user_data = NULL;
 161
 162         g_streaming_section_changed_cb = NULL;
 163         g_streaming_section_changed_user_data = NULL;
 164
 165         g_wakeup_engine_command_cb = NULL;
 166         g_wakeup_engine_command_user_data = NULL;
 167
 168         g_wakeup_service_state_changed_cb = NULL;
 169         g_wakeup_service_state_changed_user_data = NULL;
 170
 171         g_wakeup_service_voice_key_status_changed_cb = NULL;
 172         g_wakeup_service_voice_key_status_changed_user_data = NULL;
 173
 174         g_loaded_engine_changed_cb = NULL;
 175         g_loaded_engine_changed_user_data = NULL;
 176
 177         g_wakeup_manager->initialize();
 178
 179         MWR_LOGD("[END]");
 180
 181 #ifdef BUF_SAVE_MODE
 182         if (g_pFile) {
 183                 fclose(g_pFile);
 184                 g_pFile = NULL;
 185         } else {
 186                 MWR_LOGD("[Recorder Info] File not found!");
 187         }
 188
 189         while (1) {
 190                 snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/wakeup_manager_%d_%d", getpid(), g_count);
 191                 int ret = access(g_temp_file_name, 0);
 192
 193                 if (0 == ret) {
 194                         MWR_LOGD("[Recorder ERROR] File is already exist");
 195                         if (0 == remove(g_temp_file_name)) {
 196                                 MWR_LOGD("[Recorder] Remove file");
 197                                 break;
 198                         } else {
 199                                 g_count++;
 200                         }
 201                 } else {
 202                         break;
 203                 }
 204         }
 205
 206         MWR_LOGD("[Recorder] Temp file name=[%s]", g_temp_file_name);
 207
 208         /* open test file */
 209         g_pFile = fopen(g_temp_file_name, "wb+x");
 210         if (!g_pFile) {
 211                 MWR_LOGD("[Recorder ERROR] File not found!");
 212         }
 213         g_count++;
 214 #endif
 215
 216 #ifdef BUF_LOAD_MODE
 217         Ecore_Timer* timer = ecore_timer_add(0.01f, file_read_feed, NULL);
 218 #endif
 219         return 0;
 220 }
 221
 222 int wakeup_manager_deinitialize(void)
 223 {
 224         MWR_LOGI("[ENTER]");
 225
 226 #ifdef BUF_SAVE_MODE
 227         if (g_pFile) {
 228                 MWR_LOGE("[Recorder SUCCESS] File Close");
 229                 fclose(g_pFile);
 230                 g_pFile = NULL;
 231         }
 232 #endif
 233
 234         if (nullptr == g_wakeup_manager) return -1;
 235
 236         try {
 237                 g_wakeup_manager->deinitialize();
 238                 g_wakeup_manager.reset();
 239
 240                 g_wakeup_event_observer.reset();
 241                 g_setting_value_observer.reset();
 242         } catch (const std::exception& e) {
 243                 MWR_LOGE("Exception caught : %s", e.what());
 244                 return -1;
 245         }
 246
 247         MWR_LOGI("[END]");
 248         return 0;
 249 }
 250
 251 int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size)
 252 {
 253         if (NULL == settings || NULL == struct_size) {
 254                 MWR_LOGD("[ERROR] Parameter is invalid, settings(%p), struct_size(%p)", settings, struct_size);
 255                 return -1;
 256         }
 257
 258         if (nullptr == g_wakeup_manager) return -1;
 259         CWakeupSettings* wakeup_settings = g_wakeup_manager->get_wakeup_settings();
 260         if (wakeup_settings) {
 261                 const int PLUGIN_VERSION = 1;
 262                 static ma_plugin_settings current_settings;
 263                 current_settings.plugin_version = PLUGIN_VERSION;
 264                 current_settings.ui_panel_enabled = wakeup_settings->get_ui_panel_enabled();
 265                 *struct_size = sizeof(current_settings);
 266                 *settings = &current_settings;
 267         }
 268
 269         return 0;
 270 }
 271
 272 int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
 273 {
 274         MWR_LOGI("[ENTER]");
 275
 276         if (NULL == appid || NULL == wakeup_word) {
 277                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
 278                 return -1;
 279         }
 280
 281         if (nullptr == g_wakeup_manager) return -1;
 282         g_wakeup_manager->add_assistant_wakeup_word(
 283                 string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
 284
 285         MWR_LOGD("[END]");
 286         return 0;
 287 }
 288
 289 int wakeup_manager_remove_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
 290 {
 291         MWR_LOGI("[ENTER]");
 292
 293         if (NULL == appid || NULL == wakeup_word) {
 294                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
 295                 return -1;
 296         }
 297
 298         if (nullptr == g_wakeup_manager) return -1;
 299         g_wakeup_manager->remove_assistant_wakeup_word(
 300                 string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
 301
 302         MWR_LOGD("[END]");
 303         return 0;
 304 }
 305
 306 int wakeup_manager_add_assistant_language(const char* appid, const char* language)
 307 {
 308         MWR_LOGI("[ENTER]");
 309
 310         if (NULL == appid || NULL == language) {
 311                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
 312                 return -1;
 313         }
 314
 315         if (nullptr == g_wakeup_manager) return -1;
 316         g_wakeup_manager->add_assistant_language(string{appid}, string{language});
 317
 318         MWR_LOGD("[DEBUG] language(%s)", language);
 319
 320         MWR_LOGD("[END]");
 321         return 0;
 322 }
 323
 324 int wakeup_manager_add_assistant_wakeup_engine(const char* appid, const char* engine)
 325 {
 326         MWR_LOGI("[ENTER]");
 327
 328         if (NULL == appid || NULL == engine) {
 329                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup engine(%s)", appid, engine);
 330                 return -1;
 331         }
 332
 333         if (nullptr == g_wakeup_manager) return -1;
 334         MWR_LOGD("[DEBUG] appid(%s), wakeup engine(%s)", appid, engine);
 335         g_wakeup_manager->add_assistant_wakeup_engine(string{appid}, string{engine});
 336
 337         MWR_LOGD("[END]");
 338         return 0;
 339 }
 340
 341 int wakeup_manager_set_default_assistant(const char* appid)
 342 {
 343         MWR_LOGI("[ENTER]");
 344
 345         if (NULL == appid) {
 346                 MWR_LOGD("[ERROR] Parameter is NULL");
 347                 return -1;
 348         }
 349
 350         if (nullptr == g_wakeup_manager) return -1;
 351         MWR_LOGD("[DEBUG] default_assistant appid(%s)", appid);
 352         g_wakeup_manager->set_default_assistant(string{appid});
 353
 354         MWR_LOGD("[END]");
 355         return 0;
 356 }
 357
 358 int wakeup_manager_get_default_assistant(const char** appid)
 359 {
 360         static string default_assistant;
 361
 362         if (nullptr == g_wakeup_manager) return -1;
 363         default_assistant = g_wakeup_manager->get_default_assistant();
 364
 365         if (default_assistant.empty()) {
 366                 *appid = nullptr;
 367         } else {
 368                 *appid = default_assistant.c_str();
 369         }
 370         return 0;
 371 }
 372
 373 int wakeup_manager_set_language(const char* language)
 374 {
 375         MWR_LOGI("[ENTER]");
 376
 377         if (NULL == language) {
 378                 MWR_LOGD("[ERROR] Parameter is NULL");
 379                 return -1;
 380         }
 381
 382         if (nullptr == g_wakeup_manager) return -1;
 383         g_wakeup_manager->set_language(string{language});
 384
 385         MWR_LOGD("[END]");
 386         return 0;
 387 }
 388
 389 int wakeup_manager_change_state(wakeup_manager_state_e state)
 390 {
 391         if (nullptr == g_wakeup_manager) return -1;
 392         g_wakeup_manager->change_manager_state(state);
 393         return 0;
 394 }
 395
 396 int wakeup_manager_activate(void)
 397 {
 398         MWR_LOGI("[ENTER]");
 399
 400         if (nullptr == g_wakeup_manager) return -1;
 401         g_wakeup_manager->activate();
 402
 403         MWR_LOGD("[END]");
 404         return 0;
 405 }
 406
 407 int wakeup_manager_deactivate(void)
 408 {
 409         MWR_LOGI("[ENTER]");
 410
 411         if (nullptr == g_wakeup_manager) return -1;
 412         g_wakeup_manager->deactivate();
 413
 414         MWR_LOGD("[END]");
 415         return 0;
 416 }
 417
 418 int wakeup_manager_update_voice_feedback_state(const char* appid, int state)
 419 {
 420         MWR_LOGI("[ENTER]");
 421
 422         string appid_string;
 423         if (NULL == appid) {
 424                 MWR_LOGD("[ERROR] Parameter is NULL");
 425         } else {
 426                 appid_string = appid;
 427         }
 428
 429         if (nullptr == g_wakeup_manager) return -1;
 430         g_wakeup_manager->update_voice_feedback_state(appid_string, state);
 431
 432         MWR_LOGD("[END]");
 433         return 0;
 434 }
 435
 436 int wakeup_manager_set_assistant_specific_command(const char* appid, const char* command)
 437 {
 438         MWR_LOGI("[ENTER]");
 439
 440         string appid_string;
 441         string command_string;
 442         if (NULL == appid || NULL == command) {
 443                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), command(%s)", appid, command);
 444         }
 445         if (appid) appid_string = appid;
 446         if (command) command_string = command;
 447
 448         if (nullptr == g_wakeup_manager) return -1;
 449         g_wakeup_manager->set_assistant_specific_command(appid_string, command_string);
 450
 451         MWR_LOGD("[END]");
 452         return 0;
 453 }
 454
 455 int wakeup_manager_set_background_volume(const char* appid, double ratio)
 456 {
 457         MWR_LOGI("[ENTER]");
 458
 459         string appid_string;
 460         if (NULL == appid) {
 461                 MWR_LOGD("[ERROR] Parameter is NULL");
 462         } else {
 463                 appid_string = appid;
 464         }
 465
 466         if (nullptr == g_wakeup_manager) return -1;
 467         g_wakeup_manager->set_background_volume(appid_string, ratio);
 468
 469         MWR_LOGD("[END]");
 470         return 0;
 471 }
 472
 473 int wakeup_manager_update_recognition_result(const char* appid, int result)
 474 {
 475         MWR_LOGI("[ENTER]");
 476
 477         string appid_string;
 478         if (NULL == appid) {
 479                 MWR_LOGD("[ERROR] Parameter is NULL");
 480         } else {
 481                 appid_string = appid;
 482         }
 483
 484         if (nullptr == g_wakeup_manager) return -1;
 485         g_wakeup_manager->update_recognition_result(appid_string, result);
 486
 487         MWR_LOGD("[END]");
 488         return 0;
 489 }
 490
 491 int wakeup_manager_process_plugin_event(mas_plugin_event_e event, void* data, int len)
 492 {
 493         MWR_LOGI("[ENTER]");
 494
 495         if (nullptr == g_wakeup_manager) return -1;
 496         g_wakeup_manager->process_plugin_event(event, data, len);
 497
 498         MWR_LOGD("[END]");
 499         return 0;
 500 }
 501
 502 int wakeup_manager_start_streaming_utterance_data(void)
 503 {
 504         MWR_LOGI("[ENTER]");
 505
 506         if (nullptr == g_wakeup_manager) return -1;
 507         g_wakeup_manager->start_streaming_utterance_data();
 508
 509         MWR_LOGD("[END]");
 510         return 0;
 511 }
 512
 513 int wakeup_manager_stop_streaming_utterance_data(void)
 514 {
 515         MWR_LOGI("[ENTER]");
 516
 517         if (nullptr == g_wakeup_manager) return -1;
 518         g_wakeup_manager->stop_streaming_utterance_data();
 519
 520         MWR_LOGD("[END]");
 521         return 0;
 522 }
 523
 524 int wakeup_manager_start_streaming_follow_up_data(void)
 525 {
 526         MWR_LOGI("[ENTER]");
 527
 528         if (nullptr == g_wakeup_manager) return -1;
 529         g_wakeup_manager->start_streaming_follow_up_data();
 530
 531         MWR_LOGD("[END]");
 532         return 0;
 533 }
 534
 535 int wakeup_manager_stop_streaming_follow_up_data(void)
 536 {
 537         MWR_LOGI("[ENTER]");
 538
 539         if (nullptr == g_wakeup_manager) return -1;
 540         g_wakeup_manager->stop_streaming_follow_up_data();
 541
 542         MWR_LOGD("[END]");
 543         return 0;
 544 }
 545
 546 int wakeup_manager_start_streaming_previous_utterance_data(void)
 547 {
 548         MWR_LOGI("[ENTER]");
 549
 550         if (nullptr == g_wakeup_manager) return -1;
 551         g_wakeup_manager->start_streaming_previous_utterance_data();
 552
 553         MWR_LOGD("[END]");
 554         return 0;
 555 }
 556
 557 int wakeup_manager_stop_streaming_previous_utterance_data(void)
 558 {
 559         MWR_LOGI("[ENTER]");
 560
 561         if (nullptr == g_wakeup_manager) return -1;
 562         g_wakeup_manager->stop_streaming_previous_utterance_data();
 563
 564         MWR_LOGD("[END]");
 565         return 0;
 566 }
 567
 568 int wakeup_manager_get_audio_format(int* rate, int* channel, int* audio_type)
 569 {
 570         MWR_LOGI("[ENTER]");
 571
 572         if (!audio_type || !rate || !channel) {
 573                 MWR_LOGE("[ERROR] Invalid parameter");
 574                 return -1;
 575         }
 576
 577         if (nullptr == g_wakeup_manager) return -1;
 578         g_wakeup_manager->get_audio_format(rate, channel, audio_type);
 579
 580         MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
 581         return 0;
 582 }
 583
 584 int wakeup_manager_get_audio_source_type(char** type)
 585 {
 586         MWR_LOGI("[ENTER]");
 587
 588         if (!type) {
 589                 MWR_LOGE("[ERROR] Invalid parameter");
 590                 return -1;
 591         }
 592
 593         if (nullptr == g_wakeup_manager) return -1;
 594         g_wakeup_manager->get_audio_source_type(type);
 595
 596         MWR_LOGD("[END] type(%s)", *type);
 597         return 0;
 598 }
 599
 600 int wakeup_manager_set_voice_key_tap_duration(float duration)
 601 {
 602         MWR_LOGI("[ENTER]");
 603
 604         if (nullptr == g_wakeup_manager) return -1;
 605         g_wakeup_manager->set_voice_key_tap_duration(duration);
 606
 607         MWR_LOGD("[END] duration(%f)", duration);
 608         return 0;
 609 }
 610
 611 int wakeup_manager_unset_voice_key_tap_duration()
 612 {
 613         MWR_LOGI("[ENTER]");
 614
 615         if (nullptr == g_wakeup_manager) return -1;
 616         g_wakeup_manager->unset_voice_key_tap_duration();
 617
 618         MWR_LOGD("[END]");
 619         return 0;
 620 }
 621
 622 int wakeup_manager_set_voice_key_support_mode(int mode)
 623 {
 624         MWR_LOGI("[ENTER] : %d", mode);
 625
 626         if (nullptr == g_wakeup_manager) return -1;
 627         g_wakeup_manager->set_voice_key_support_mode(static_cast<VOICE_KEY_SUPPORT_MODE>(mode));
 628
 629         MWR_LOGD("[END]");
 630         return 0;
 631 }
 632
 633 int wakeup_manager_set_wake_word_audio_require_flag(bool require)
 634 {
 635         MWR_LOGI("[ENTER] : %d", require);
 636
 637         if (nullptr == g_wakeup_manager) return -1;
 638         g_wakeup_manager->set_wake_word_audio_require_flag(require);
 639
 640         MWR_LOGD("[END]");
 641         return 0;
 642 }
 643
 644 int wakeup_manager_set_assistant_language(const char* appid, const char* language)
 645 {
 646         MWR_LOGI("[ENTER]");
 647
 648         string appid_string;
 649         string language_string;
 650         if (NULL == appid || NULL == language) {
 651                 MWR_LOGE("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
 652                 return -1;
 653         }
 654         appid_string = appid;
 655         language_string = language;
 656
 657         if (nullptr == g_wakeup_manager) return -1;
 658         g_wakeup_manager->set_assistant_language(appid_string, language_string);
 659
 660         MWR_LOGD("[END]");
 661         return 0;
 662 }
 663
 664 int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data)
 665 {
 666         MWR_LOGI("[ENTER]");
 667
 668         if (NULL == callback) {
 669                 MWR_LOGE("[ERROR] Input parameter is NULL");
 670                 return -1;
 671         }
 672
 673         g_wakeup_event_cb = callback;
 674         g_wakeup_event_user_data = user_data;
 675
 676         MWR_LOGD("[END]");
 677         return 0;
 678 }
 679
 680 int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 681 {
 682         MWR_LOGI("[ENTER]");
 683
 684         if (NULL == callback) {
 685                 MWR_LOGE("[ERROR] Input parameter is NULL");
 686                 return -1;
 687         }
 688
 689         g_utterance_streaming_cb = callback;
 690         g_utterance_streaming_user_data = user_data;
 691
 692         MWR_LOGD("[END]");
 693         return 0;
 694 }
 695
 696 int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 697 {
 698         MWR_LOGI("[ENTER]");
 699
 700         if (NULL == callback) {
 701                 MWR_LOGE("[ERROR] Input parameter is NULL");
 702                 return -1;
 703         }
 704
 705         g_previous_utterance_streaming_cb = callback;
 706         g_previous_utterance_streaming_user_data = user_data;
 707
 708         MWR_LOGD("[END]");
 709         return 0;
 710 }
 711
 712 int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 713 {
 714         MWR_LOGI("[ENTER]");
 715
 716         if (NULL == callback) {
 717                 MWR_LOGE("[ERROR] Input parameter is NULL");
 718                 return -1;
 719         }
 720
 721         g_follow_up_streaming_cb = callback;
 722         g_follow_up_streaming_user_data = user_data;
 723
 724         MWR_LOGD("[END]");
 725         return 0;
 726 }
 727
 728 int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data)
 729 {
 730         MWR_LOGI("[ENTER]");
 731
 732         if (NULL == callback) {
 733                 MWR_LOGE("[ERROR] Input parameter is NULL");
 734                 return -1;
 735         }
 736
 737         g_speech_status_cb = callback;
 738         g_speech_status_user_data = user_data;
 739
 740         MWR_LOGD("[END]");
 741         return 0;
 742 }
 743
 744 int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data)
 745 {
 746         MWR_LOGI("[ENTER]");
 747
 748         if (NULL == callback) {
 749                 MWR_LOGE("[ERROR] Input parameter is NULL");
 750                 return -1;
 751         }
 752
 753         g_setting_changed_cb = callback;
 754         g_setting_changed_user_data = user_data;
 755
 756         MWR_LOGD("[END]");
 757         return 0;
 758 }
 759
 760 int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data)
 761 {
 762         MWR_LOGI("[ENTER]");
 763
 764         if (NULL == callback) {
 765                 MWR_LOGE("[ERROR] Input parameter is NULL");
 766                 return -1;
 767         }
 768
 769         g_error_cb = callback;
 770         g_error_user_data = user_data;
 771
 772         MWR_LOGD("[END]");
 773         return 0;
 774 }
 775
 776 int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data)
 777 {
 778         MWR_LOGI("[ENTER]");
 779
 780         if (NULL == callback) {
 781                 MWR_LOGE("[ERROR] Input parameter is NULL");
 782                 return -1;
 783         }
 784
 785         g_streaming_section_changed_cb = callback;
 786         g_streaming_section_changed_user_data = user_data;
 787
 788         MWR_LOGD("[END]");
 789         return 0;
 790 }
 791
 792 int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data)
 793 {
 794         MWR_LOGI("[ENTER]");
 795
 796         if (NULL == callback) {
 797                 MWR_LOGE("[ERROR] Input parameter is NULL");
 798                 return -1;
 799         }
 800
 801         g_wakeup_engine_command_cb = callback;
 802         g_wakeup_engine_command_user_data = user_data;
 803
 804         MWR_LOGD("[END]");
 805         return 0;
 806 }
 807
 808 int wakeup_manager_set_wakeup_service_state_changed_callback(wakeup_service_state_changed_cb callback, void* user_data)
 809 {
 810         MWR_LOGI("[ENTER]");
 811
 812         if (NULL == callback) {
 813                 MWR_LOGE("[ERROR] Input parameter is NULL");
 814                 return -1;
 815         }
 816
 817         g_wakeup_service_state_changed_cb = callback;
 818         g_wakeup_service_state_changed_user_data = user_data;
 819
 820         MWR_LOGD("[END]");
 821         return 0;
 822 }
 823
 824 int wakeup_manager_set_voice_key_status_changed_callback(wakeup_service_voice_key_status_changed_cb callback, void* user_data)
 825 {
 826         MWR_LOGI("[ENTER]");
 827
 828         if (NULL == callback) {
 829                 MWR_LOGE("[ERROR] Input parameter is NULL");
 830                 return -1;
 831         }
 832
 833         g_wakeup_service_voice_key_status_changed_cb = callback;
 834         g_wakeup_service_voice_key_status_changed_user_data = user_data;
 835
 836         MWR_LOGD("[END]");
 837         return 0;
 838 }
 839
 840 int wakeup_manager_set_loaded_engine_changed_callback(wakeup_service_loaded_engine_changed_cb callback, void* user_data)
 841 {
 842         MWR_LOGI("[ENTER]");
 843
 844         if (NULL == callback) {
 845                 MWR_LOGE("[ERROR] Input parameter is NULL");
 846                 return -1;
 847         }
 848
 849         g_loaded_engine_changed_cb = callback;
 850         g_loaded_engine_changed_user_data = user_data;
 851
 852         MWR_LOGD("[END]");
 853         return 0;
 854 }
 855
 856 int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
 857 {
 858         if (nullptr == g_wakeup_manager) return -1;
 859
 860 #ifdef BUF_SAVE_MODE
 861         static int num = 0;
 862         const int MAXIMUM_NUM = 1000;
 863         if (g_pFile && num++ < MAXIMUM_NUM)
 864                 fwrite(buffer, 1, len, g_pFile);
 865 #endif
 866
 867         g_wakeup_manager->feed_audio_data(event, buffer, len);
 868
 869         return 0;
 870 }
 871
 872 int wakeup_manager_set_dependency_module_command(const char* engine_name, const char* command)
 873 {
 874         if (nullptr == g_wakeup_manager) return -1;
 875         g_wakeup_manager->set_dependency_module_command(
 876                 engine_name ? engine_name : "",
 877                 command ? command : "");
 878         return 0;
 879 }
 880
 881 int wakeup_manager_wakeup_assistant(const mas_wakeup_event_info* wakeup_info)
 882 {
 883         if (nullptr == g_wakeup_manager) return -1;
 884         CWakeupPolicy* policy = g_wakeup_manager->get_wakeup_policy();
 885         if (policy) policy->select_candidate(*wakeup_info);
 886         return 0;
 887 }
 888
 889 void CWakeupEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
 890 {
 891         if (NULL != g_wakeup_event_cb) {
 892                 g_wakeup_event_cb(wakeup_info, g_wakeup_event_user_data);
 893         }
 894 }
 895
 896 void CWakeupEventObserver::on_streaming_audio_data(
 897         mas_speech_streaming_event_e event, void* buffer, unsigned int len)
 898 {
 899         if (MAS_SPEECH_STREAMING_EVENT_START == event) {
 900                 MWR_LOGI("streaming_cb START");
 901         }
 902         if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
 903                 MWR_LOGI("streaming_cb FINISH");
 904         }
 905         if (NULL != g_utterance_streaming_cb) {
 906                 g_utterance_streaming_cb(event, buffer, len, g_utterance_streaming_user_data);
 907         } else {
 908                 MWR_LOGI("[INFO] No service streaming callback");
 909         }
 910 }
 911
 912 void CWakeupEventObserver::on_audio_streaming_data_section(
 913         ma_audio_streaming_data_section_e section)
 914 {
 915         if (g_streaming_section_changed_cb) {
 916                 g_streaming_section_changed_cb(section, g_streaming_section_changed_user_data);
 917         }
 918 }
 919
 920 void CWakeupEventObserver::on_wakeup_engine_command(
 921         mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command)
 922 {
 923         if (g_wakeup_engine_command_cb) {
 924                 g_wakeup_engine_command_cb(target, assistant_name, command, g_wakeup_engine_command_user_data);
 925         }
 926 }
 927
 928 void CWakeupEventObserver::on_wakeup_service_state_changed(ma_service_state_e state)
 929 {
 930         if (g_wakeup_service_state_changed_cb) {
 931                 g_wakeup_service_state_changed_cb(state, g_wakeup_service_state_changed_user_data);
 932         }
 933 }
 934
 935 void CWakeupEventObserver::on_voice_key_status_changed(ma_voice_key_status_e status)
 936 {
 937         if (g_wakeup_service_voice_key_status_changed_cb) {
 938                 g_wakeup_service_voice_key_status_changed_cb(status, g_wakeup_service_voice_key_status_changed_user_data);
 939         }
 940 }
 941
 942 void CSettingValueObserver::on_value_changed()
 943 {
 944         if (g_setting_changed_cb) {
 945                 g_setting_changed_cb(g_setting_changed_user_data);
 946         }
 947 }
 948
 949 void CSettingValueObserver::on_loaded_wakeup_engine_changed()
 950 {
 951         if (g_loaded_engine_changed_cb) {
 952                 g_loaded_engine_changed_cb(g_loaded_engine_changed_user_data);
 953         }
 954 }