src/service_ipc_dbus_dispatcher.cpp

   1 /*
   2  * Copyright 2020 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 #include <stdlib.h>
  18
  19 #include "service_common.h"
  20 #include "service_ipc_dbus_dispatcher.h"
  21 #include "service_main.h"
  22
  23 /*
  24 * Dbus Client-Daemon Server
  25 */
  26 int CServiceIpcDbusDispatcher::on_hello(DBusConnection* conn, DBusMessage* msg)
  27 {
  28         MAS_LOGD("[DEBUG] MAS HELLO");
  29
  30         DBusMessage* reply;
  31         reply = dbus_message_new_method_return(msg);
  32
  33         if (NULL != reply) {
  34                 if (!dbus_connection_send(conn, reply, NULL)) {
  35                         MAS_LOGE("[OUT ERROR] Out Of Memory!");
  36                 }
  37
  38                 dbus_connection_flush(conn);
  39                 dbus_message_unref(reply);
  40         } else {
  41                 MAS_LOGE("[OUT ERROR] Fail to create reply message!!");
  42         }
  43
  44         return 0;
  45 }
  46
  47 int CServiceIpcDbusDispatcher::on_initialize(DBusConnection* conn, DBusMessage* msg)
  48 {
  49         if (nullptr == mIpcObserver) {
  50                 MAS_LOGE("mIpcObserver variable is NULL");
  51                 return -1;
  52         }
  53
  54         DBusError err;
  55         dbus_error_init(&err);
  56
  57         int pid = -1;
  58         int ret = 0;
  59
  60         if (FALSE == dbus_message_get_args(msg, &err,
  61                 DBUS_TYPE_INT32, &pid,
  62                 DBUS_TYPE_INVALID)) {
  63                 MAS_LOGE("[ERROR] Failed retrieving arguments");
  64         }
  65
  66         MAS_LOGD("[DEBUG] MAS INITIALIZE");
  67
  68         if (dbus_error_is_set(&err)) {
  69                 MAS_LOGE("[IN ERROR] mas initialize : get arguments error (%s)", err.message);
  70                 dbus_error_free(&err);
  71                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
  72         } else {
  73                 MAS_LOGD("[IN] mas initialize : pid(%d)", pid);
  74                 ret = mIpcObserver->on_initialize(pid);
  75         }
  76
  77         DBusMessage* reply;
  78         reply = dbus_message_new_method_return(msg);
  79
  80         MAS_LOGI("[OUT] mas initialize : result(%d)", ret);
  81         if (NULL != reply) {
  82                 dbus_message_append_args(reply,
  83                         DBUS_TYPE_INT32, &ret,
  84                         DBUS_TYPE_INVALID);
  85
  86                 if (0 == ret) {
  87                         MAS_LOGD("[OUT] mas initialize : result(%d)", ret);
  88                 } else {
  89                         MAS_LOGE("[OUT ERROR] mas initialize : result(%d)", ret);
  90                 }
  91
  92                 if (!dbus_connection_send(conn, reply, NULL)) {
  93                         MAS_LOGE("[OUT ERROR] mas initialize : Out Of Memory!");
  94                 }
  95
  96                 dbus_connection_flush(conn);
  97                 dbus_message_unref(reply);
  98         } else {
  99                 MAS_LOGE("[OUT ERROR] mas initialize : Fail to create reply message!!");
 100         }
 101
 102         return ret;
 103 }
 104
 105 int CServiceIpcDbusDispatcher::on_deinitialize(DBusConnection* conn, DBusMessage* msg)
 106 {
 107         if (nullptr == mIpcObserver) {
 108                 MAS_LOGE("mIpcObserver variable is NULL");
 109                 return -1;
 110         }
 111
 112         DBusError err;
 113         dbus_error_init(&err);
 114
 115         int pid = -1;
 116         int ret = 0;
 117
 118         if (FALSE == dbus_message_get_args(msg, &err,
 119                 DBUS_TYPE_INT32, &pid,
 120                 DBUS_TYPE_INVALID)) {
 121                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 122         }
 123
 124         MAS_LOGD("[DEBUG] MAS DEINITIALIZE");
 125
 126         if (dbus_error_is_set(&err)) {
 127                 MAS_LOGE("[IN ERROR] mas deinitialize : get arguments error (%s)", err.message);
 128                 dbus_error_free(&err);
 129                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 130         } else {
 131                 MAS_LOGD("[IN] mas deinitialize : pid(%d)", pid);
 132                 ret = mIpcObserver->on_deinitialize(pid);
 133         }
 134
 135         DBusMessage* reply;
 136         reply = dbus_message_new_method_return(msg);
 137
 138         MAS_LOGI("[OUT] mas deinitialize : result(%d)", ret);
 139         if (NULL != reply) {
 140                 dbus_message_append_args(reply,
 141                         DBUS_TYPE_INT32, &ret,
 142                         DBUS_TYPE_INVALID);
 143
 144                 if (0 == ret) {
 145                         MAS_LOGD("[OUT] mas deinitialize : result(%d)", ret);
 146                 } else {
 147                         MAS_LOGE("[OUT ERROR] mas deinitialize : result(%d)", ret);
 148                 }
 149
 150                 if (!dbus_connection_send(conn, reply, NULL)) {
 151                         MAS_LOGE("[OUT ERROR] mas deinitialize : Out Of Memory!");
 152                 }
 153
 154                 dbus_connection_flush(conn);
 155                 dbus_message_unref(reply);
 156         } else {
 157                 MAS_LOGE("[OUT ERROR] mas deinitialize : Fail to create reply message!!");
 158         }
 159
 160         return 0;
 161 }
 162
 163 int CServiceIpcDbusDispatcher::on_get_audio_format(DBusConnection* conn, DBusMessage* msg)
 164 {
 165         if (nullptr == mIpcObserver) {
 166                 MAS_LOGE("mIpcObserver variable is NULL");
 167                 return -1;
 168         }
 169
 170         DBusError err;
 171         dbus_error_init(&err);
 172
 173         int pid = -1;
 174         int rate, channel, audio_type;
 175         int ret;
 176
 177         if (FALSE == dbus_message_get_args(msg, &err,
 178                 DBUS_TYPE_INT32, &pid,
 179                 DBUS_TYPE_INVALID)) {
 180                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 181         }
 182
 183         MAS_LOGD("[DEBUG] MAS GET AUDIO FORMAT");
 184
 185         if (dbus_error_is_set(&err)) {
 186                 MAS_LOGE("[IN ERROR] mas get audio format : Get arguments error (%s)", err.message);
 187                 dbus_error_free(&err);
 188                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 189         } else {
 190                 MAS_LOGD("[IN] mas get audio format");
 191                 ret = mIpcObserver->on_get_audio_format(pid, rate, channel, audio_type);
 192         }
 193
 194         DBusMessage* reply;
 195         reply = dbus_message_new_method_return(msg);
 196
 197         if (NULL != reply) {
 198                 /* Append result and voice */
 199                 dbus_message_append_args(reply,
 200                         DBUS_TYPE_INT32, &ret,
 201                         DBUS_TYPE_INT32, &rate,
 202                         DBUS_TYPE_INT32, &channel,
 203                         DBUS_TYPE_INT32, &audio_type,
 204                         DBUS_TYPE_INVALID);
 205                 if (0 == ret) {
 206                         MAS_LOGI("[OUT] mas get audio format : rate(%d), channel(%d), audio_type(%d)", rate, channel, audio_type);
 207                 } else {
 208                         MAS_LOGE("[OUT ERROR] mas get audio format : result(%d)", ret);
 209                 }
 210
 211                 if (!dbus_connection_send(conn, reply, NULL)) {
 212                         MAS_LOGE("[OUT ERROR] mas get audio format : Out Of Memory!");
 213                 }
 214
 215                 dbus_connection_flush(conn);
 216                 dbus_message_unref(reply);
 217         } else {
 218                 MAS_LOGE("[OUT ERROR] tts default voice : Fail to create reply message!!");
 219         }
 220
 221         return ret;
 222 }
 223
 224 int CServiceIpcDbusDispatcher::on_get_audio_source_type(DBusConnection* conn, DBusMessage* msg)
 225 {
 226         if (nullptr == mIpcObserver) {
 227                 MAS_LOGE("mIpcObserver variable is NULL");
 228                 return -1;
 229         }
 230
 231         DBusError err;
 232         dbus_error_init(&err);
 233
 234         int pid = -1;
 235         std::string type;
 236         int ret;
 237
 238         if (FALSE == dbus_message_get_args(msg, &err,
 239                 DBUS_TYPE_INT32, &pid,
 240                 DBUS_TYPE_INVALID)) {
 241                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 242         }
 243
 244         MAS_LOGD("[DEBUG] MAS GET AUDIO SOURCE TYPE");
 245
 246         if (dbus_error_is_set(&err)) {
 247                 MAS_LOGE("[IN ERROR] mas get audio source type : Get arguments error (%s)", err.message);
 248                 dbus_error_free(&err);
 249                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 250         } else {
 251                 MAS_LOGD("[IN] mas get audio source type");
 252                 ret = mIpcObserver->on_get_audio_source_type(pid, type);
 253         }
 254
 255         DBusMessage* reply;
 256         reply = dbus_message_new_method_return(msg);
 257
 258         char* temp_type = NULL;
 259
 260         if (-1 == ret)
 261                 temp_type = strdup("#NULL");
 262         else
 263                 temp_type = strdup(type.c_str());
 264
 265         if (NULL != reply) {
 266                 /* Append result and voice */
 267                 dbus_message_append_args(reply,
 268                         DBUS_TYPE_INT32, &ret,
 269                         DBUS_TYPE_STRING, &temp_type,
 270                         DBUS_TYPE_INVALID);
 271                 if (0 == ret) {
 272                         MAS_LOGI("[OUT] mas get audio source type : type(%s)", temp_type);
 273                 } else {
 274                         MAS_LOGE("[OUT ERROR] mas get audio source type : result(%d)", ret);
 275                 }
 276
 277                 if (!dbus_connection_send(conn, reply, NULL)) {
 278                         MAS_LOGE("[OUT ERROR] mas get audio source type : Out Of Memory!");
 279                 }
 280
 281                 dbus_connection_flush(conn);
 282                 dbus_message_unref(reply);
 283         } else {
 284                 MAS_LOGE("[OUT ERROR] mas get audio source type : Fail to create reply message!!");
 285         }
 286
 287         if (temp_type)
 288                 free(temp_type);
 289
 290         return ret;
 291 }
 292
 293 int CServiceIpcDbusDispatcher::on_send_asr_result(DBusConnection* conn, DBusMessage* msg)
 294 {
 295         if (nullptr == mIpcObserver) {
 296                 MAS_LOGE("mIpcObserver variable is NULL");
 297                 return -1;
 298         }
 299
 300         DBusError err;
 301         dbus_error_init(&err);
 302
 303         int pid, event;
 304         char *asr_result;
 305         int ret = 0;
 306
 307         if (FALSE == dbus_message_get_args(msg, &err,
 308                 DBUS_TYPE_INT32, &pid,
 309                 DBUS_TYPE_INT32, &event,
 310                 DBUS_TYPE_STRING, &asr_result,
 311                 DBUS_TYPE_INVALID)) {
 312                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 313         }
 314
 315         MAS_LOGD("[DEBUG] MAS SEND ASR RESULT");
 316
 317         if (dbus_error_is_set(&err)) {
 318                 MAS_LOGE("[IN ERROR] mas send asr result : Get arguments error (%s)", err.message);
 319                 dbus_error_free(&err);
 320                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 321         } else {
 322                 MAS_LOGI("[IN] mas send asr result : pid(%d), event(%d), asr_result(%s)", pid, event, asr_result);
 323                 ret = mIpcObserver->on_send_asr_result(pid, event,
 324                         asr_result ? std::string{asr_result} : std::string{});
 325         }
 326
 327         DBusMessage* reply;
 328         reply = dbus_message_new_method_return(msg);
 329
 330         if (NULL != reply) {
 331                 dbus_message_append_args(reply,
 332                         DBUS_TYPE_INT32, &ret,
 333                         DBUS_TYPE_INVALID);
 334
 335                 if (0 == ret) {
 336                         MAS_LOGD("[OUT] mas send asr result : result(%d)", ret);
 337                 } else {
 338                         MAS_LOGE("[OUT ERROR] mas send asr result : result(%d)", ret);
 339                 }
 340
 341                 if (!dbus_connection_send(conn, reply, NULL)) {
 342                         MAS_LOGE("[OUT ERROR] mas send asr result : Out Of Memory!");
 343                 }
 344
 345                 dbus_connection_flush(conn);
 346                 dbus_message_unref(reply);
 347         } else {
 348                 MAS_LOGE("[OUT ERROR] mas send asr result : Fail to create reply message!!");
 349         }
 350
 351         MAS_LOGD("<<<<<");
 352         MAS_LOGD("  ");
 353
 354         return ret;
 355 }
 356
 357 int CServiceIpcDbusDispatcher::on_send_result(DBusConnection* conn, DBusMessage* msg)
 358 {
 359         if (nullptr == mIpcObserver) {
 360                 MAS_LOGE("mIpcObserver variable is NULL");
 361                 return -1;
 362         }
 363
 364         DBusError err;
 365         dbus_error_init(&err);
 366
 367         int pid;
 368         char* display_text;
 369         char* utterance_text;
 370         char* result_json;
 371         int ret = 0;
 372
 373         if (FALSE == dbus_message_get_args(msg, &err,
 374                 DBUS_TYPE_INT32, &pid,
 375                 DBUS_TYPE_STRING, &display_text,
 376                 DBUS_TYPE_STRING, &utterance_text,
 377                 DBUS_TYPE_STRING, &result_json,
 378                 DBUS_TYPE_INVALID)) {
 379                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 380         }
 381
 382         MAS_LOGD("[DEBUG] MAS SEND RESULT");
 383
 384         if (dbus_error_is_set(&err)) {
 385                 MAS_LOGE("[IN ERROR] mas send result : Get arguments error (%s)", err.message);
 386                 dbus_error_free(&err);
 387                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 388         } else {
 389                 MAS_LOGI("[IN] mas send result : pid(%d), display_text(%s), utterance_text(%s), result_json(%s)", pid, display_text, utterance_text, result_json);
 390                 ret = mIpcObserver->on_send_result(pid,
 391                         display_text ? std::string{display_text} : std::string{},
 392                         utterance_text ? std::string{utterance_text} : std::string{},
 393                         result_json ? std::string{result_json} : std::string{});
 394         }
 395
 396         DBusMessage* reply;
 397         reply = dbus_message_new_method_return(msg);
 398
 399         if (NULL != reply) {
 400                 dbus_message_append_args(reply,
 401                         DBUS_TYPE_INT32, &ret,
 402                         DBUS_TYPE_INVALID);
 403
 404                 if (0 == ret) {
 405                         MAS_LOGD("[OUT] mas send result : result(%d)", ret);
 406                 } else {
 407                         MAS_LOGE("[OUT ERROR] mas send result : result(%d)", ret);
 408                 }
 409
 410                 if (!dbus_connection_send(conn, reply, NULL)) {
 411                         MAS_LOGE("[OUT ERROR] mas send result : Out Of Memory!");
 412                 }
 413
 414                 dbus_connection_flush(conn);
 415                 dbus_message_unref(reply);
 416         } else {
 417                 MAS_LOGE("[OUT ERROR] mas send result : Fail to create reply message!!");
 418         }
 419
 420         MAS_LOGD("<<<<<");
 421         MAS_LOGD("  ");
 422
 423         return ret;
 424 }
 425
 426 int CServiceIpcDbusDispatcher::on_send_recognition_result(DBusConnection* conn, DBusMessage* msg)
 427 {
 428         if (nullptr == mIpcObserver) {
 429                 MAS_LOGE("mIpcObserver variable is NULL");
 430                 return -1;
 431         }
 432
 433         DBusError err;
 434         dbus_error_init(&err);
 435
 436         int pid;
 437         int result;
 438         int ret = 0;
 439
 440         if (FALSE == dbus_message_get_args(msg, &err,
 441                 DBUS_TYPE_INT32, &pid,
 442                 DBUS_TYPE_INT32, &result,
 443                 DBUS_TYPE_INVALID)) {
 444                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 445         }
 446
 447         MAS_LOGD("[DEBUG] MAS SEND RECOGNITION RESULT");
 448
 449         if (dbus_error_is_set(&err)) {
 450                 MAS_LOGE("[IN ERROR] mas send recognition result : Get arguments error (%s)", err.message);
 451                 dbus_error_free(&err);
 452                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 453         } else {
 454                 MAS_LOGI("[IN] mas send recognition result : pid(%d), result(%d)", pid, result);
 455                 ret = mIpcObserver->on_send_recognition_result(pid, result);
 456         }
 457
 458         MAS_LOGD("<<<<<");
 459         MAS_LOGD("  ");
 460
 461         return ret;
 462 }
 463
 464 int CServiceIpcDbusDispatcher::on_start_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
 465 {
 466         if (nullptr == mIpcObserver) {
 467                 MAS_LOGE("mIpcObserver variable is NULL");
 468                 return -1;
 469         }
 470
 471         DBusError err;
 472         dbus_error_init(&err);
 473
 474         int pid;
 475         int type;
 476         int ret = 0;
 477
 478         if (FALSE == dbus_message_get_args(msg, &err,
 479                 DBUS_TYPE_INT32, &pid,
 480                 DBUS_TYPE_INT32, &type,
 481                 DBUS_TYPE_INVALID)) {
 482                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 483         }
 484
 485         MAS_LOGD("[DEBUG] MAS SEND START STREAMING");
 486
 487         if (dbus_error_is_set(&err)) {
 488                 MAS_LOGE("[IN ERROR] mas send start streaming : Get arguments error (%s)", err.message);
 489                 dbus_error_free(&err);
 490                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 491         } else {
 492                 MAS_LOGI("[IN] mas send start streaming : pid(%d), type(%d)", pid, type);
 493                 ret = mIpcObserver->on_start_streaming_audio_data(pid, type);
 494         }
 495
 496         MAS_LOGD("<<<<<");
 497         MAS_LOGD("  ");
 498
 499         return ret;
 500 }
 501
 502 int CServiceIpcDbusDispatcher::on_stop_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
 503 {
 504         if (nullptr == mIpcObserver) {
 505                 MAS_LOGE("mIpcObserver variable is NULL");
 506                 return -1;
 507         }
 508
 509         DBusError err;
 510         dbus_error_init(&err);
 511
 512         int pid;
 513         int type;
 514         int ret = 0;
 515
 516         if (FALSE == dbus_message_get_args(msg, &err,
 517                 DBUS_TYPE_INT32, &pid,
 518                 DBUS_TYPE_INT32, &type,
 519                 DBUS_TYPE_INVALID)) {
 520                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 521         }
 522
 523         MAS_LOGD("[DEBUG] MAS SEND STOP STREAMING");
 524
 525         if (dbus_error_is_set(&err)) {
 526                 MAS_LOGE("[IN ERROR] mas stop streaming : Get arguments error (%s)", err.message);
 527                 dbus_error_free(&err);
 528                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 529         } else {
 530                 MAS_LOGI("[IN] mas stop streaming : pid(%d), type(%d)", pid, type);
 531                 ret = mIpcObserver->on_stop_streaming_audio_data(pid, type);
 532         }
 533
 534         MAS_LOGD("<<<<<");
 535         MAS_LOGD("  ");
 536
 537         return ret;
 538 }
 539
 540 int CServiceIpcDbusDispatcher::on_update_voice_feedback_state(DBusConnection* conn, DBusMessage* msg)
 541 {
 542         if (nullptr == mIpcObserver) {
 543                 MAS_LOGE("mIpcObserver variable is NULL");
 544                 return -1;
 545         }
 546
 547         DBusError err;
 548         dbus_error_init(&err);
 549
 550         int pid;
 551         int state;
 552         int ret = 0;
 553
 554         if (FALSE == dbus_message_get_args(msg, &err,
 555                 DBUS_TYPE_INT32, &pid,
 556                 DBUS_TYPE_INT32, &state,
 557                 DBUS_TYPE_INVALID)) {
 558                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 559         }
 560
 561         MAS_LOGD("[DEBUG] MAS SEND UPDATE VOICE FEEDBACK");
 562
 563         if (dbus_error_is_set(&err)) {
 564                 MAS_LOGE("[IN ERROR] mas update voice feedback : Get arguments error (%s)", err.message);
 565                 dbus_error_free(&err);
 566                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 567         } else {
 568                 MAS_LOGI("[IN] mas update voice feedback : pid(%d), state(%d)", pid, state);
 569                 ret = mIpcObserver->on_update_voice_feedback_state(pid, state);
 570         }
 571
 572         MAS_LOGD("<<<<<");
 573         MAS_LOGD("  ");
 574
 575         return ret;
 576 }
 577
 578 int CServiceIpcDbusDispatcher::on_send_assistant_specific_command(DBusConnection* conn, DBusMessage* msg)
 579 {
 580         if (nullptr == mIpcObserver) {
 581                 MAS_LOGE("mIpcObserver variable is NULL");
 582                 return -1;
 583         }
 584
 585         DBusError err;
 586         dbus_error_init(&err);
 587
 588         int pid;
 589         int ret = 0;
 590         char* command;
 591
 592         if (FALSE == dbus_message_get_args(msg, &err,
 593                 DBUS_TYPE_INT32, &pid,
 594                 DBUS_TYPE_STRING, &command,
 595                 DBUS_TYPE_INVALID)) {
 596                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 597         }
 598
 599         MAS_LOGD("[DEBUG] MAS SEND ASSISTANT SPECIFIC COMMAND");
 600
 601         if (dbus_error_is_set(&err)) {
 602                 MAS_LOGE("[IN ERROR] mas send assistant specific command : Get arguments error (%s)", err.message);
 603                 dbus_error_free(&err);
 604                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 605         } else {
 606                 MAS_LOGI("[IN] mas send assistant specific command : pid(%d), command(%s)", pid, command);
 607                 ret = mIpcObserver->on_send_assistant_specific_command(pid,
 608                         command ? std::string{command} : std::string{});
 609         }
 610
 611         MAS_LOGD("<<<<<");
 612         MAS_LOGD("  ");
 613
 614         return ret;
 615 }
 616
 617 int CServiceIpcDbusDispatcher::on_set_background_volume(DBusConnection* conn, DBusMessage* msg)
 618 {
 619         if (nullptr == mIpcObserver) {
 620                 MAS_LOGE("mIpcObserver variable is NULL");
 621                 return -1;
 622         }
 623
 624         DBusError err;
 625         dbus_error_init(&err);
 626
 627         int pid;
 628         int ret = 0;
 629         double ratio;
 630
 631         if (FALSE == dbus_message_get_args(msg, &err,
 632                 DBUS_TYPE_INT32, &pid,
 633                 DBUS_TYPE_DOUBLE, &ratio,
 634                 DBUS_TYPE_INVALID)) {
 635                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 636         }
 637
 638         MAS_LOGD("[DEBUG] MAS SET BACKGROUND VOLUME");
 639
 640         if (dbus_error_is_set(&err)) {
 641                 MAS_LOGE("[IN ERROR] mas set background volume : Get arguments error (%s)", err.message);
 642                 dbus_error_free(&err);
 643                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 644         } else {
 645                 MAS_LOGI("[IN] mas set background volume : pid(%d), ratio(%f)", pid, ratio);
 646                 ret = mIpcObserver->on_set_background_volume(pid, ratio);
 647         }
 648
 649         MAS_LOGD("<<<<<");
 650         MAS_LOGD("  ");
 651
 652         return ret;
 653 }
 654
 655 int CServiceIpcDbusDispatcher::on_set_preprocessing_allow_mode(DBusConnection* conn, DBusMessage* msg)
 656 {
 657         if (nullptr == mIpcObserver) {
 658                 MAS_LOGE("mIpcObserver variable is NULL");
 659                 return -1;
 660         }
 661
 662         DBusError err;
 663         dbus_error_init(&err);
 664
 665         int pid;
 666         int ret = 0;
 667         int mode;
 668         char* app_id;
 669
 670         if (FALSE == dbus_message_get_args(msg, &err,
 671                 DBUS_TYPE_INT32, &pid,
 672                 DBUS_TYPE_INT32, &mode,
 673                 DBUS_TYPE_STRING, &app_id,
 674                 DBUS_TYPE_INVALID)) {
 675                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 676         }
 677
 678         MAS_LOGD("[DEBUG] MAS SET PREPROCESSING ALLOW MODE");
 679
 680         if (dbus_error_is_set(&err)) {
 681                 MAS_LOGE("[IN ERROR] mas set preprocessing allow mode : Get arguments error (%s)", err.message);
 682                 dbus_error_free(&err);
 683                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 684         } else {
 685                 MAS_LOGI("[IN] mas set preprocessing allow mode : pid(%d), mode(%d), app_id(%s)", pid, mode, app_id);
 686                 ret = mIpcObserver->on_set_preprocessing_allow_mode(pid,
 687                         static_cast<ma_preprocessing_allow_mode_e>(mode),
 688                         app_id ? std::string{app_id} : std::string{});
 689         }
 690
 691         MAS_LOGD("<<<<<");
 692         MAS_LOGD("  ");
 693
 694         return ret;
 695 }
 696
 697 int CServiceIpcDbusDispatcher::on_send_preprocessing_result(DBusConnection* conn, DBusMessage* msg)
 698 {
 699         if (nullptr == mIpcObserver) {
 700                 MAS_LOGE("mIpcObserver variable is NULL");
 701                 return -1;
 702         }
 703
 704         DBusError err;
 705         dbus_error_init(&err);
 706
 707         int pid;
 708         int ret = 0;
 709         int result;
 710
 711         if (FALSE == dbus_message_get_args(msg, &err,
 712                 DBUS_TYPE_INT32, &pid,
 713                 DBUS_TYPE_INT32, &result,
 714                 DBUS_TYPE_INVALID)) {
 715                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 716         }
 717
 718         MAS_LOGD("[DEBUG] MAS SEND PREPROCESSING RESULT");
 719
 720         if (dbus_error_is_set(&err)) {
 721                 MAS_LOGE("[IN ERROR] mas send preprocessing result : Get arguments error (%s)", err.message);
 722                 dbus_error_free(&err);
 723                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 724         } else {
 725                 MAS_LOGI("[IN] mas send preprocessing result : pid(%d), result(%d)", pid, result);
 726                 ret = mIpcObserver->on_send_preprocessing_result(pid, result);
 727         }
 728
 729         MAS_LOGD("<<<<<");
 730         MAS_LOGD("  ");
 731
 732         return ret;
 733 }
 734
 735 int CServiceIpcDbusDispatcher::on_set_wake_word_audio_require_flag(DBusConnection* conn, DBusMessage* msg)
 736 {
 737         if (nullptr == mIpcObserver) {
 738                 MAS_LOGE("mIpcObserver variable is NULL");
 739                 return -1;
 740         }
 741
 742         DBusError err;
 743         dbus_error_init(&err);
 744
 745         int pid;
 746         int ret = 0;
 747         int require;
 748
 749         if (FALSE == dbus_message_get_args(msg, &err,
 750                 DBUS_TYPE_INT32, &pid,
 751                 DBUS_TYPE_INT32, &require,
 752                 DBUS_TYPE_INVALID)) {
 753                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 754         }
 755
 756         MAS_LOGD("[DEBUG] MAS SET WAKE WORD AUDIO REQUIRE FLAG");
 757
 758         if (dbus_error_is_set(&err)) {
 759                 MAS_LOGE("[IN ERROR] mas set wake word audio require flag : Get arguments error (%s)", err.message);
 760                 dbus_error_free(&err);
 761                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 762         } else {
 763                 MAS_LOGI("[IN] mas set wake word audio require flag : pid(%d), require(%d)", pid, require);
 764                 ret = mIpcObserver->on_set_wake_word_audio_require_flag(pid, require);
 765         }
 766
 767         MAS_LOGD("<<<<<");
 768         MAS_LOGD("  ");
 769
 770         return ret;
 771 }
 772
 773 int CServiceIpcDbusDispatcher::on_set_assistant_language(DBusConnection* conn, DBusMessage* msg)
 774 {
 775         if (nullptr == mIpcObserver) {
 776                 MAS_LOGE("mIpcObserver variable is NULL");
 777                 return -1;
 778         }
 779
 780         DBusError err;
 781         dbus_error_init(&err);
 782
 783         int pid;
 784         int ret = 0;
 785         char* language;
 786
 787         if (FALSE == dbus_message_get_args(msg, &err,
 788                 DBUS_TYPE_INT32, &pid,
 789                 DBUS_TYPE_STRING, &language,
 790                 DBUS_TYPE_INVALID)) {
 791                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 792         }
 793
 794         MAS_LOGD("[DEBUG] MAS SET ASSISTANT LANGUAGE");
 795
 796         if (dbus_error_is_set(&err)) {
 797                 MAS_LOGE("[IN ERROR] mas set assistant language : Get arguments error (%s)", err.message);
 798                 dbus_error_free(&err);
 799                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 800         } else {
 801                 MAS_LOGI("[IN] mas set assistant language : pid(%d), language(%s)", pid, language);
 802                 ret = mIpcObserver->on_set_assistant_language(pid,
 803                         language ? std::string{language} : std::string{});
 804         }
 805
 806         MAS_LOGD("<<<<<");
 807         MAS_LOGD("  ");
 808
 809         return ret;
 810 }
 811
 812 int CServiceIpcDbusDispatcher::on_add_wake_word(DBusConnection* conn, DBusMessage* msg)
 813 {
 814         if (nullptr == mIpcObserver) {
 815                 MAS_LOGE("mIpcObserver variable is NULL");
 816                 return -1;
 817         }
 818
 819         DBusError err;
 820         dbus_error_init(&err);
 821
 822         int pid;
 823         int ret = 0;
 824         char* wake_word;
 825         char* language;
 826
 827         if (FALSE == dbus_message_get_args(msg, &err,
 828                 DBUS_TYPE_INT32, &pid,
 829                 DBUS_TYPE_STRING, &wake_word,
 830                 DBUS_TYPE_STRING, &language,
 831                 DBUS_TYPE_INVALID)) {
 832                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 833         }
 834
 835         MAS_LOGD("[DEBUG] MAS ADD WAKE WORD");
 836
 837         if (dbus_error_is_set(&err)) {
 838                 MAS_LOGE("[IN ERROR] mas add wake word : Get arguments error (%s)", err.message);
 839                 dbus_error_free(&err);
 840                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 841         } else {
 842                 MAS_LOGI("[IN] mas add wake word : pid(%d), wake_word(%s) language(%s)", pid, wake_word, language);
 843                 ret = mIpcObserver->on_add_wake_word(pid,
 844                         wake_word ? std::string{wake_word} : std::string{},
 845                         language ? std::string{language} : std::string{});
 846         }
 847
 848         MAS_LOGD("<<<<<");
 849         MAS_LOGD("  ");
 850
 851         return ret;
 852 }
 853
 854 int CServiceIpcDbusDispatcher::on_remove_wake_word(DBusConnection* conn, DBusMessage* msg)
 855 {
 856         if (nullptr == mIpcObserver) {
 857                 MAS_LOGE("mIpcObserver variable is NULL");
 858                 return -1;
 859         }
 860
 861         DBusError err;
 862         dbus_error_init(&err);
 863
 864         int pid;
 865         int ret = 0;
 866         char* wake_word;
 867         char* language;
 868
 869         if (FALSE == dbus_message_get_args(msg, &err,
 870                 DBUS_TYPE_INT32, &pid,
 871                 DBUS_TYPE_STRING, &wake_word,
 872                 DBUS_TYPE_STRING, &language,
 873                 DBUS_TYPE_INVALID)) {
 874                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 875         }
 876
 877         MAS_LOGD("[DEBUG] MAS REMOVE WAKE WORD");
 878
 879         if (dbus_error_is_set(&err)) {
 880                 MAS_LOGE("[IN ERROR] mas remove wake word : Get arguments error (%s)", err.message);
 881                 dbus_error_free(&err);
 882                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 883         } else {
 884                 MAS_LOGI("[IN] mas remove wake word : pid(%d), wake_word(%s) language(%s)", pid, wake_word, language);
 885                 ret = mIpcObserver->on_remove_wake_word(pid,
 886                         wake_word ? std::string{wake_word} : std::string{},
 887                         language ? std::string{language} : std::string{});
 888         }
 889
 890         MAS_LOGD("<<<<<");
 891         MAS_LOGD("  ");
 892
 893         return ret;
 894 }
 895
 896 int CServiceIpcDbusDispatcher::on_ui_initialize(DBusConnection* conn, DBusMessage* msg)
 897 {
 898         if (nullptr == mIpcObserver) {
 899                 MAS_LOGE("mIpcObserver variable is NULL");
 900                 return -1;
 901         }
 902
 903         DBusError err;
 904         dbus_error_init(&err);
 905
 906         int pid = -1;
 907         int ret = 0;
 908
 909         if (FALSE == dbus_message_get_args(msg, &err,
 910                 DBUS_TYPE_INT32, &pid,
 911                 DBUS_TYPE_INVALID)) {
 912                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 913         }
 914
 915         MAS_LOGD("[DEBUG] MAS UI INITIALIZE");
 916
 917         if (dbus_error_is_set(&err)) {
 918                 MAS_LOGE("[IN ERROR] mas ui initialize : get arguments error (%s)", err.message);
 919                 dbus_error_free(&err);
 920                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 921         } else {
 922                 MAS_LOGD("[IN] mas ui initialize : pid(%d)", pid);
 923                 ret = mIpcObserver->on_ui_initialize(pid);
 924         }
 925
 926         DBusMessage* reply;
 927         reply = dbus_message_new_method_return(msg);
 928
 929         MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
 930         if (NULL != reply) {
 931                 dbus_message_append_args(reply,
 932                         DBUS_TYPE_INT32, &ret,
 933                         DBUS_TYPE_INVALID);
 934
 935                 if (0 == ret) {
 936                         MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
 937                 } else {
 938                         MAS_LOGE("[OUT ERROR] mas ui initialize : result(%d)", ret);
 939                 }
 940
 941                 if (!dbus_connection_send(conn, reply, NULL)) {
 942                         MAS_LOGE("[OUT ERROR] mas ui initialize : Out Of Memory!");
 943                 }
 944
 945                 dbus_connection_flush(conn);
 946                 dbus_message_unref(reply);
 947         } else {
 948                 MAS_LOGE("[OUT ERROR] mas ui initialize : Fail to create reply message!!");
 949         }
 950
 951         return ret;
 952 }
 953
 954 int CServiceIpcDbusDispatcher::on_ui_deinitialize(DBusConnection* conn, DBusMessage* msg)
 955 {
 956         if (nullptr == mIpcObserver) {
 957                 MAS_LOGE("mIpcObserver variable is NULL");
 958                 return -1;
 959         }
 960
 961         DBusError err;
 962         dbus_error_init(&err);
 963
 964         int pid = -1;
 965         int ret = 0;
 966
 967         if (FALSE == dbus_message_get_args(msg, &err,
 968                 DBUS_TYPE_INT32, &pid,
 969                 DBUS_TYPE_INVALID)) {
 970                 MAS_LOGE("[ERROR] Failed retrieving arguments");
 971         }
 972
 973         MAS_LOGD("[DEBUG] MAS UI DEINITIALIZE");
 974
 975         if (dbus_error_is_set(&err)) {
 976                 MAS_LOGE("[IN ERROR] mas ui deinitialize : get arguments error (%s)", err.message);
 977                 dbus_error_free(&err);
 978                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 979         } else {
 980                 MAS_LOGD("[IN] mas ui deinitialize : pid(%d)", pid);
 981                 ret = mIpcObserver->on_ui_deinitialize(pid);
 982         }
 983
 984         DBusMessage* reply;
 985         reply = dbus_message_new_method_return(msg);
 986
 987         MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
 988         if (NULL != reply) {
 989                 dbus_message_append_args(reply,
 990                         DBUS_TYPE_INT32, &ret,
 991                         DBUS_TYPE_INVALID);
 992
 993                 if (0 == ret) {
 994                         MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
 995                 } else {
 996                         MAS_LOGE("[OUT ERROR] mas ui deinitialize : result(%d)", ret);
 997                 }
 998
 999                 if (!dbus_connection_send(conn, reply, NULL)) {
1000                         MAS_LOGE("[OUT ERROR] mas ui deinitialize : Out Of Memory!");
1001                 }
1002
1003                 dbus_connection_flush(conn);
1004                 dbus_message_unref(reply);
1005         } else {
1006                 MAS_LOGE("[OUT ERROR] mas ui deinitialize : Fail to create reply message!!");
1007         }
1008
1009         return ret;
1010 }
1011
1012 int CServiceIpcDbusDispatcher::on_ui_change_assistant(DBusConnection* conn, DBusMessage* msg)
1013 {
1014         if (nullptr == mIpcObserver) {
1015                 MAS_LOGE("mIpcObserver variable is NULL");
1016                 return -1;
1017         }
1018
1019         DBusError err;
1020         dbus_error_init(&err);
1021
1022         char *app_id;
1023         int ret = 0;
1024
1025         if (FALSE == dbus_message_get_args(msg, &err,
1026                 DBUS_TYPE_STRING, &app_id,
1027                 DBUS_TYPE_INVALID)) {
1028                 MAS_LOGE("[ERROR] Failed retrieving arguments");
1029         }
1030
1031         MAS_LOGD("[DEBUG] MAS UI CHANGE ASSISTANT : %s", (app_id ? app_id : "NULL"));
1032
1033         if (dbus_error_is_set(&err)) {
1034                 MAS_LOGE("[IN ERROR] mas ui change assisant : Get arguments error (%s)", err.message);
1035                 dbus_error_free(&err);
1036                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
1037         } else {
1038                 MAS_LOGD("[IN] mas ui change assisant : app_id(%s)", app_id);
1039                 ret = mIpcObserver->on_ui_change_assistant(
1040                         app_id ? std::string{app_id} : std::string{});
1041         }
1042
1043         DBusMessage* reply;
1044         reply = dbus_message_new_method_return(msg);
1045
1046         if (NULL != reply) {
1047                 dbus_message_append_args(reply,
1048                         DBUS_TYPE_INT32, &ret,
1049                         DBUS_TYPE_INVALID);
1050
1051                 if (0 == ret) {
1052                         MAS_LOGD("[OUT] mas ui change assisant : result(%d)", ret);
1053                 } else {
1054                         MAS_LOGE("[OUT ERROR] mas ui change assisant : result(%d)", ret);
1055                 }
1056
1057                 if (!dbus_connection_send(conn, reply, NULL)) {
1058                         MAS_LOGE("[OUT ERROR] mas ui change assisant : Out Of Memory!");
1059                 }
1060
1061                 dbus_connection_flush(conn);
1062                 dbus_message_unref(reply);
1063         } else {
1064                 MAS_LOGE("[OUT ERROR] mas ui change assisant : Fail to create reply message!!");
1065         }
1066
1067         MAS_LOGD("<<<<<");
1068         MAS_LOGD("  ");
1069
1070         return ret;
1071 }