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