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 class CWakeupEventObserver : public IWakeupEventObserver
  52 {
  53         void on_wakeup(mas_wakeup_event_info wakeup_info) override;
  54         void on_streaming_audio_data(
  55                 mas_speech_streaming_event_e event, void* buffer, unsigned int len) override;
  56         void on_audio_streaming_data_section(ma_audio_streaming_data_section_e section) override;
  57         void on_wakeup_engine_command(
  58                 mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command) override;
  59 };
  60
  61 class CSettingValueObserver : public ISettingValueObserver
  62 {
  63         void on_value_changed() override;
  64 };
  65
  66 static std::unique_ptr<CWakeupEventObserver> g_wakeup_event_observer;
  67 static std::unique_ptr<CSettingValueObserver> g_setting_value_observer;
  68 static std::unique_ptr<CWakeupManager> g_wakeup_manager;
  69
  70 int wakeup_manager_initialize(void)
  71 {
  72         MWR_LOGD("[ENTER]");
  73
  74         try {
  75                 g_wakeup_event_observer.reset(new CWakeupEventObserver);
  76                 g_setting_value_observer.reset(new CSettingValueObserver);
  77                 if (NULL == g_wakeup_event_observer || NULL == g_setting_value_observer) {
  78                         return -1;
  79                 }
  80                 g_wakeup_manager.reset(new CWakeupManager(g_wakeup_event_observer.get(), g_setting_value_observer.get()));
  81                 if (NULL == g_wakeup_manager) {
  82                         return -1;
  83                 }
  84         } catch (const std::exception& e) {
  85                 MWR_LOGE("Exception caught : %s", e.what());
  86                 return -1;
  87         }
  88
  89         g_wakeup_event_cb = NULL;
  90         g_wakeup_event_user_data = NULL;
  91
  92         g_utterance_streaming_cb = NULL;
  93         g_utterance_streaming_user_data = NULL;
  94
  95         g_follow_up_streaming_cb = NULL;
  96         g_follow_up_streaming_user_data = NULL;
  97
  98         g_speech_status_cb = NULL;
  99         g_speech_status_user_data = NULL;
 100
 101         g_setting_changed_cb = NULL;
 102         g_setting_changed_user_data = NULL;
 103
 104         g_error_cb = NULL;
 105         g_error_user_data = NULL;
 106
 107         g_streaming_section_changed_cb = NULL;
 108         g_streaming_section_changed_user_data = NULL;
 109
 110         g_wakeup_engine_command_cb = NULL;
 111         g_wakeup_engine_command_user_data = NULL;
 112
 113         g_wakeup_manager->initialize();
 114
 115         MWR_LOGD("[END]");
 116         return 0;
 117 }
 118
 119 int wakeup_manager_deinitialize(void)
 120 {
 121         MWR_LOGI("[ENTER]");
 122
 123         if (nullptr == g_wakeup_manager) return -1;
 124
 125         try {
 126                 g_wakeup_manager->deinitialize();
 127                 g_wakeup_manager.reset();
 128
 129                 g_wakeup_event_observer.reset();
 130                 g_setting_value_observer.reset();
 131         } catch (const std::exception& e) {
 132                 MWR_LOGE("Exception caught : %s", e.what());
 133                 return -1;
 134         }
 135
 136         MWR_LOGI("[END]");
 137         return 0;
 138 }
 139
 140 int wakeup_manager_get_settings(ma_plugin_settings **settings, size_t *struct_size)
 141 {
 142         if (NULL == settings || NULL == struct_size) {
 143                 MWR_LOGD("[ERROR] Parameter is invalid, settings(%p), struct_size(%p)", settings, struct_size);
 144                 return -1;
 145         }
 146
 147         if (nullptr == g_wakeup_manager) return -1;
 148         CWakeupSettings* wakeup_settings = g_wakeup_manager->get_wakeup_settings();
 149         if (wakeup_settings) {
 150                 const int PLUGIN_VERSION = 1;
 151                 static ma_plugin_settings current_settings;
 152                 current_settings.plugin_version = PLUGIN_VERSION;
 153                 current_settings.ui_panel_enabled = wakeup_settings->get_ui_panel_enabled();
 154                 *struct_size = sizeof(current_settings);
 155                 *settings = &current_settings;
 156         }
 157
 158         return 0;
 159 }
 160
 161 int wakeup_manager_add_assistant_wakeup_word(const char* appid, const char* wakeup_word, const char* language)
 162 {
 163         MWR_LOGD("[ENTER]");
 164
 165         if (NULL == appid || NULL == wakeup_word) {
 166                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup_word(%s), language(%s)", appid, wakeup_word, language);
 167                 return -1;
 168         }
 169
 170         if (nullptr == g_wakeup_manager) return -1;
 171         g_wakeup_manager->add_assistant_wakeup_word(
 172                 string{appid}, string{wakeup_word}, (language ? string{language} : string{}));
 173
 174         MWR_LOGD("[END]");
 175         return 0;
 176 }
 177
 178 int wakeup_manager_add_assistant_language(const char* appid, const char* language)
 179 {
 180         MWR_LOGD("[ENTER]");
 181
 182         if (NULL == appid || NULL == language) {
 183                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
 184                 return -1;
 185         }
 186
 187         if (nullptr == g_wakeup_manager) return -1;
 188         g_wakeup_manager->add_assistant_language(string{appid}, string{language});
 189
 190         MWR_LOGD("[DEBUG] language(%s)", language);
 191
 192         MWR_LOGD("[END]");
 193         return 0;
 194 }
 195
 196 int wakeup_manager_set_assistant_wakeup_engine(const char* appid, const char* engine)
 197 {
 198         MWR_LOGD("[ENTER]");
 199
 200         if (NULL == appid || NULL == engine) {
 201                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), wakeup engine(%s)", appid, engine);
 202                 return -1;
 203         }
 204
 205         if (nullptr == g_wakeup_manager) return -1;
 206         MWR_LOGD("[DEBUG] appid(%s), wakeup engine(%s)", appid, engine);
 207         g_wakeup_manager->set_assistant_wakeup_engine(string{appid}, string{engine});
 208
 209         MWR_LOGD("[END]");
 210         return 0;
 211 }
 212
 213 int wakeup_manager_set_default_assistant(const char* appid)
 214 {
 215         MWR_LOGD("[ENTER]");
 216
 217         if (NULL == appid) {
 218                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s)", appid);
 219                 return -1;
 220         }
 221
 222         if (nullptr == g_wakeup_manager) return -1;
 223         MWR_LOGD("[DEBUG] default_assistant appid(%s)", appid);
 224         g_wakeup_manager->set_default_assistant(string{appid});
 225
 226         MWR_LOGD("[END]");
 227         return 0;
 228 }
 229
 230 int wakeup_manager_get_default_assistant(const char** appid)
 231 {
 232         static string default_assistant;
 233
 234         if (nullptr == g_wakeup_manager) return -1;
 235         default_assistant = g_wakeup_manager->get_default_assistant();
 236
 237         if (default_assistant.empty()) {
 238                 *appid = nullptr;
 239         } else {
 240                 *appid = default_assistant.c_str();
 241         }
 242         return 0;
 243 }
 244
 245 int wakeup_manager_set_language(const char* language)
 246 {
 247         MWR_LOGD("[ENTER]");
 248
 249         if (NULL == language) {
 250                 MWR_LOGD("[ERROR] Parameter is invalid, language(%s)", language);
 251                 return -1;
 252         }
 253
 254         if (nullptr == g_wakeup_manager) return -1;
 255         g_wakeup_manager->set_language(string{language});
 256
 257         MWR_LOGD("[END]");
 258         return 0;
 259 }
 260
 261 int wakeup_manager_change_state(wakeup_manager_state_e state)
 262 {
 263         if (nullptr == g_wakeup_manager) return -1;
 264         g_wakeup_manager->change_manager_state(state);
 265         return 0;
 266 }
 267
 268 int wakeup_manager_activate(void)
 269 {
 270         MWR_LOGD("[ENTER]");
 271
 272         if (nullptr == g_wakeup_manager) return -1;
 273         g_wakeup_manager->activate();
 274
 275         MWR_LOGD("[END]");
 276         return 0;
 277 }
 278
 279 int wakeup_manager_deactivate(void)
 280 {
 281         MWR_LOGD("[ENTER]");
 282
 283         if (nullptr == g_wakeup_manager) return -1;
 284         g_wakeup_manager->deactivate();
 285
 286         MWR_LOGD("[END]");
 287         return 0;
 288 }
 289
 290 int wakeup_manager_update_voice_feedback_state(const char* appid, int state)
 291 {
 292         MWR_LOGD("[ENTER]");
 293
 294         string appid_string;
 295         if (NULL == appid) {
 296                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s)", appid);
 297         } else {
 298                 appid_string = appid;
 299         }
 300
 301         if (nullptr == g_wakeup_manager) return -1;
 302         g_wakeup_manager->update_voice_feedback_state(appid_string, state);
 303
 304         MWR_LOGD("[END]");
 305         return 0;
 306 }
 307
 308 int wakeup_manager_send_assistant_specific_command(const char* appid, const char* command)
 309 {
 310         MWR_LOGD("[ENTER]");
 311
 312         string appid_string;
 313         string command_string;
 314         if (NULL == appid || NULL == command) {
 315                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s), command(%s)", appid, command);
 316         }
 317         if (appid) appid_string = appid;
 318         if (command) command_string = command;
 319
 320         if (nullptr == g_wakeup_manager) return -1;
 321         g_wakeup_manager->send_assistant_specific_command(appid_string, command_string);
 322
 323         MWR_LOGD("[END]");
 324         return 0;
 325 }
 326
 327 int wakeup_manager_set_background_volume(const char* appid, double ratio)
 328 {
 329         MWR_LOGD("[ENTER]");
 330
 331         string appid_string;
 332         if (NULL == appid) {
 333                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s)", appid);
 334         } else {
 335                 appid_string = appid;
 336         }
 337
 338         if (nullptr == g_wakeup_manager) return -1;
 339         g_wakeup_manager->set_background_volume(appid_string, ratio);
 340
 341         MWR_LOGD("[END]");
 342         return 0;
 343 }
 344
 345 int wakeup_manager_update_recognition_result(const char* appid, int result)
 346 {
 347         MWR_LOGD("[ENTER]");
 348
 349         string appid_string;
 350         if (NULL == appid) {
 351                 MWR_LOGD("[ERROR] Parameter is invalid, appid(%s)", appid);
 352         } else {
 353                 appid_string = appid;
 354         }
 355
 356         if (nullptr == g_wakeup_manager) return -1;
 357         g_wakeup_manager->update_recognition_result(appid_string, result);
 358
 359         MWR_LOGD("[END]");
 360         return 0;
 361 }
 362
 363 int wakeup_manager_process_event(mas_plugin_event_e event, void* data, int len)
 364 {
 365         MWR_LOGD("[ENTER]");
 366
 367         if (nullptr == g_wakeup_manager) return -1;
 368         g_wakeup_manager->process_event(event, data, len);
 369
 370         MWR_LOGD("[END]");
 371         return 0;
 372 }
 373
 374 int wakeup_manager_start_streaming_utterance_data(void)
 375 {
 376         MWR_LOGD("[ENTER]");
 377
 378         if (nullptr == g_wakeup_manager) return -1;
 379         g_wakeup_manager->start_streaming_utterance_data();
 380
 381         MWR_LOGD("[END]");
 382         return 0;
 383 }
 384
 385 int wakeup_manager_stop_streaming_utterance_data(void)
 386 {
 387         MWR_LOGD("[ENTER]");
 388
 389         if (nullptr == g_wakeup_manager) return -1;
 390         g_wakeup_manager->stop_streaming_utterance_data();
 391
 392         MWR_LOGD("[END]");
 393         return 0;
 394 }
 395
 396 int wakeup_manager_start_streaming_follow_up_data(void)
 397 {
 398         MWR_LOGD("[ENTER]");
 399
 400         if (nullptr == g_wakeup_manager) return -1;
 401         g_wakeup_manager->start_streaming_follow_up_data();
 402
 403         MWR_LOGD("[END]");
 404         return 0;
 405 }
 406
 407 int wakeup_manager_stop_streaming_follow_up_data(void)
 408 {
 409         MWR_LOGD("[ENTER]");
 410
 411         if (nullptr == g_wakeup_manager) return -1;
 412         g_wakeup_manager->stop_streaming_follow_up_data();
 413
 414         MWR_LOGD("[END]");
 415         return 0;
 416 }
 417
 418 int wakeup_manager_start_streaming_previous_utterance_data(void)
 419 {
 420         MWR_LOGD("[ENTER]");
 421
 422         if (nullptr == g_wakeup_manager) return -1;
 423         g_wakeup_manager->start_streaming_previous_utterance_data();
 424
 425         MWR_LOGD("[END]");
 426         return 0;
 427 }
 428
 429 int wakeup_manager_stop_streaming_previous_utterance_data(void)
 430 {
 431         MWR_LOGD("[ENTER]");
 432
 433         if (nullptr == g_wakeup_manager) return -1;
 434         g_wakeup_manager->stop_streaming_previous_utterance_data();
 435
 436         MWR_LOGD("[END]");
 437         return 0;
 438 }
 439
 440 int wakeup_manager_get_audio_format(int* rate, int* channel, int* audio_type)
 441 {
 442         MWR_LOGD("[ENTER]");
 443
 444         if (!audio_type || !rate || !channel) {
 445                 MWR_LOGE("[ERROR] Invalid parameter");
 446                 return -1;
 447         }
 448
 449         if (nullptr == g_wakeup_manager) return -1;
 450         g_wakeup_manager->get_audio_format(rate, channel, audio_type);
 451
 452         MWR_LOGD("[END] rate(%d), channel(%d), audio_type(%d)", *rate, *channel, *audio_type);
 453         return 0;
 454 }
 455
 456 int wakeup_manager_get_audio_source_type(char** type)
 457 {
 458         MWR_LOGD("[ENTER]");
 459
 460         if (!type) {
 461                 MWR_LOGE("[ERROR] Invalid parameter");
 462                 return -1;
 463         }
 464
 465         if (nullptr == g_wakeup_manager) return -1;
 466         g_wakeup_manager->get_audio_source_type(type);
 467
 468         MWR_LOGD("[END] type(%s)", *type);
 469         return 0;
 470 }
 471
 472 int wakeup_manager_set_wake_word_audio_require_flag(bool require)
 473 {
 474         MWR_LOGD("[ENTER] : %d", require);
 475
 476         if (nullptr == g_wakeup_manager) return -1;
 477         g_wakeup_manager->set_wake_word_audio_require_flag(require);
 478
 479         MWR_LOGD("[END]");
 480         return 0;
 481 }
 482
 483 int wakeup_manager_set_assistant_language(const char* appid, const char* language)
 484 {
 485         MWR_LOGD("[ENTER]");
 486
 487         string appid_string;
 488         string language_string;
 489         if (NULL == appid || NULL == language) {
 490                 MWR_LOGE("[ERROR] Parameter is invalid, appid(%s), language(%s)", appid, language);
 491                 return -1;
 492         }
 493         appid_string = appid;
 494         language_string = language;
 495
 496         if (nullptr == g_wakeup_manager) return -1;
 497         g_wakeup_manager->set_assistant_language(appid_string, language_string);
 498
 499         MWR_LOGD("[END]");
 500         return 0;
 501 }
 502
 503 int wakeup_manager_set_wakeup_event_callback(wakeup_service_wakeup_event_cb callback, void* user_data)
 504 {
 505         MWR_LOGD("[ENTER]");
 506
 507         if (NULL == callback) {
 508                 MWR_LOGE("[ERROR] Input parameter is NULL");
 509                 return -1;
 510         }
 511
 512         g_wakeup_event_cb = callback;
 513         g_wakeup_event_user_data = user_data;
 514
 515         MWR_LOGD("[END]");
 516         return 0;
 517 }
 518
 519 int wakeup_manager_set_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 520 {
 521         MWR_LOGD("[ENTER]");
 522
 523         if (NULL == callback) {
 524                 MWR_LOGE("[ERROR] Input parameter is NULL");
 525                 return -1;
 526         }
 527
 528         g_utterance_streaming_cb = callback;
 529         g_utterance_streaming_user_data = user_data;
 530
 531         MWR_LOGD("[END]");
 532         return 0;
 533 }
 534
 535 int wakeup_manager_set_previous_utterance_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 536 {
 537         MWR_LOGD("[ENTER]");
 538
 539         if (NULL == callback) {
 540                 MWR_LOGE("[ERROR] Input parameter is NULL");
 541                 return -1;
 542         }
 543
 544         g_previous_utterance_streaming_cb = callback;
 545         g_previous_utterance_streaming_user_data = user_data;
 546
 547         MWR_LOGD("[END]");
 548         return 0;
 549 }
 550
 551 int wakeup_manager_set_follow_up_streaming_callback(wakeup_service_speech_streaming_cb callback, void* user_data)
 552 {
 553         MWR_LOGD("[ENTER]");
 554
 555         if (NULL == callback) {
 556                 MWR_LOGE("[ERROR] Input parameter is NULL");
 557                 return -1;
 558         }
 559
 560         g_follow_up_streaming_cb = callback;
 561         g_follow_up_streaming_user_data = user_data;
 562
 563         MWR_LOGD("[END]");
 564         return 0;
 565 }
 566
 567 int wakeup_manager_set_speech_status_callback(wakeup_service_speech_status_cb callback, void* user_data)
 568 {
 569         MWR_LOGD("[ENTER]");
 570
 571         if (NULL == callback) {
 572                 MWR_LOGE("[ERROR] Input parameter is NULL");
 573                 return -1;
 574         }
 575
 576         g_speech_status_cb = callback;
 577         g_speech_status_user_data = user_data;
 578
 579         MWR_LOGD("[END]");
 580         return 0;
 581 }
 582
 583 int wakeup_manager_set_setting_changed_callback(wakeup_service_setting_changed_cb callback, void* user_data)
 584 {
 585         MWR_LOGD("[ENTER]");
 586
 587         if (NULL == callback) {
 588                 MWR_LOGE("[ERROR] Input parameter is NULL");
 589                 return -1;
 590         }
 591
 592         g_setting_changed_cb = callback;
 593         g_setting_changed_user_data = user_data;
 594
 595         MWR_LOGD("[END]");
 596         return 0;
 597 }
 598
 599 int wakeup_manager_set_error_callback(wakeup_service_error_cb callback, void* user_data)
 600 {
 601         MWR_LOGD("[ENTER]");
 602
 603         if (NULL == callback) {
 604                 MWR_LOGE("[ERROR] Input parameter is NULL");
 605                 return -1;
 606         }
 607
 608         g_error_cb = callback;
 609         g_error_user_data = user_data;
 610
 611         MWR_LOGD("[END]");
 612         return 0;
 613 }
 614
 615 int wakeup_manager_set_streaming_section_changed_callback(wakeup_service_streaming_section_changed_cb callback, void* user_data)
 616 {
 617         MWR_LOGD("[ENTER]");
 618
 619         if (NULL == callback) {
 620                 MWR_LOGE("[ERROR] Input parameter is NULL");
 621                 return -1;
 622         }
 623
 624         g_streaming_section_changed_cb = callback;
 625         g_streaming_section_changed_user_data = user_data;
 626
 627         MWR_LOGD("[END]");
 628         return 0;
 629 }
 630
 631 int wakeup_manager_set_wakeup_engine_command_callback(wakeup_service_engine_command_cb callback, void* user_data)
 632 {
 633         MWR_LOGD("[ENTER]");
 634
 635         if (NULL == callback) {
 636                 MWR_LOGE("[ERROR] Input parameter is NULL");
 637                 return -1;
 638         }
 639
 640         g_wakeup_engine_command_cb = callback;
 641         g_wakeup_engine_command_user_data = user_data;
 642
 643         MWR_LOGD("[END]");
 644         return 0;
 645 }
 646
 647 int wakeup_manager_feed_audio_data(mas_speech_streaming_event_e event, void* buffer, int len)
 648 {
 649         if (nullptr == g_wakeup_manager) return -1;
 650         g_wakeup_manager->feed_audio_data(event, buffer, len);
 651         return 0;
 652 }
 653
 654 int wakeup_manager_send_dependency_module_command(const char* engine_name, const char* command)
 655 {
 656         if (nullptr == g_wakeup_manager) return -1;
 657         g_wakeup_manager->send_dependency_module_command(
 658                 engine_name ? engine_name : "",
 659                 command ? command : "");
 660         return 0;
 661 }
 662
 663 void CWakeupEventObserver::on_wakeup(mas_wakeup_event_info wakeup_info)
 664 {
 665         if (NULL != g_wakeup_event_cb) {
 666                 g_wakeup_event_cb(wakeup_info, g_wakeup_event_user_data);
 667         }
 668 }
 669
 670 void CWakeupEventObserver::on_streaming_audio_data(
 671         mas_speech_streaming_event_e event, void* buffer, unsigned int len)
 672 {
 673         if (MAS_SPEECH_STREAMING_EVENT_START == event) {
 674                 MWR_LOGD("streaming_cb START");
 675         }
 676         if (MAS_SPEECH_STREAMING_EVENT_FINISH == event) {
 677                 MWR_LOGD("streaming_cb FINISH");
 678         }
 679         if (NULL != g_utterance_streaming_cb) {
 680                 g_utterance_streaming_cb(event, buffer, len, g_utterance_streaming_user_data);
 681         } else {
 682                 MWR_LOGI("[INFO] No service streaming callback");
 683         }
 684 }
 685
 686 void CWakeupEventObserver::on_audio_streaming_data_section(
 687         ma_audio_streaming_data_section_e section)
 688 {
 689         if (g_streaming_section_changed_cb) {
 690                 g_streaming_section_changed_cb(section, g_streaming_section_changed_user_data);
 691         }
 692 }
 693
 694 void CWakeupEventObserver::on_wakeup_engine_command(
 695         mas_wakeup_engine_command_target_e target, const char* assistant_name, const char* command)
 696 {
 697         if (g_wakeup_engine_command_cb) {
 698                 g_wakeup_engine_command_cb(target, assistant_name, command, g_wakeup_engine_command_user_data);
 699         }
 700 }
 701
 702 void CSettingValueObserver::on_value_changed()
 703 {
 704         if (g_setting_changed_cb) {
 705                 g_setting_changed_cb(g_setting_changed_user_data);
 706         }
 707 }