src/multi_assistant_dbus_server.c

   1 /*
   2  * Copyright 2018-2019 Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "multi_assistant_main.h"
  18 #include "multi_assistant_dbus.h"
  19 #include "multi_assistant_dbus_server.h"
  20 #include "multi_assistant_service_client.h"
  21
  22 /*
  23 * Dbus Client-Daemon Server
  24 */
  25 int ma_service_dbus_hello(DBusConnection* conn, DBusMessage* msg)
  26 {
  27         MAS_LOGD("[DEBUG] MAS HELLO");
  28
  29         DBusMessage* reply;
  30         reply = dbus_message_new_method_return(msg);
  31
  32         if (NULL != reply) {
  33                 if (!dbus_connection_send(conn, reply, NULL)) {
  34                         MAS_LOGE("[OUT ERROR] Out Of Memory!");
  35                 }
  36
  37                 dbus_connection_flush(conn);
  38                 dbus_message_unref(reply);
  39         } else {
  40                 MAS_LOGE("[OUT ERROR] Fail to create reply message!!");
  41         }
  42
  43         return 0;
  44 }
  45
  46 int ma_service_dbus_initialize(DBusConnection* conn, DBusMessage* msg)
  47 {
  48         DBusError err;
  49         dbus_error_init(&err);
  50
  51         int pid = -1;
  52         int ret = 0;
  53
  54         dbus_message_get_args(msg, &err,
  55                 DBUS_TYPE_INT32, &pid,
  56                 DBUS_TYPE_INVALID);
  57
  58         MAS_LOGD("[DEBUG] MAS INITIALIZE");
  59
  60         if (dbus_error_is_set(&err)) {
  61                 MAS_LOGE("[IN ERROR] mas initialize : get arguments error (%s)", err.message);
  62                 dbus_error_free(&err);
  63                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
  64         } else {
  65                 MAS_LOGD("[IN] mas initialize : pid(%d)", pid);
  66                 ret =  mas_client_initialize(pid);
  67         }
  68
  69         DBusMessage* reply;
  70         reply = dbus_message_new_method_return(msg);
  71
  72         MAS_LOGD("[OUT] mas initialize : result(%d)", ret);
  73         if (NULL != reply) {
  74                 dbus_message_append_args(reply,
  75                         DBUS_TYPE_INT32, &ret,
  76                         DBUS_TYPE_INVALID);
  77
  78                 if (0 == ret) {
  79                         MAS_LOGD("[OUT] mas initialize : result(%d)", ret);
  80                 } else {
  81                         MAS_LOGE("[OUT ERROR] mas initialize : result(%d)", ret);
  82                 }
  83
  84                 if (!dbus_connection_send(conn, reply, NULL)) {
  85                         MAS_LOGE("[OUT ERROR] mas initialize : Out Of Memory!");
  86                 }
  87
  88                 dbus_connection_flush(conn);
  89                 dbus_message_unref(reply);
  90         } else {
  91                 MAS_LOGE("[OUT ERROR] mas initialize : Fail to create reply message!!");
  92         }
  93
  94         return 0;
  95 }
  96
  97 int ma_service_dbus_deinitialize(DBusConnection* conn, DBusMessage* msg)
  98 {
  99         DBusError err;
 100         dbus_error_init(&err);
 101
 102         int pid = -1;
 103         int ret = 0;
 104
 105         dbus_message_get_args(msg, &err,
 106                 DBUS_TYPE_INT32, &pid,
 107                 DBUS_TYPE_INVALID);
 108
 109         MAS_LOGD("[DEBUG] MAS DEINITIALIZE");
 110
 111         if (dbus_error_is_set(&err)) {
 112                 MAS_LOGE("[IN ERROR] mas deinitialize : get arguments error (%s)", err.message);
 113                 dbus_error_free(&err);
 114                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 115         } else {
 116                 MAS_LOGD("[IN] mas deinitialize : pid(%d)", pid);
 117                 ret =  mas_client_deinitialize(pid);
 118         }
 119
 120         DBusMessage* reply;
 121         reply = dbus_message_new_method_return(msg);
 122
 123         MAS_LOGD("[OUT] mas deinitialize : result(%d)", ret);
 124         if (NULL != reply) {
 125                 dbus_message_append_args(reply,
 126                         DBUS_TYPE_INT32, &ret,
 127                         DBUS_TYPE_INVALID);
 128
 129                 if (0 == ret) {
 130                         MAS_LOGD("[OUT] mas deinitialize : result(%d)", ret);
 131                 } else {
 132                         MAS_LOGE("[OUT ERROR] mas deinitialize : result(%d)", ret);
 133                 }
 134
 135                 if (!dbus_connection_send(conn, reply, NULL)) {
 136                         MAS_LOGE("[OUT ERROR] mas deinitialize : Out Of Memory!");
 137                 }
 138
 139                 dbus_connection_flush(conn);
 140                 dbus_message_unref(reply);
 141         } else {
 142                 MAS_LOGE("[OUT ERROR] mas deinitialize : Fail to create reply message!!");
 143         }
 144
 145         return 0;
 146 }
 147
 148 int ma_service_dbus_get_audio_format(DBusConnection* conn, DBusMessage* msg)
 149 {
 150         DBusError err;
 151         dbus_error_init(&err);
 152
 153         int pid = -1;
 154         int rate, channel, audio_type;
 155         int ret;
 156
 157         dbus_message_get_args(msg, &err,
 158                 DBUS_TYPE_INT32, &pid,
 159                 DBUS_TYPE_INVALID);
 160
 161         MAS_LOGD("[DEBUG] MAS GET AUDIO FORMAT");
 162
 163         if (dbus_error_is_set(&err)) {
 164                 MAS_LOGE("[IN ERROR] mas get audio format : Get arguments error (%s)", err.message);
 165                 dbus_error_free(&err);
 166                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 167         } else {
 168                 MAS_LOGD("[IN] mas get default voice");
 169                 ret = mas_client_get_audio_format(pid, &rate, &channel, &audio_type);
 170         }
 171
 172         DBusMessage* reply;
 173         reply = dbus_message_new_method_return(msg);
 174
 175         if (NULL != reply) {
 176                 /* Append result and voice */
 177                 dbus_message_append_args(reply,
 178                         DBUS_TYPE_INT32, &ret,
 179                         DBUS_TYPE_INT32, &rate,
 180                         DBUS_TYPE_INT32, &channel,
 181                         DBUS_TYPE_INT32, &audio_type,
 182                         DBUS_TYPE_INVALID);
 183                 if (0 == ret) {
 184                         MAS_LOGD("[OUT] mas get audio format : rate(%d), channel(%d), audio_type(%d)", rate, channel, audio_type);
 185                 } else {
 186                         MAS_LOGE("[OUT ERROR] mas get audio format : result(%d)", ret);
 187                 }
 188
 189                 if (!dbus_connection_send(conn, reply, NULL)) {
 190                         MAS_LOGE("[OUT ERROR] mas get audio format : Out Of Memory!");
 191                 }
 192
 193                 dbus_connection_flush(conn);
 194                 dbus_message_unref(reply);
 195         } else {
 196                 MAS_LOGE("[OUT ERROR] tts default voice : Fail to create reply message!!");
 197         }
 198
 199         return 0;
 200 }
 201
 202 int ma_service_dbus_get_audio_source_type(DBusConnection* conn, DBusMessage* msg)
 203 {
 204         DBusError err;
 205         dbus_error_init(&err);
 206
 207         int pid = -1;
 208         char *type = NULL;
 209         int ret;
 210
 211         dbus_message_get_args(msg, &err,
 212                 DBUS_TYPE_INT32, &pid,
 213                 DBUS_TYPE_INVALID);
 214
 215         MAS_LOGD("[DEBUG] MAS GET AUDIO SOURCE TYPE");
 216
 217         if (dbus_error_is_set(&err)) {
 218                 MAS_LOGE("[IN ERROR] mas get audio source type : Get arguments error (%s)", err.message);
 219                 dbus_error_free(&err);
 220                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 221         } else {
 222                 MAS_LOGD("[IN] mas get default voice");
 223                 ret = mas_client_get_audio_source_type(pid, &type);
 224         }
 225
 226         DBusMessage* reply;
 227         reply = dbus_message_new_method_return(msg);
 228
 229         char* temp_type = NULL;
 230
 231         if (type)
 232                 temp_type = strdup(type);
 233         else
 234                 temp_type = strdup("#NULL");
 235
 236         if (NULL != reply) {
 237                 /* Append result and voice */
 238                 dbus_message_append_args(reply,
 239                         DBUS_TYPE_INT32, &ret,
 240                         DBUS_TYPE_STRING, &temp_type,
 241                         DBUS_TYPE_INVALID);
 242                 if (0 == ret) {
 243                         MAS_LOGD("[OUT] mas get audio source type : type(%s)", temp_type);
 244                 } else {
 245                         MAS_LOGE("[OUT ERROR] mas get audio source type : result(%d)", ret);
 246                 }
 247
 248                 if (!dbus_connection_send(conn, reply, NULL)) {
 249                         MAS_LOGE("[OUT ERROR] mas get audio source type : Out Of Memory!");
 250                 }
 251
 252                 dbus_connection_flush(conn);
 253                 dbus_message_unref(reply);
 254         } else {
 255                 MAS_LOGE("[OUT ERROR] mas get audio source type : Fail to create reply message!!");
 256         }
 257
 258         if (temp_type)
 259                 free(temp_type);
 260
 261         return 0;
 262 }
 263
 264 int ma_service_dbus_send_asr_result(DBusConnection* conn, DBusMessage* msg)
 265 {
 266         DBusError err;
 267         dbus_error_init(&err);
 268
 269         int pid, event;
 270         char *asr_result;
 271         int ret = 0;
 272
 273         dbus_message_get_args(msg, &err,
 274                 DBUS_TYPE_INT32, &pid,
 275                 DBUS_TYPE_INT32, &event,
 276                 DBUS_TYPE_STRING, &asr_result,
 277                 DBUS_TYPE_INVALID);
 278
 279         MAS_LOGD("[DEBUG] MAS SEND ASR RESULT");
 280
 281         if (dbus_error_is_set(&err)) {
 282                 MAS_LOGE("[IN ERROR] mas send asr result : Get arguments error (%s)", err.message);
 283                 dbus_error_free(&err);
 284                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 285         } else {
 286                 MAS_LOGD("[IN] mas send asr result : pid(%d), event(%d), asr_result(%s)", pid, event, asr_result);
 287                 ret = mas_client_send_asr_result(pid, event, asr_result);
 288         }
 289
 290         DBusMessage* reply;
 291         reply = dbus_message_new_method_return(msg);
 292
 293         if (NULL != reply) {
 294                 dbus_message_append_args(reply,
 295                         DBUS_TYPE_INT32, &ret,
 296                         DBUS_TYPE_INVALID);
 297
 298                 if (0 == ret) {
 299                         MAS_LOGD("[OUT] mas send asr result : result(%d)", ret);
 300                 } else {
 301                         MAS_LOGE("[OUT ERROR] mas send asr result : result(%d)", ret);
 302                 }
 303
 304                 if (!dbus_connection_send(conn, reply, NULL)) {
 305                         MAS_LOGE("[OUT ERROR] mas send asr result : Out Of Memory!");
 306                 }
 307
 308                 dbus_connection_flush(conn);
 309                 dbus_message_unref(reply);
 310         } else {
 311                 MAS_LOGE("[OUT ERROR] mas send asr result : Fail to create reply message!!");
 312         }
 313
 314         MAS_LOGD("<<<<<");
 315         MAS_LOGD("  ");
 316
 317         return 0;
 318 }
 319
 320 int ma_service_dbus_send_result(DBusConnection* conn, DBusMessage* msg)
 321 {
 322         DBusError err;
 323         dbus_error_init(&err);
 324
 325         int pid;
 326         char* display_text;
 327         char* utterance_text;
 328         char* result_json;
 329         int ret = 0;
 330
 331         dbus_message_get_args(msg, &err,
 332                 DBUS_TYPE_INT32, &pid,
 333                 DBUS_TYPE_STRING, &display_text,
 334                 DBUS_TYPE_STRING, &utterance_text,
 335                 DBUS_TYPE_STRING, &result_json,
 336                 DBUS_TYPE_INVALID);
 337
 338         MAS_LOGD("[DEBUG] MAS SEND RESULT");
 339
 340         if (dbus_error_is_set(&err)) {
 341                 MAS_LOGE("[IN ERROR] mas send result : Get arguments error (%s)", err.message);
 342                 dbus_error_free(&err);
 343                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 344         } else {
 345                 MAS_LOGD("[IN] mas send result : pid(%d), display_text(%s), utterance_text(%s), result_json(%s)", pid, display_text, utterance_text, result_json);
 346                 ret =  mas_client_send_result(pid, display_text, utterance_text, result_json);
 347         }
 348
 349         DBusMessage* reply;
 350         reply = dbus_message_new_method_return(msg);
 351
 352         if (NULL != reply) {
 353                 dbus_message_append_args(reply,
 354                         DBUS_TYPE_INT32, &ret,
 355                         DBUS_TYPE_INVALID);
 356
 357                 if (0 == ret) {
 358                         MAS_LOGD("[OUT] mas send result : result(%d)", ret);
 359                 } else {
 360                         MAS_LOGE("[OUT ERROR] mas send result : result(%d)", ret);
 361                 }
 362
 363                 if (!dbus_connection_send(conn, reply, NULL)) {
 364                         MAS_LOGE("[OUT ERROR] mas send result : Out Of Memory!");
 365                 }
 366
 367                 dbus_connection_flush(conn);
 368                 dbus_message_unref(reply);
 369         } else {
 370                 MAS_LOGE("[OUT ERROR] mas send result : Fail to create reply message!!");
 371         }
 372
 373         MAS_LOGD("<<<<<");
 374         MAS_LOGD("  ");
 375
 376         return 0;
 377 }
 378
 379 int ma_service_dbus_send_recognition_result(DBusConnection* conn, DBusMessage* msg)
 380 {
 381         DBusError err;
 382         dbus_error_init(&err);
 383
 384         int pid;
 385         int result;
 386         int ret = 0;
 387
 388         dbus_message_get_args(msg, &err,
 389                 DBUS_TYPE_INT32, &pid,
 390                 DBUS_TYPE_INT32, &result,
 391                 DBUS_TYPE_INVALID);
 392
 393         MAS_LOGD("[DEBUG] MAS SEND RECOGNITION RESULT");
 394
 395         if (dbus_error_is_set(&err)) {
 396                 MAS_LOGE("[IN ERROR] mas send error : Get arguments error (%s)", err.message);
 397                 dbus_error_free(&err);
 398                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 399         } else {
 400                 MAS_LOGD("[IN] mas send error : pid(%d), result(%d)", pid, result);
 401                 ret =  mas_client_send_recognition_result(pid, result);
 402         }
 403
 404         MAS_LOGD("<<<<<");
 405         MAS_LOGD("  ");
 406
 407         return 0;
 408 }
 409
 410 int ma_service_dbus_start_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
 411 {
 412         DBusError err;
 413         dbus_error_init(&err);
 414
 415         int pid;
 416         int type;
 417         int ret = 0;
 418
 419         dbus_message_get_args(msg, &err,
 420                 DBUS_TYPE_INT32, &pid,
 421                 DBUS_TYPE_INT32, &type,
 422                 DBUS_TYPE_INVALID);
 423
 424         MAS_LOGD("[DEBUG] MAS SEND START STREAMING");
 425
 426         if (dbus_error_is_set(&err)) {
 427                 MAS_LOGE("[IN ERROR] mas send start streaming : Get arguments error (%s)", err.message);
 428                 dbus_error_free(&err);
 429                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 430         } else {
 431                 MAS_LOGD("[IN] mas send start streaming : pid(%d), type(%d)", pid, type);
 432                 ret =  mas_client_start_streaming_audio_data(pid, type);
 433         }
 434
 435         MAS_LOGD("<<<<<");
 436         MAS_LOGD("  ");
 437
 438         return 0;
 439 }
 440
 441 int ma_service_dbus_stop_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
 442 {
 443         DBusError err;
 444         dbus_error_init(&err);
 445
 446         int pid;
 447         int type;
 448         int ret = 0;
 449
 450         dbus_message_get_args(msg, &err,
 451                 DBUS_TYPE_INT32, &pid,
 452                 DBUS_TYPE_INT32, &type,
 453                 DBUS_TYPE_INVALID);
 454
 455         MAS_LOGD("[DEBUG] MAS SEND STOP STREAMING");
 456
 457         if (dbus_error_is_set(&err)) {
 458                 MAS_LOGE("[IN ERROR] mas stop streaming : Get arguments error (%s)", err.message);
 459                 dbus_error_free(&err);
 460                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 461         } else {
 462                 MAS_LOGD("[IN] mas stop streaming : pid(%d), type(%d)", pid, type);
 463                 ret =  mas_client_stop_streaming_audio_data(pid, type);
 464         }
 465
 466         MAS_LOGD("<<<<<");
 467         MAS_LOGD("  ");
 468
 469         return 0;
 470 }
 471
 472 int ma_service_dbus_update_voice_feedback_state(DBusConnection* conn, DBusMessage* msg)
 473 {
 474         DBusError err;
 475         dbus_error_init(&err);
 476
 477         int pid;
 478         int state;
 479         int ret = 0;
 480
 481         dbus_message_get_args(msg, &err,
 482                 DBUS_TYPE_INT32, &pid,
 483                 DBUS_TYPE_INT32, &state,
 484                 DBUS_TYPE_INVALID);
 485
 486         MAS_LOGD("[DEBUG] MAS SEND UPDATE VOICE FEEDBACK");
 487
 488         if (dbus_error_is_set(&err)) {
 489                 MAS_LOGE("[IN ERROR] mas update voice feedback : Get arguments error (%s)", err.message);
 490                 dbus_error_free(&err);
 491                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 492         } else {
 493                 MAS_LOGD("[IN] mas update voice feedback : pid(%d), state(%d)", pid, state);
 494                 ret =  mas_client_update_voice_feedback_state(pid, state);
 495         }
 496
 497         MAS_LOGD("<<<<<");
 498         MAS_LOGD("  ");
 499
 500         return 0;
 501 }
 502
 503 int ma_service_dbus_send_assistant_specific_command(DBusConnection* conn, DBusMessage* msg)
 504 {
 505         DBusError err;
 506         dbus_error_init(&err);
 507
 508         int pid;
 509         int ret = 0;
 510         char* command;
 511
 512         dbus_message_get_args(msg, &err,
 513                 DBUS_TYPE_INT32, &pid,
 514                 DBUS_TYPE_STRING, &command,
 515                 DBUS_TYPE_INVALID);
 516
 517         MAS_LOGD("[DEBUG] MAS SEND ASSISTANT SPECIFIC COMMAND");
 518
 519         if (dbus_error_is_set(&err)) {
 520                 MAS_LOGE("[IN ERROR] mas send assistant specific command : Get arguments error (%s)", err.message);
 521                 dbus_error_free(&err);
 522                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 523         } else {
 524                 MAS_LOGD("[IN] mas send assistant specific command : pid(%d), command(%s)", pid, command);
 525                 ret =  mas_client_send_assistant_specific_command(pid, command);
 526         }
 527
 528         MAS_LOGD("<<<<<");
 529         MAS_LOGD("  ");
 530
 531         return 0;
 532 }
 533
 534 int ma_service_dbus_set_background_volume(DBusConnection* conn, DBusMessage* msg)
 535 {
 536         DBusError err;
 537         dbus_error_init(&err);
 538
 539         int pid;
 540         int ret = 0;
 541         double ratio;
 542
 543         dbus_message_get_args(msg, &err,
 544                 DBUS_TYPE_INT32, &pid,
 545                 DBUS_TYPE_DOUBLE, &ratio,
 546                 DBUS_TYPE_INVALID);
 547
 548         MAS_LOGD("[DEBUG] MAS SET BACKGROUND VOLUME");
 549
 550         if (dbus_error_is_set(&err)) {
 551                 MAS_LOGE("[IN ERROR] mas set background volume : Get arguments error (%s)", err.message);
 552                 dbus_error_free(&err);
 553                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 554         } else {
 555                 MAS_LOGD("[IN] mas set background volume : pid(%d), ratio(%f)", pid, ratio);
 556                 ret =  mas_client_set_background_volume(pid, ratio);
 557         }
 558
 559         MAS_LOGD("<<<<<");
 560         MAS_LOGD("  ");
 561
 562         return 0;
 563 }
 564
 565 int ma_service_dbus_set_preprocessing_allow_mode(DBusConnection* conn, DBusMessage* msg)
 566 {
 567         DBusError err;
 568         dbus_error_init(&err);
 569
 570         int pid;
 571         int ret = 0;
 572         int mode;
 573         char* app_id;
 574
 575         dbus_message_get_args(msg, &err,
 576                 DBUS_TYPE_INT32, &pid,
 577                 DBUS_TYPE_INT32, &mode,
 578                 DBUS_TYPE_STRING, &app_id,
 579                 DBUS_TYPE_INVALID);
 580
 581         MAS_LOGD("[DEBUG] MAS SET PREPROCESSING ALLOW MODE");
 582
 583         if (dbus_error_is_set(&err)) {
 584                 MAS_LOGE("[IN ERROR] mas set preprocessing allow mode : Get arguments error (%s)", err.message);
 585                 dbus_error_free(&err);
 586                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 587         } else {
 588                 char* temp_app_id = NULL;
 589                 if (NULL != app_id && strcmp("#NULL", app_id)) {
 590                         temp_app_id = strdup(app_id);
 591                 }
 592                 MAS_LOGD("[IN] mas set preprocessing allow mode : pid(%d), mode(%d), app_id(%s)", pid, mode, temp_app_id);
 593                 ret =  mas_client_set_preprocessing_allow_mode(pid, mode, temp_app_id);
 594                 if (NULL != temp_app_id)
 595                         free(temp_app_id);
 596         }
 597
 598         MAS_LOGD("<<<<<");
 599         MAS_LOGD("  ");
 600
 601         return 0;
 602 }
 603
 604 int ma_service_dbus_send_preprocessing_result(DBusConnection* conn, DBusMessage* msg)
 605 {
 606         DBusError err;
 607         dbus_error_init(&err);
 608
 609         int pid;
 610         int ret = 0;
 611         int result;
 612
 613         dbus_message_get_args(msg, &err,
 614                 DBUS_TYPE_INT32, &pid,
 615                 DBUS_TYPE_INT32, &result,
 616                 DBUS_TYPE_INVALID);
 617
 618         MAS_LOGD("[DEBUG] MAS SEND PREPROCESSING RESULT");
 619
 620         if (dbus_error_is_set(&err)) {
 621                 MAS_LOGE("[IN ERROR] mas send preprocessing result : Get arguments error (%s)", err.message);
 622                 dbus_error_free(&err);
 623                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 624         } else {
 625                 MAS_LOGD("[IN] mas send preprocessing result : pid(%d), result(%d)", pid, result);
 626                 ret =  mas_client_send_preprocessing_result(pid, (bool)result);
 627         }
 628
 629         MAS_LOGD("<<<<<");
 630         MAS_LOGD("  ");
 631
 632         return 0;
 633 }
 634
 635 int ma_service_dbus_set_wake_word_audio_require_flag(DBusConnection* conn, DBusMessage* msg)
 636 {
 637         DBusError err;
 638         dbus_error_init(&err);
 639
 640         int pid;
 641         int ret = 0;
 642         int require;
 643
 644         dbus_message_get_args(msg, &err,
 645                 DBUS_TYPE_INT32, &pid,
 646                 DBUS_TYPE_INT32, &require,
 647                 DBUS_TYPE_INVALID);
 648
 649         MAS_LOGD("[DEBUG] MAS SET WAKE WORD AUDIO REQUIRE FLAG");
 650
 651         if (dbus_error_is_set(&err)) {
 652                 MAS_LOGE("[IN ERROR] mas set wake word audio require flag : Get arguments error (%s)", err.message);
 653                 dbus_error_free(&err);
 654                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 655         } else {
 656                 MAS_LOGD("[IN] mas set wake word audio require flag : pid(%d), require(%d)", pid, require);
 657                 ret =  mas_client_set_wake_word_audio_require_flag(pid, (bool)require);
 658         }
 659
 660         MAS_LOGD("<<<<<");
 661         MAS_LOGD("  ");
 662
 663         return 0;
 664 }
 665
 666 int ma_service_dbus_set_assistant_language(DBusConnection* conn, DBusMessage* msg)
 667 {
 668         DBusError err;
 669         dbus_error_init(&err);
 670
 671         int pid;
 672         int ret = 0;
 673         char* language;
 674
 675         dbus_message_get_args(msg, &err,
 676                 DBUS_TYPE_INT32, &pid,
 677                 DBUS_TYPE_STRING, &language,
 678                 DBUS_TYPE_INVALID);
 679
 680         MAS_LOGD("[DEBUG] MAS SET ASSISTANT LANGUAGE");
 681
 682         if (dbus_error_is_set(&err)) {
 683                 MAS_LOGE("[IN ERROR] mas set assistant language : Get arguments error (%s)", err.message);
 684                 dbus_error_free(&err);
 685                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 686         } else {
 687                 MAS_LOGD("[IN] mas set assistant language : pid(%d), language(%s)", pid, language);
 688                 ret =  mas_client_set_assistant_language(pid, language);
 689         }
 690
 691         MAS_LOGD("<<<<<");
 692         MAS_LOGD("  ");
 693
 694         return 0;
 695 }
 696
 697 int ma_service_ui_dbus_initialize(DBusConnection* conn, DBusMessage* msg)
 698 {
 699         DBusError err;
 700         dbus_error_init(&err);
 701
 702         int pid = -1;
 703         int ret = 0;
 704
 705         dbus_message_get_args(msg, &err,
 706                 DBUS_TYPE_INT32, &pid,
 707                 DBUS_TYPE_INVALID);
 708
 709         MAS_LOGD("[DEBUG] MAS UI INITIALIZE");
 710
 711         if (dbus_error_is_set(&err)) {
 712                 MAS_LOGE("[IN ERROR] mas ui initialize : get arguments error (%s)", err.message);
 713                 dbus_error_free(&err);
 714                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 715         } else {
 716                 MAS_LOGD("[IN] mas ui initialize : pid(%d)", pid);
 717                 ret =  mas_ui_client_initialize(pid);
 718         }
 719
 720         DBusMessage* reply;
 721         reply = dbus_message_new_method_return(msg);
 722
 723         MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
 724         if (NULL != reply) {
 725                 dbus_message_append_args(reply,
 726                         DBUS_TYPE_INT32, &ret,
 727                         DBUS_TYPE_INVALID);
 728
 729                 if (0 == ret) {
 730                         MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
 731                 } else {
 732                         MAS_LOGE("[OUT ERROR] mas ui initialize : result(%d)", ret);
 733                 }
 734
 735                 if (!dbus_connection_send(conn, reply, NULL)) {
 736                         MAS_LOGE("[OUT ERROR] mas ui initialize : Out Of Memory!");
 737                 }
 738
 739                 dbus_connection_flush(conn);
 740                 dbus_message_unref(reply);
 741         } else {
 742                 MAS_LOGE("[OUT ERROR] mas ui initialize : Fail to create reply message!!");
 743         }
 744
 745         return 0;
 746 }
 747
 748 int ma_service_ui_dbus_deinitialize(DBusConnection* conn, DBusMessage* msg)
 749 {
 750         DBusError err;
 751         dbus_error_init(&err);
 752
 753         int pid = -1;
 754         int ret = 0;
 755
 756         dbus_message_get_args(msg, &err,
 757                 DBUS_TYPE_INT32, &pid,
 758                 DBUS_TYPE_INVALID);
 759
 760         MAS_LOGD("[DEBUG] MAS UI DEINITIALIZE");
 761
 762         if (dbus_error_is_set(&err)) {
 763                 MAS_LOGE("[IN ERROR] mas ui deinitialize : get arguments error (%s)", err.message);
 764                 dbus_error_free(&err);
 765                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 766         } else {
 767                 MAS_LOGD("[IN] mas ui deinitialize : pid(%d)", pid);
 768                 ret =  mas_ui_client_deinitialize(pid);
 769         }
 770
 771         DBusMessage* reply;
 772         reply = dbus_message_new_method_return(msg);
 773
 774         MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
 775         if (NULL != reply) {
 776                 dbus_message_append_args(reply,
 777                         DBUS_TYPE_INT32, &ret,
 778                         DBUS_TYPE_INVALID);
 779
 780                 if (0 == ret) {
 781                         MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
 782                 } else {
 783                         MAS_LOGE("[OUT ERROR] mas ui deinitialize : result(%d)", ret);
 784                 }
 785
 786                 if (!dbus_connection_send(conn, reply, NULL)) {
 787                         MAS_LOGE("[OUT ERROR] mas ui deinitialize : Out Of Memory!");
 788                 }
 789
 790                 dbus_connection_flush(conn);
 791                 dbus_message_unref(reply);
 792         } else {
 793                 MAS_LOGE("[OUT ERROR] mas ui deinitialize : Fail to create reply message!!");
 794         }
 795
 796         return 0;
 797 }
 798
 799 int ma_service_ui_dbus_change_assistant(DBusConnection* conn, DBusMessage* msg)
 800 {
 801         DBusError err;
 802         dbus_error_init(&err);
 803
 804         char *app_id;
 805         int ret = 0;
 806
 807         dbus_message_get_args(msg, &err,
 808                 DBUS_TYPE_STRING, &app_id,
 809                 DBUS_TYPE_INVALID);
 810
 811         MAS_LOGD("[DEBUG] MAS UI CHANGE ASSISTANT : %s", (app_id ? app_id : "NULL"));
 812
 813         if (dbus_error_is_set(&err)) {
 814                 MAS_LOGE("[IN ERROR] mas ui change assisant : Get arguments error (%s)", err.message);
 815                 dbus_error_free(&err);
 816                 ret = -1; //MAS_ERROR_OPERATION_FAILED;
 817         } else {
 818                 MAS_LOGD("[IN] mas ui change assisant : app_id(%s)", app_id);
 819                 ret = mas_ui_client_change_assistant(app_id);
 820         }
 821
 822         DBusMessage* reply;
 823         reply = dbus_message_new_method_return(msg);
 824
 825         if (NULL != reply) {
 826                 dbus_message_append_args(reply,
 827                         DBUS_TYPE_INT32, &ret,
 828                         DBUS_TYPE_INVALID);
 829
 830                 if (0 == ret) {
 831                         MAS_LOGD("[OUT] mas ui change assisant : result(%d)", ret);
 832                 } else {
 833                         MAS_LOGE("[OUT ERROR] mas ui change assisant : result(%d)", ret);
 834                 }
 835
 836                 if (!dbus_connection_send(conn, reply, NULL)) {
 837                         MAS_LOGE("[OUT ERROR] mas ui change assisant : Out Of Memory!");
 838                 }
 839
 840                 dbus_connection_flush(conn);
 841                 dbus_message_unref(reply);
 842         } else {
 843                 MAS_LOGE("[OUT ERROR] mas ui change assisant : Fail to create reply message!!");
 844         }
 845
 846         MAS_LOGD("<<<<<");
 847         MAS_LOGD("  ");
 848
 849         return 0;
 850 }