server/vcd_dbus_server.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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
  18 #include "vcd_client_data.h"
  19 #include "vcd_dbus.h"
  20 #include "vcd_dbus_server.h"
  21 #include "vcd_main.h"
  22 #include "vcd_server.h"
  23
  24
  25 int __dbus_error_return(DBusConnection* conn, DBusMessage* msg, int ret)
  26 {
  27         DBusMessage* reply;
  28         reply = dbus_message_new_method_return(msg);
  29
  30         if (NULL != reply) {
  31                 dbus_message_append_args(reply,
  32                                                                  DBUS_TYPE_INT32, &ret,
  33                                                                  DBUS_TYPE_INVALID);
  34
  35                 if (0 == ret) {
  36                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
  37                 } else {
  38                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
  39                 }
  40
  41                 if (!dbus_connection_send(conn, reply, NULL)) {
  42                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
  43                 }
  44
  45                 dbus_connection_flush(conn);
  46                 dbus_message_unref(reply);
  47         } else {
  48                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
  49         }
  50
  51         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
  52
  53         return 0;
  54 }
  55
  56 int vcd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
  57 {
  58         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Hello");
  59
  60         DBusMessage* reply;
  61         reply = dbus_message_new_method_return(msg);
  62
  63         if (NULL != reply) {
  64                 if (!dbus_connection_send(conn, reply, NULL)) {
  65                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
  66                 }
  67
  68                 dbus_connection_flush(conn);
  69                 dbus_message_unref(reply);
  70         } else {
  71                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
  72         }
  73
  74         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
  75
  76         return 0;
  77 }
  78
  79 /*
  80 * Dbus Server functions for manager
  81 */
  82
  83 int vcd_dbus_server_mgr_initialize(DBusConnection* conn, DBusMessage* msg)
  84 {
  85         DBusError err;
  86         dbus_error_init(&err);
  87
  88         int pid;
  89         int service_state;
  90         int foreground;
  91         int daemon_pid;
  92         int ret = VCD_ERROR_OPERATION_FAILED;
  93
  94         dbus_message_get_args(msg, &err,
  95                 DBUS_TYPE_INT32, &pid,
  96                 DBUS_TYPE_INVALID);
  97
  98         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Initialize");
  99
 100         if (dbus_error_is_set(&err)) {
 101                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr initialize : get arguments error (%s)", err.message);
 102                 dbus_error_free(&err);
 103                 ret = VCD_ERROR_OPERATION_FAILED;
 104         } else {
 105                 ret =  vcd_server_mgr_initialize(pid);
 106                 service_state = vcd_server_get_service_state();
 107                 foreground = vcd_server_get_foreground();
 108                 daemon_pid = getpid();
 109
 110                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid);
 111         }
 112
 113         DBusMessage* reply;
 114         reply = dbus_message_new_method_return(msg);
 115
 116         if (NULL != reply) {
 117                 dbus_message_append_args(reply,
 118                         DBUS_TYPE_INT32, &ret,
 119                         DBUS_TYPE_INT32, &service_state,
 120                         DBUS_TYPE_INT32, &foreground,
 121                         DBUS_TYPE_INT32, &daemon_pid,
 122                         DBUS_TYPE_INVALID);
 123
 124                 if (0 == ret) {
 125                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 126                 } else {
 127                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 128                 }
 129
 130                 if (!dbus_connection_send(conn, reply, NULL)) {
 131                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 132                 }
 133
 134                 dbus_connection_flush(conn);
 135                 dbus_message_unref(reply);
 136         } else {
 137                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 138         }
 139
 140         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 141
 142         return 0;
 143 }
 144
 145 int vcd_dbus_server_mgr_finalize(DBusConnection* conn, DBusMessage* msg)
 146 {
 147         DBusError err;
 148         dbus_error_init(&err);
 149
 150         int pid;
 151         int ret = VCD_ERROR_OPERATION_FAILED;
 152         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 153
 154         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Finalize");
 155
 156         if (dbus_error_is_set(&err)) {
 157                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr finalize : get arguments error (%s)", err.message);
 158                 dbus_error_free(&err);
 159                 ret = VCD_ERROR_OPERATION_FAILED;
 160         } else {
 161                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid);
 162                 ret =  vcd_server_mgr_finalize(pid);
 163         }
 164
 165         DBusMessage* reply;
 166
 167         reply = dbus_message_new_method_return(msg);
 168
 169         if (NULL != reply) {
 170                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 171
 172                 if (0 == ret) {
 173                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 174                 } else {
 175                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 176                 }
 177
 178                 if (!dbus_connection_send(conn, reply, NULL)) {
 179                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 180                 }
 181
 182                 dbus_connection_flush(conn);
 183                 dbus_message_unref(reply);
 184         } else {
 185                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 186         }
 187
 188         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 189
 190         return 0;
 191 }
 192
 193 int vcd_dbus_server_mgr_set_command(DBusConnection* conn, DBusMessage* msg)
 194 {
 195         DBusError err;
 196         dbus_error_init(&err);
 197
 198         int pid;
 199         int ret = VCD_ERROR_OPERATION_FAILED;
 200
 201         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 202
 203         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set command");
 204
 205         if (dbus_error_is_set(&err)) {
 206                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set command : get arguments error (%s)", err.message);
 207                 dbus_error_free(&err);
 208                 ret = VCD_ERROR_OPERATION_FAILED;
 209         } else {
 210                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid);
 211                 ret = vcd_server_mgr_set_command(pid);
 212         }
 213
 214         DBusMessage* reply;
 215         reply = dbus_message_new_method_return(msg);
 216
 217         if (NULL != reply) {
 218                 if (0 == ret) {
 219                         /* Append result and language */
 220                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 221
 222                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 223                 } else {
 224                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 225
 226                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 227                 }
 228
 229                 if (!dbus_connection_send(conn, reply, NULL)) {
 230                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 231                 }
 232
 233                 dbus_connection_flush(conn);
 234                 dbus_message_unref(reply);
 235         } else {
 236                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 237         }
 238
 239         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 240
 241         return 0;
 242 }
 243
 244 int vcd_dbus_server_mgr_unset_command(DBusConnection* conn, DBusMessage* msg)
 245 {
 246         DBusError err;
 247         dbus_error_init(&err);
 248
 249         int pid;
 250         int ret = VCD_ERROR_OPERATION_FAILED;
 251
 252         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 253
 254         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD manager unset command");
 255
 256         if (dbus_error_is_set(&err)) {
 257                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr unset command : get arguments error (%s)", err.message);
 258                 dbus_error_free(&err);
 259                 ret = VCD_ERROR_OPERATION_FAILED;
 260         } else {
 261                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid);
 262                 ret = vcd_server_mgr_unset_command(pid);
 263         }
 264
 265         DBusMessage* reply;
 266         reply = dbus_message_new_method_return(msg);
 267
 268         if (NULL != reply) {
 269                 if (0 == ret) {
 270                         /* Append result and language */
 271                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 272
 273                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 274                 } else {
 275                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 276
 277                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 278                 }
 279
 280                 if (!dbus_connection_send(conn, reply, NULL)) {
 281                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 282                 }
 283
 284                 dbus_connection_flush(conn);
 285                 dbus_message_unref(reply);
 286         } else {
 287                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 288         }
 289
 290         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 291
 292         return 0;
 293 }
 294
 295 int vcd_dbus_server_mgr_set_demandable_client(DBusConnection* conn, DBusMessage* msg)
 296 {
 297         DBusError err;
 298         dbus_error_init(&err);
 299
 300         int pid;
 301         int ret = VCD_ERROR_OPERATION_FAILED;
 302
 303         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 304
 305         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set demandable client");
 306
 307         if (dbus_error_is_set(&err)) {
 308                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set demandable client : get arguments error (%s)", err.message);
 309                 dbus_error_free(&err);
 310                 ret = VCD_ERROR_OPERATION_FAILED;
 311         } else {
 312                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid);
 313                 ret = vcd_server_mgr_set_demandable_client(pid);
 314         }
 315
 316         DBusMessage* reply;
 317         reply = dbus_message_new_method_return(msg);
 318
 319         if (NULL != reply) {
 320                 if (0 == ret) {
 321                         /* Append result and language */
 322                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 323
 324                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 325                 } else {
 326                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 327
 328                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 329                 }
 330
 331                 if (!dbus_connection_send(conn, reply, NULL)) {
 332                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 333                 }
 334
 335                 dbus_connection_flush(conn);
 336                 dbus_message_unref(reply);
 337         } else {
 338                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 339         }
 340
 341         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 342
 343         return 0;
 344 }
 345
 346 int vcd_dbus_server_mgr_set_audio_type(DBusConnection* conn, DBusMessage* msg)
 347 {
 348         DBusError err;
 349         dbus_error_init(&err);
 350
 351         int pid = 0;
 352         char* audio_type = NULL;
 353
 354         int ret = VCD_ERROR_OPERATION_FAILED;
 355
 356         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set audio type");
 357
 358         dbus_message_get_args(msg, &err,
 359                                                   DBUS_TYPE_INT32, &pid,
 360                                                   DBUS_TYPE_STRING, &audio_type,
 361                                                   DBUS_TYPE_INVALID);
 362
 363         if (dbus_error_is_set(&err)) {
 364                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message);
 365                 dbus_error_free(&err);
 366                 ret = VCD_ERROR_OPERATION_FAILED;
 367         } else {
 368                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
 369                 ret = vcd_server_mgr_set_audio_type(pid, audio_type);
 370         }
 371
 372         DBusMessage* reply;
 373         reply = dbus_message_new_method_return(msg);
 374
 375         if (NULL != reply) {
 376                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 377
 378                 if (0 == ret) {
 379                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 380                 } else {
 381                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 382                 }
 383
 384                 if (!dbus_connection_send(conn, reply, NULL)) {
 385                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 386                 }
 387
 388                 dbus_connection_flush(conn);
 389                 dbus_message_unref(reply);
 390         } else {
 391                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 392         }
 393
 394         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 395
 396         return 0;
 397 }
 398
 399 int vcd_dbus_server_mgr_get_audio_type(DBusConnection* conn, DBusMessage* msg)
 400 {
 401         DBusError err;
 402         dbus_error_init(&err);
 403
 404         int pid = 0;
 405         char* audio_type = NULL;
 406
 407         int ret = VCD_ERROR_OPERATION_FAILED;
 408
 409         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get audio type");
 410
 411         dbus_message_get_args(msg, &err,
 412                                                   DBUS_TYPE_INT32, &pid,
 413                                                   DBUS_TYPE_INVALID);
 414
 415         if (dbus_error_is_set(&err)) {
 416                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message);
 417                 dbus_error_free(&err);
 418                 ret = VCD_ERROR_OPERATION_FAILED;
 419         } else {
 420                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d)", pid);
 421                 ret = vcd_server_mgr_get_audio_type(pid, &audio_type);
 422         }
 423
 424         DBusMessage* reply;
 425         reply = dbus_message_new_method_return(msg);
 426
 427         if (NULL != reply) {
 428                 dbus_message_append_args(reply,
 429                                                                  DBUS_TYPE_INT32, &ret,
 430                                                                  DBUS_TYPE_STRING, &audio_type,
 431                                                                  DBUS_TYPE_INVALID);
 432
 433                 if (0 == ret) {
 434                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), audio type(%s)", ret, audio_type);
 435                 } else {
 436                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 437                 }
 438
 439                 if (!dbus_connection_send(conn, reply, NULL)) {
 440                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 441                 }
 442
 443                 dbus_connection_flush(conn);
 444                 dbus_message_unref(reply);
 445         } else {
 446                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 447         }
 448
 449         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 450
 451         if (NULL != audio_type) free(audio_type);
 452
 453         return 0;
 454 }
 455
 456 int vcd_dbus_server_mgr_set_client_info(DBusConnection* conn, DBusMessage* msg)
 457 {
 458         DBusError err;
 459         dbus_error_init(&err);
 460
 461         int pid = 0;
 462
 463         int ret = VCD_ERROR_OPERATION_FAILED;
 464
 465         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set client info");
 466
 467         dbus_message_get_args(msg, &err,
 468                                                   DBUS_TYPE_INT32, &pid,
 469                                                   DBUS_TYPE_INVALID);
 470
 471         if (dbus_error_is_set(&err)) {
 472                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set client info : get arguments error (%s)", err.message);
 473                 dbus_error_free(&err);
 474                 ret = VCD_ERROR_OPERATION_FAILED;
 475         } else {
 476                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid);
 477                 ret = vcd_server_mgr_set_client_info(pid);
 478         }
 479
 480         DBusMessage* reply;
 481         reply = dbus_message_new_method_return(msg);
 482
 483         if (NULL != reply) {
 484                 dbus_message_append_args(reply,
 485                                                                  DBUS_TYPE_INT32, &ret,
 486                                                                  DBUS_TYPE_INVALID);
 487
 488                 if (0 == ret) {
 489                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 490                 } else {
 491                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 492                 }
 493
 494                 if (!dbus_connection_send(conn, reply, NULL)) {
 495                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 496                 }
 497
 498                 dbus_connection_flush(conn);
 499                 dbus_message_unref(reply);
 500         } else {
 501                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 502         }
 503
 504         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 505
 506         return 0;
 507 }
 508
 509 int vcd_dbus_server_mgr_set_private_data(DBusConnection* conn, DBusMessage* msg)
 510 {
 511         DBusError err;
 512         dbus_error_init(&err);
 513
 514         int pid = 0;
 515         char* key = NULL;
 516         char* data = NULL;
 517
 518         int ret = VCD_ERROR_OPERATION_FAILED;
 519
 520         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set private data");
 521
 522         dbus_message_get_args(msg, &err,
 523                                 DBUS_TYPE_INT32, &pid,
 524                                 DBUS_TYPE_STRING, &key,
 525                                 DBUS_TYPE_STRING, &data,
 526                                 DBUS_TYPE_INVALID);
 527
 528         if (dbus_error_is_set(&err)) {
 529                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set private data : get arguments error (%s)", err.message);
 530                 dbus_error_free(&err);
 531                 ret = VCD_ERROR_OPERATION_FAILED;
 532         } else {
 533                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data);
 534                 ret = vcd_server_mgr_set_private_data(pid, key, data);
 535         }
 536
 537         DBusMessage* reply;
 538         reply = dbus_message_new_method_return(msg);
 539
 540         if (NULL != reply) {
 541                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 542
 543                 if (0 == ret) {
 544                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 545                 } else {
 546                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 547                 }
 548
 549                 if (!dbus_connection_send(conn, reply, NULL)) {
 550                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 551                 }
 552
 553                 dbus_connection_flush(conn);
 554                 dbus_message_unref(reply);
 555         } else {
 556                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 557         }
 558
 559         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 560
 561         return 0;
 562 }
 563
 564 int vcd_dbus_server_mgr_get_private_data(DBusConnection* conn, DBusMessage* msg)
 565 {
 566         DBusError err;
 567         dbus_error_init(&err);
 568
 569         int pid = 0;
 570         char* key = NULL;
 571         char* data = NULL;
 572
 573         int ret = VCD_ERROR_OPERATION_FAILED;
 574
 575         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get private data");
 576
 577         dbus_message_get_args(msg, &err,
 578                                 DBUS_TYPE_INT32, &pid,
 579                                 DBUS_TYPE_STRING, &key,
 580                                 DBUS_TYPE_INVALID);
 581
 582         if (dbus_error_is_set(&err)) {
 583                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message);
 584                 dbus_error_free(&err);
 585                 ret = VCD_ERROR_OPERATION_FAILED;
 586         } else {
 587                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key);
 588                 ret = vcd_server_mgr_get_private_data(pid, key, &data);
 589         }
 590
 591         DBusMessage* reply;
 592         reply = dbus_message_new_method_return(msg);
 593
 594         if (NULL != reply) {
 595                 dbus_message_append_args(reply,
 596                                         DBUS_TYPE_INT32, &ret,
 597                                         DBUS_TYPE_STRING, &data,
 598                                         DBUS_TYPE_INVALID);
 599
 600                 if (0 == ret) {
 601                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), private data(%s)", ret, data);
 602                 } else {
 603                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 604                 }
 605
 606                 if (!dbus_connection_send(conn, reply, NULL)) {
 607                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 608                 }
 609
 610                 dbus_connection_flush(conn);
 611                 dbus_message_unref(reply);
 612         } else {
 613                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 614         }
 615
 616         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 617
 618         if (NULL != data) free(data);
 619
 620         return 0;
 621 }
 622
 623 int vcd_dbus_server_mgr_set_domain(DBusConnection* conn, DBusMessage* msg)
 624 {
 625         DBusError err;
 626         dbus_error_init(&err);
 627
 628         int pid = 0;
 629         char* domain = NULL;
 630
 631         int ret = VCD_ERROR_OPERATION_FAILED;
 632
 633         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set audio type");
 634
 635         dbus_message_get_args(msg, &err,
 636                                 DBUS_TYPE_INT32, &pid,
 637                                 DBUS_TYPE_STRING, &domain,
 638                                 DBUS_TYPE_INVALID);
 639
 640         if (dbus_error_is_set(&err)) {
 641                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set domain : get arguments error (%s)", err.message);
 642                 dbus_error_free(&err);
 643                 ret = VCD_ERROR_OPERATION_FAILED;
 644         } else {
 645                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain);
 646                 ret = vcd_server_mgr_set_domain(pid, domain);
 647         }
 648
 649         DBusMessage* reply;
 650         reply = dbus_message_new_method_return(msg);
 651
 652         if (NULL != reply) {
 653                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 654
 655                 if (0 == ret) {
 656                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 657                 } else {
 658                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 659                 }
 660
 661                 if (!dbus_connection_send(conn, reply, NULL)) {
 662                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 663                 }
 664
 665                 dbus_connection_flush(conn);
 666                 dbus_message_unref(reply);
 667         } else {
 668                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 669         }
 670
 671         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 672
 673         return 0;
 674 }
 675
 676 int vcd_dbus_server_mgr_do_action(DBusConnection* conn, DBusMessage* msg)
 677 {
 678         DBusError err;
 679         dbus_error_init(&err);
 680
 681         int pid = 0;
 682         int type = 0;
 683         char* send_event = NULL;
 684
 685         int ret = VCD_ERROR_OPERATION_FAILED;
 686
 687         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager request to do action");
 688
 689         dbus_message_get_args(msg, &err,
 690                                 DBUS_TYPE_INT32, &pid,
 691                                 DBUS_TYPE_INT32, &type,
 692                                 DBUS_TYPE_STRING, &send_event,
 693                                 DBUS_TYPE_INVALID);
 694
 695         if (dbus_error_is_set(&err)) {
 696                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr request to do action : get arguments error (%s)", err.message);
 697                 dbus_error_free(&err);
 698                 ret = VCD_ERROR_OPERATION_FAILED;
 699         } else {
 700                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event);
 701                 ret = vcd_server_mgr_do_action(pid, type, send_event);
 702         }
 703
 704         DBusMessage* reply;
 705         reply = dbus_message_new_method_return(msg);
 706
 707         if (NULL != reply) {
 708                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 709
 710                 if (0 == ret) {
 711                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 712                 } else {
 713                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 714                 }
 715
 716                 if (!dbus_connection_send(conn, reply, NULL)) {
 717                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 718                 }
 719
 720                 dbus_connection_flush(conn);
 721                 dbus_message_unref(reply);
 722         } else {
 723                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 724         }
 725
 726         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 727
 728         return 0;
 729 }
 730
 731 int vcd_dbus_server_mgr_enable_command_type(DBusConnection* conn, DBusMessage* msg)
 732 {
 733         DBusError err;
 734         dbus_error_init(&err);
 735
 736         int pid = 0;
 737         int cmd_type = 0;
 738
 739         int ret = VCD_ERROR_OPERATION_FAILED;
 740
 741         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager enable command type");
 742
 743         dbus_message_get_args(msg, &err,
 744                                 DBUS_TYPE_INT32, &pid,
 745                                 DBUS_TYPE_INT32, &cmd_type,
 746                                 DBUS_TYPE_INVALID);
 747
 748         if (dbus_error_is_set(&err)) {
 749                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr enable command type : get arguments error (%s)", err.message);
 750                 dbus_error_free(&err);
 751                 ret = VCD_ERROR_OPERATION_FAILED;
 752         } else {
 753                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr enable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
 754                 ret = vcd_server_mgr_enable_command_type(pid, cmd_type);
 755         }
 756
 757         DBusMessage* reply;
 758         reply = dbus_message_new_method_return(msg);
 759
 760         if (NULL != reply) {
 761                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 762
 763                 if (0 == ret) {
 764                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 765                 } else {
 766                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 767                 }
 768
 769                 if (!dbus_connection_send(conn, reply, NULL)) {
 770                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 771                 }
 772
 773                 dbus_connection_flush(conn);
 774                 dbus_message_unref(reply);
 775         } else {
 776                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 777         }
 778
 779         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 780
 781         return 0;
 782 }
 783
 784 int vcd_dbus_server_mgr_disable_command_type(DBusConnection* conn, DBusMessage* msg)
 785 {
 786         DBusError err;
 787         dbus_error_init(&err);
 788
 789         int pid = 0;
 790         int cmd_type = 0;
 791
 792         int ret = VCD_ERROR_OPERATION_FAILED;
 793
 794         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager disable command type");
 795
 796         dbus_message_get_args(msg, &err,
 797                                 DBUS_TYPE_INT32, &pid,
 798                                 DBUS_TYPE_INT32, &cmd_type,
 799                                 DBUS_TYPE_INVALID);
 800
 801         if (dbus_error_is_set(&err)) {
 802                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr disable command type : get arguments error (%s)", err.message);
 803                 dbus_error_free(&err);
 804                 ret = VCD_ERROR_OPERATION_FAILED;
 805         } else {
 806                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr disable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
 807                 ret = vcd_server_mgr_disable_command_type(pid, cmd_type);
 808         }
 809
 810         DBusMessage* reply;
 811         reply = dbus_message_new_method_return(msg);
 812
 813         if (NULL != reply) {
 814                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 815
 816                 if (0 == ret) {
 817                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 818                 } else {
 819                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 820                 }
 821
 822                 if (!dbus_connection_send(conn, reply, NULL)) {
 823                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 824                 }
 825
 826                 dbus_connection_flush(conn);
 827                 dbus_message_unref(reply);
 828         } else {
 829                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 830         }
 831
 832         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 833
 834         return 0;
 835 }
 836
 837 int vcd_dbus_server_mgr_start(DBusConnection* conn, DBusMessage* msg)
 838 {
 839         DBusError err;
 840         dbus_error_init(&err);
 841
 842         int pid = 0;
 843         int recognition_mode = 0;
 844         int exclusive = 0;
 845         int start_by_client = 0;
 846
 847         int ret = VCD_ERROR_OPERATION_FAILED;
 848
 849         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager start");
 850
 851         dbus_message_get_args(msg, &err,
 852                                                   DBUS_TYPE_INT32, &pid,
 853                                                   DBUS_TYPE_INT32, &recognition_mode,
 854                                                   DBUS_TYPE_INT32, &exclusive,
 855                                                   DBUS_TYPE_INT32, &start_by_client,
 856                                                   DBUS_TYPE_INVALID);
 857
 858         if (dbus_error_is_set(&err)) {
 859                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr start : get arguments error (%s)", err.message);
 860                 dbus_error_free(&err);
 861                 ret = VCD_ERROR_OPERATION_FAILED;
 862         } else {
 863                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive, start_by_client);
 864                 ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, (bool)exclusive, (bool)start_by_client);
 865         }
 866
 867         DBusMessage* reply;
 868         reply = dbus_message_new_method_return(msg);
 869
 870         if (NULL != reply) {
 871                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 872
 873                 if (0 == ret) {
 874                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 875                 } else {
 876                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 877                 }
 878
 879                 if (!dbus_connection_send(conn, reply, NULL)) {
 880                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 881                 }
 882
 883                 dbus_connection_flush(conn);
 884                 dbus_message_unref(reply);
 885         } else {
 886                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 887         }
 888
 889         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 890
 891         return 0;
 892 }
 893
 894 int vcd_dbus_server_mgr_stop(DBusConnection* conn, DBusMessage* msg)
 895 {
 896         DBusError err;
 897         dbus_error_init(&err);
 898
 899         int pid;
 900         int ret = VCD_ERROR_OPERATION_FAILED;
 901         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 902
 903         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager stop");
 904
 905         if (dbus_error_is_set(&err)) {
 906                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr stop : get arguments error (%s)", err.message);
 907                 dbus_error_free(&err);
 908                 ret = VCD_ERROR_OPERATION_FAILED;
 909         } else {
 910                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid);
 911                 ret = vcd_server_mgr_stop();
 912         }
 913
 914         DBusMessage* reply;
 915         reply = dbus_message_new_method_return(msg);
 916
 917         if (NULL != reply) {
 918                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 919
 920                 if (0 == ret) {
 921                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 922                 } else {
 923                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 924                 }
 925
 926                 if (!dbus_connection_send(conn, reply, NULL)) {
 927                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 928                 }
 929
 930                 dbus_connection_flush(conn);
 931                 dbus_message_unref(reply);
 932         } else {
 933                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 934         }
 935
 936         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 937
 938         return 0;
 939 }
 940
 941 int vcd_dbus_server_mgr_cancel(DBusConnection* conn, DBusMessage* msg)
 942 {
 943         DBusError err;
 944         dbus_error_init(&err);
 945
 946         int pid;
 947         int ret = VCD_ERROR_OPERATION_FAILED;
 948         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 949
 950         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager cancel");
 951
 952         if (dbus_error_is_set(&err)) {
 953                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr cancel : get arguments error (%s)", err.message);
 954                 dbus_error_free(&err);
 955                 ret = VCD_ERROR_OPERATION_FAILED;
 956         } else {
 957                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid);
 958                 ret = vcd_server_mgr_cancel();
 959         }
 960
 961         DBusMessage* reply;
 962         reply = dbus_message_new_method_return(msg);
 963
 964         if (NULL != reply) {
 965                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 966
 967                 if (0 == ret) {
 968                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
 969                 } else {
 970                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
 971                 }
 972
 973                 if (!dbus_connection_send(conn, reply, NULL)) {
 974                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
 975                 }
 976
 977                 dbus_connection_flush(conn);
 978                 dbus_message_unref(reply);
 979         } else {
 980                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
 981         }
 982
 983         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
 984
 985         return 0;
 986 }
 987
 988 int vcd_dbus_server_mgr_result_selection(DBusConnection* conn, DBusMessage* msg)
 989 {
 990         DBusError err;
 991         dbus_error_init(&err);
 992
 993         int pid;
 994         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 995
 996         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager result selection");
 997
 998         if (dbus_error_is_set(&err)) {
 999                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr result selection : get arguments error (%s)", err.message);
1000                 dbus_error_free(&err);
1001         } else {
1002                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid);
1003                 vcd_server_mgr_result_select();
1004         }
1005         return 0;
1006
1007         /*
1008         DBusMessage* reply;
1009         reply = dbus_message_new_method_return(msg);
1010
1011         if (NULL != reply) {
1012                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1013
1014                 if (0 == ret) {
1015                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1016                 } else {
1017                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1018                 }
1019
1020                 if (!dbus_connection_send(conn, reply, NULL)) {
1021                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1022                 }
1023
1024                 dbus_connection_flush(conn);
1025                 dbus_message_unref(reply);
1026         } else {
1027                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1028         }
1029
1030         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1031
1032         return 0;
1033         */
1034 }
1035
1036 /*
1037 * Dbus Server functions for client
1038 */
1039 int vcd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
1040 {
1041         DBusError err;
1042         dbus_error_init(&err);
1043
1044         int pid;
1045         int service_state = 0;
1046         int daemon_pid;
1047         int ret = VCD_ERROR_OPERATION_FAILED;
1048
1049         dbus_message_get_args(msg, &err,
1050                                                   DBUS_TYPE_INT32, &pid,
1051                                                   DBUS_TYPE_INVALID);
1052
1053         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Initialize");
1054
1055         if (dbus_error_is_set(&err)) {
1056                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd initialize : get arguments error (%s)", err.message);
1057                 dbus_error_free(&err);
1058                 ret = VCD_ERROR_OPERATION_FAILED;
1059         } else {
1060                 ret =  vcd_server_initialize(pid);
1061                 service_state = vcd_server_get_service_state();
1062                 daemon_pid = getpid();
1063                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
1064         }
1065
1066         int mgr_pid = vcd_client_manager_get_pid();
1067
1068         DBusMessage* reply;
1069         reply = dbus_message_new_method_return(msg);
1070
1071         if (NULL != reply) {
1072                 dbus_message_append_args(reply,
1073                         DBUS_TYPE_INT32, &ret,
1074                         DBUS_TYPE_INT32, &mgr_pid,
1075                         DBUS_TYPE_INT32, &service_state,
1076                         DBUS_TYPE_INT32, &daemon_pid,
1077                         DBUS_TYPE_INVALID);
1078
1079                 if (0 == ret) {
1080                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1081                 } else {
1082                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1083                 }
1084
1085                 if (!dbus_connection_send(conn, reply, NULL)) {
1086                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1087                 }
1088
1089                 dbus_connection_flush(conn);
1090                 dbus_message_unref(reply);
1091         } else {
1092                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1093         }
1094
1095         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1096
1097         return 0;
1098 }
1099
1100 int vcd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
1101 {
1102         DBusError err;
1103         dbus_error_init(&err);
1104
1105         int pid;
1106         int ret = VCD_ERROR_OPERATION_FAILED;
1107         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1108
1109         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Finalize");
1110
1111         if (dbus_error_is_set(&err)) {
1112                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd finalize : get arguments error (%s)", err.message);
1113                 dbus_error_free(&err);
1114                 ret = VCD_ERROR_OPERATION_FAILED;
1115         } else {
1116                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd finalize : pid(%d)", pid);
1117                 ret =  vcd_server_finalize(pid);
1118         }
1119
1120         DBusMessage* reply;
1121
1122         reply = dbus_message_new_method_return(msg);
1123
1124         if (NULL != reply) {
1125                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1126
1127                 if (0 == ret) {
1128                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1129                 } else {
1130                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1131                 }
1132
1133                 if (!dbus_connection_send(conn, reply, NULL)) {
1134                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1135                 }
1136
1137                 dbus_connection_flush(conn);
1138                 dbus_message_unref(reply);
1139         } else {
1140                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1141         }
1142
1143         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1144
1145         return 0;
1146 }
1147
1148 #if 0
1149 int vcd_dbus_server_set_exclusive_command(DBusConnection* conn, DBusMessage* msg)
1150 {
1151         DBusError err;
1152         dbus_error_init(&err);
1153
1154         int pid;
1155         int value;
1156         int ret = VCD_ERROR_OPERATION_FAILED;
1157
1158         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1159
1160         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD set exclusive command");
1161
1162         if (dbus_error_is_set(&err)) {
1163                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd unset command : get arguments error (%s)", err.message);
1164                 dbus_error_free(&err);
1165                 ret = VCD_ERROR_OPERATION_FAILED;
1166         } else {
1167                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd unset command : pid(%d) value(%d)", pid, value);
1168                 ret = vcd_server_set_exclusive_command(pid, (bool)value);
1169         }
1170
1171         DBusMessage* reply;
1172         reply = dbus_message_new_method_return(msg);
1173
1174         if (NULL != reply) {
1175                 if (0 == ret) {
1176                         /* Append result and language */
1177                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1178
1179                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1180                 } else {
1181                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1182
1183                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1184                 }
1185
1186                 if (!dbus_connection_send(conn, reply, NULL)) {
1187                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1188                 }
1189
1190                 dbus_connection_flush(conn);
1191                 dbus_message_unref(reply);
1192         } else {
1193                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1194         }
1195
1196         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1197
1198         return 0;
1199 }
1200 #endif
1201
1202 int vcd_dbus_server_set_command(DBusConnection* conn, DBusMessage* msg)
1203 {
1204         DBusError err;
1205         dbus_error_init(&err);
1206
1207         int pid;
1208         int cmd_type;
1209         int ret = VCD_ERROR_OPERATION_FAILED;
1210
1211         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &cmd_type, DBUS_TYPE_INVALID);
1212
1213         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD set command");
1214
1215         if (dbus_error_is_set(&err)) {
1216                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd set command : get arguments error (%s)", err.message);
1217                 dbus_error_free(&err);
1218                 ret = VCD_ERROR_OPERATION_FAILED;
1219         } else {
1220                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set command : pid(%d), cmd_type(%d)", pid, cmd_type);
1221                 ret = vcd_server_set_command(pid, (vc_cmd_type_e)cmd_type);
1222         }
1223
1224         DBusMessage* reply;
1225         reply = dbus_message_new_method_return(msg);
1226
1227         if (NULL != reply) {
1228                 if (0 == ret) {
1229                         /* Append result and language */
1230                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1231
1232                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1233                 } else {
1234                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1235
1236                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1237                 }
1238
1239                 if (!dbus_connection_send(conn, reply, NULL)) {
1240                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1241                 }
1242
1243                 dbus_connection_flush(conn);
1244                 dbus_message_unref(reply);
1245         } else {
1246                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1247         }
1248
1249         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1250
1251         return 0;
1252 }
1253
1254 int vcd_dbus_server_unset_command(DBusConnection* conn, DBusMessage* msg)
1255 {
1256         DBusError err;
1257         dbus_error_init(&err);
1258
1259         int pid;
1260         int cmd_type;
1261         int ret = VCD_ERROR_OPERATION_FAILED;
1262
1263         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &cmd_type, DBUS_TYPE_INVALID);
1264
1265         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD unset command");
1266
1267         if (dbus_error_is_set(&err)) {
1268                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd unset command : get arguments error (%s)", err.message);
1269                 dbus_error_free(&err);
1270                 ret = VCD_ERROR_OPERATION_FAILED;
1271         } else {
1272                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd unset command : pid(%d), cmd_type(%d)", pid, cmd_type);
1273                 ret = vcd_server_unset_command(pid, (vc_cmd_type_e)cmd_type);
1274         }
1275
1276         DBusMessage* reply;
1277         reply = dbus_message_new_method_return(msg);
1278
1279         if (NULL != reply) {
1280                 if (0 == ret) {
1281                         /* Append result and language */
1282                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1283
1284                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1285                 } else {
1286                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1287
1288                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1289                 }
1290
1291                 if (!dbus_connection_send(conn, reply, NULL)) {
1292                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1293                 }
1294
1295                 dbus_connection_flush(conn);
1296                 dbus_message_unref(reply);
1297         } else {
1298                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1299         }
1300
1301         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1302
1303         return 0;
1304 }
1305
1306 int vcd_dbus_server_set_foreground(DBusConnection* conn, DBusMessage* msg)
1307 {
1308         DBusError err;
1309         dbus_error_init(&err);
1310
1311         int pid;
1312         int value;
1313
1314         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1315
1316         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD set foreground");
1317
1318         if (dbus_error_is_set(&err)) {
1319                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd set foreground : get arguments error (%s)", err.message);
1320                 dbus_error_free(&err);
1321         } else {
1322                 bool tmp_value;
1323                 tmp_value = (bool)value;
1324                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set foreground : pid(%d), value(%s)", pid, value ? "true" : "false");
1325                 vcd_server_set_foreground(pid, tmp_value);
1326         }
1327
1328         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1329
1330         return 0;
1331 }
1332
1333 int vcd_dbus_server_dialog(DBusConnection* conn, DBusMessage* msg)
1334 {
1335         DBusError err;
1336         dbus_error_init(&err);
1337
1338         int pid;
1339         char* disp_text = NULL;
1340         char* utt_text = NULL;
1341         int continuous;
1342         int ret = VCD_ERROR_OPERATION_FAILED;
1343
1344         dbus_message_get_args(msg, &err,
1345                                 DBUS_TYPE_INT32, &pid,
1346                                 DBUS_TYPE_STRING, &disp_text,
1347                                 DBUS_TYPE_STRING, &utt_text,
1348                                 DBUS_TYPE_INT32, &continuous,
1349                                 DBUS_TYPE_INVALID);
1350
1351         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD request dialog");
1352
1353         if (dbus_error_is_set(&err)) {
1354                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd request dialog : get arguments error (%s)", err.message);
1355                 dbus_error_free(&err);
1356         } else {
1357                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", pid, disp_text, utt_text, continuous);
1358                 ret = vcd_server_dialog(pid, disp_text, utt_text, continuous);
1359         }
1360
1361         DBusMessage* reply;
1362         reply = dbus_message_new_method_return(msg);
1363
1364         if (NULL != reply) {
1365                 if (0 == ret) {
1366                         /* Append result and language */
1367                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1368
1369                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1370                 } else {
1371                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1372
1373                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1374                 }
1375
1376                 if (!dbus_connection_send(conn, reply, NULL)) {
1377                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1378                 }
1379
1380                 dbus_connection_flush(conn);
1381                 dbus_message_unref(reply);
1382         } else {
1383                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1384         }
1385
1386
1387         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1388
1389         return 0;
1390 }
1391
1392 int vcd_dbus_server_is_system_command_valid(DBusConnection* conn, DBusMessage* msg)
1393 {
1394         DBusError err;
1395         dbus_error_init(&err);
1396
1397         int pid;
1398         int is_sys_cmd_valid;
1399
1400         int ret = VCD_ERROR_OPERATION_FAILED;
1401
1402         dbus_message_get_args(msg, &err,
1403                                 DBUS_TYPE_INT32, &pid,
1404                                 DBUS_TYPE_INVALID);
1405
1406         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD request to check system command is valid");
1407
1408         if (dbus_error_is_set(&err)) {
1409                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd request to check system command is valid : get arguments error (%s)", err.message);
1410                 dbus_error_free(&err);
1411         } else {
1412                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd dialog : pid(%d)", pid);
1413                 ret = vcd_server_is_system_command_valid(pid, &is_sys_cmd_valid);
1414         }
1415
1416         DBusMessage* reply;
1417         reply = dbus_message_new_method_return(msg);
1418
1419         if (NULL != reply) {
1420                 dbus_message_append_args(reply,
1421                                         DBUS_TYPE_INT32, &ret,
1422                                         DBUS_TYPE_INT32, &is_sys_cmd_valid,
1423                                         DBUS_TYPE_INVALID);
1424
1425                 if (0 == ret) {
1426                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), is_sys_cmd_valid (%d)", ret, is_sys_cmd_valid);
1427                 } else {
1428                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1429                 }
1430
1431                 if (!dbus_connection_send(conn, reply, NULL)) {
1432                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1433                 }
1434
1435                 dbus_connection_flush(conn);
1436                 dbus_message_unref(reply);
1437         } else {
1438                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1439         }
1440
1441         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1442
1443         return 0;
1444 }
1445
1446 #if 0
1447 int vcd_dbus_server_start_request(DBusConnection* conn, DBusMessage* msg)
1448 {
1449         DBusError err;
1450         dbus_error_init(&err);
1451
1452         int pid;
1453         int silence;
1454
1455         int ret = VCD_ERROR_OPERATION_FAILED;
1456
1457         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Request Start");
1458
1459         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &silence, DBUS_TYPE_INVALID);
1460
1461         if (dbus_error_is_set(&err)) {
1462                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd start : get arguments error (%s)", err.message);
1463                 dbus_error_free(&err);
1464                 ret = VCD_ERROR_OPERATION_FAILED;
1465         } else {
1466                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd request start : pid(%d), silence(%d)", pid, silence);
1467                 ret = vcd_server_request_start(pid, (bool)silence);
1468         }
1469
1470         DBusMessage* reply;
1471         reply = dbus_message_new_method_return(msg);
1472
1473         if (NULL != reply) {
1474                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1475
1476                 if (0 == ret) {
1477                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1478                 } else {
1479                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1480                 }
1481
1482                 if (!dbus_connection_send(conn, reply, NULL)) {
1483                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1484                 }
1485
1486                 dbus_connection_flush(conn);
1487                 dbus_message_unref(reply);
1488         } else {
1489                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1490         }
1491
1492         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1493
1494         return 0;
1495 }
1496
1497 int vcd_dbus_server_stop_request(DBusConnection* conn, DBusMessage* msg)
1498 {
1499         DBusError err;
1500         dbus_error_init(&err);
1501
1502         int pid;
1503         int ret = VCD_ERROR_OPERATION_FAILED;
1504         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1505
1506         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Request Stop");
1507
1508         if (dbus_error_is_set(&err)) {
1509                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd stop : get arguments error (%s)", err.message);
1510                 dbus_error_free(&err);
1511                 ret = VCD_ERROR_OPERATION_FAILED;
1512         } else {
1513                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd request stop : pid(%d)", pid);
1514                 ret = vcd_server_request_stop(pid);
1515         }
1516
1517         DBusMessage* reply;
1518         reply = dbus_message_new_method_return(msg);
1519
1520         if (NULL != reply) {
1521                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1522
1523                 if (0 == ret) {
1524                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1525                 } else {
1526                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1527                 }
1528
1529                 if (!dbus_connection_send(conn, reply, NULL)) {
1530                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1531                 }
1532
1533                 dbus_connection_flush(conn);
1534                 dbus_message_unref(reply);
1535         } else {
1536                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1537         }
1538
1539         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1540
1541         return 0;
1542 }
1543
1544 int vcd_dbus_server_cancel_request(DBusConnection* conn, DBusMessage* msg)
1545 {
1546         DBusError err;
1547         dbus_error_init(&err);
1548
1549         int pid;
1550         int ret = VCD_ERROR_OPERATION_FAILED;
1551         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1552
1553         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Request Cancel");
1554
1555         if (dbus_error_is_set(&err)) {
1556                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd cancel : get arguments error (%s)", err.message);
1557                 dbus_error_free(&err);
1558                 ret = VCD_ERROR_OPERATION_FAILED;
1559         } else {
1560                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd request cancel : pid(%d)", pid);
1561                 ret = vcd_server_request_cancel(pid);
1562         }
1563
1564         DBusMessage* reply;
1565         reply = dbus_message_new_method_return(msg);
1566
1567         if (NULL != reply) {
1568                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1569
1570                 if (0 == ret) {
1571                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1572                 } else {
1573                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1574                 }
1575
1576                 if (!dbus_connection_send(conn, reply, NULL)) {
1577                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1578                 }
1579
1580                 dbus_connection_flush(conn);
1581                 dbus_message_unref(reply);
1582         } else {
1583                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1584         }
1585
1586         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1587
1588         return 0;
1589 }
1590 #endif
1591
1592 /*
1593 * Dbus Widget-Daemon Server
1594 */
1595 int vcd_dbus_server_widget_initialize(DBusConnection* conn, DBusMessage* msg)
1596 {
1597         DBusError err;
1598         dbus_error_init(&err);
1599
1600         int pid;
1601         int service_state = 0;
1602         int daemon_pid;
1603         int ret = VCD_ERROR_OPERATION_FAILED;
1604
1605         dbus_message_get_args(msg, &err,
1606                 DBUS_TYPE_INT32, &pid,
1607                 DBUS_TYPE_INVALID);
1608
1609         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Widget Initialize");
1610
1611         if (dbus_error_is_set(&err)) {
1612                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget initialize : get arguments error (%s)", err.message);
1613                 dbus_error_free(&err);
1614                 ret = VCD_ERROR_OPERATION_FAILED;
1615         } else {
1616                 ret =  vcd_server_widget_initialize(pid);
1617                 service_state = vcd_server_get_service_state();
1618                 daemon_pid = getpid();
1619                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
1620         }
1621
1622         DBusMessage* reply;
1623         reply = dbus_message_new_method_return(msg);
1624
1625         if (NULL != reply) {
1626                 dbus_message_append_args(reply,
1627                         DBUS_TYPE_INT32, &ret,
1628                         DBUS_TYPE_INT32, &service_state,
1629                         DBUS_TYPE_INT32, &daemon_pid,
1630                         DBUS_TYPE_INVALID);
1631
1632                 if (0 == ret) {
1633                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1634                 } else {
1635                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1636                 }
1637
1638                 if (!dbus_connection_send(conn, reply, NULL)) {
1639                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1640                 }
1641
1642                 dbus_connection_flush(conn);
1643                 dbus_message_unref(reply);
1644         } else {
1645                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1646         }
1647
1648         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1649
1650         return 0;
1651 }
1652
1653 int vcd_dbus_server_widget_finalize(DBusConnection* conn, DBusMessage* msg)
1654 {
1655         DBusError err;
1656         dbus_error_init(&err);
1657
1658         int pid;
1659         int ret = VCD_ERROR_OPERATION_FAILED;
1660         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1661
1662         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Widget Finalize");
1663
1664         if (dbus_error_is_set(&err)) {
1665                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget finalize : get arguments error (%s)", err.message);
1666                 dbus_error_free(&err);
1667                 ret = VCD_ERROR_OPERATION_FAILED;
1668         } else {
1669                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget finalize : pid(%d)", pid);
1670                 ret =  vcd_server_widget_finalize(pid);
1671         }
1672
1673         DBusMessage* reply;
1674
1675         reply = dbus_message_new_method_return(msg);
1676
1677         if (NULL != reply) {
1678                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1679
1680                 if (0 == ret) {
1681                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1682                 } else {
1683                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1684                 }
1685
1686                 if (!dbus_connection_send(conn, reply, NULL)) {
1687                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1688                 }
1689
1690                 dbus_connection_flush(conn);
1691                 dbus_message_unref(reply);
1692         } else {
1693                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1694         }
1695
1696         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1697
1698         return 0;
1699 }
1700
1701 int vcd_dbus_server_widget_start_recording(DBusConnection* conn, DBusMessage* msg)
1702 {
1703         DBusError err;
1704         dbus_error_init(&err);
1705
1706         int pid;
1707         int ret = VCD_ERROR_OPERATION_FAILED;
1708         int widget_command;
1709
1710         dbus_message_get_args(msg, &err,
1711                                                   DBUS_TYPE_INT32, &pid,
1712                                                   DBUS_TYPE_INT32, &widget_command,
1713                                                   DBUS_TYPE_INVALID);
1714
1715         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD widget start recording");
1716
1717         if (dbus_error_is_set(&err)) {
1718                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget start recording : get arguments error (%s)", err.message);
1719                 dbus_error_free(&err);
1720                 ret = VCD_ERROR_OPERATION_FAILED;
1721         } else {
1722                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start recording : pid(%d)", pid);
1723                 ret = vcd_server_widget_start_recording(pid, widget_command);
1724         }
1725
1726         DBusMessage* reply;
1727         reply = dbus_message_new_method_return(msg);
1728
1729         if (NULL != reply) {
1730                 if (0 == ret) {
1731                         /* Append result and language */
1732                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1733
1734                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1735                 } else {
1736                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1737
1738                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1739                 }
1740
1741                 if (!dbus_connection_send(conn, reply, NULL)) {
1742                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1743                 }
1744
1745                 dbus_connection_flush(conn);
1746                 dbus_message_unref(reply);
1747         } else {
1748                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1749         }
1750
1751         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1752
1753         return 0;
1754 }
1755
1756 int vcd_dbus_server_widget_start(DBusConnection* conn, DBusMessage* msg)
1757 {
1758         DBusError err;
1759         dbus_error_init(&err);
1760
1761         int pid;
1762         int silence;
1763
1764         int ret = VCD_ERROR_OPERATION_FAILED;
1765
1766         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD widget start");
1767
1768         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &silence, DBUS_TYPE_INVALID);
1769
1770         if (dbus_error_is_set(&err)) {
1771                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd start : get arguments error (%s)", err.message);
1772                 dbus_error_free(&err);
1773                 ret = VCD_ERROR_OPERATION_FAILED;
1774         } else {
1775                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start : pid(%d), silence(%d)", pid, silence);
1776                 ret = vcd_server_widget_start(pid, (bool)silence);
1777         }
1778
1779         DBusMessage* reply;
1780         reply = dbus_message_new_method_return(msg);
1781
1782         if (NULL != reply) {
1783                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1784
1785                 if (0 == ret) {
1786                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1787                 } else {
1788                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1789                 }
1790
1791                 if (!dbus_connection_send(conn, reply, NULL)) {
1792                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1793                 }
1794
1795                 dbus_connection_flush(conn);
1796                 dbus_message_unref(reply);
1797         } else {
1798                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1799         }
1800
1801         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1802
1803         return 0;
1804 }
1805
1806 int vcd_dbus_server_widget_stop(DBusConnection* conn, DBusMessage* msg)
1807 {
1808         DBusError err;
1809         dbus_error_init(&err);
1810
1811         int pid;
1812         int ret = VCD_ERROR_OPERATION_FAILED;
1813         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1814
1815         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD widget stop");
1816
1817         if (dbus_error_is_set(&err)) {
1818                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget stop : get arguments error (%s)", err.message);
1819                 dbus_error_free(&err);
1820                 ret = VCD_ERROR_OPERATION_FAILED;
1821         } else {
1822                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget stop : pid(%d)", pid);
1823                 ret = vcd_server_widget_stop(pid);
1824         }
1825
1826         DBusMessage* reply;
1827         reply = dbus_message_new_method_return(msg);
1828
1829         if (NULL != reply) {
1830                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1831
1832                 if (0 == ret) {
1833                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1834                 } else {
1835                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1836                 }
1837
1838                 if (!dbus_connection_send(conn, reply, NULL)) {
1839                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1840                 }
1841
1842                 dbus_connection_flush(conn);
1843                 dbus_message_unref(reply);
1844         } else {
1845                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1846         }
1847
1848         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1849
1850         return 0;
1851 }
1852
1853 int vcd_dbus_server_widget_cancel(DBusConnection* conn, DBusMessage* msg)
1854 {
1855         DBusError err;
1856         dbus_error_init(&err);
1857
1858         int pid;
1859         int ret = VCD_ERROR_OPERATION_FAILED;
1860         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
1861
1862         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD widget cancel");
1863
1864         if (dbus_error_is_set(&err)) {
1865                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget cancel : get arguments error (%s)", err.message);
1866                 dbus_error_free(&err);
1867                 ret = VCD_ERROR_OPERATION_FAILED;
1868         } else {
1869                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget cancel : pid(%d)", pid);
1870                 ret = vcd_server_widget_cancel(pid);
1871         }
1872
1873         DBusMessage* reply;
1874         reply = dbus_message_new_method_return(msg);
1875
1876         if (NULL != reply) {
1877                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1878
1879                 if (0 == ret) {
1880                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1881                 } else {
1882                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1883                 }
1884
1885                 if (!dbus_connection_send(conn, reply, NULL)) {
1886                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1887                 }
1888
1889                 dbus_connection_flush(conn);
1890                 dbus_message_unref(reply);
1891         } else {
1892                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1893         }
1894
1895         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1896
1897         return 0;
1898 }
1899
1900 int vcd_dbus_server_widget_enable_asr_result(DBusConnection* conn, DBusMessage* msg)
1901 {
1902         DBusError err;
1903         dbus_error_init(&err);
1904
1905         int pid;
1906         int enable;
1907         int ret = VCD_ERROR_OPERATION_FAILED;
1908         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &enable, DBUS_TYPE_INVALID);
1909
1910         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD widget enable asr result");
1911
1912         if (dbus_error_is_set(&err)) {
1913                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget enable asr result : get arguments error (%s)", err.message);
1914                 dbus_error_free(&err);
1915                 ret = VCD_ERROR_OPERATION_FAILED;
1916         } else {
1917                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget enable asr result : pid(%d) enable(%d)", pid, enable);
1918                 ret = vcd_server_widget_enable_asr_result(pid, enable);
1919         }
1920
1921         DBusMessage* reply;
1922         reply = dbus_message_new_method_return(msg);
1923
1924         if (NULL != reply) {
1925                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1926
1927                 if (0 == ret) {
1928                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1929                 } else {
1930                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1931                 }
1932
1933                 if (!dbus_connection_send(conn, reply, NULL)) {
1934                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1935                 }
1936
1937                 dbus_connection_flush(conn);
1938                 dbus_message_unref(reply);
1939         } else {
1940                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1941         }
1942
1943         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1944
1945         return 0;
1946 }
1947
1948 int vcd_dbus_server_set_language(DBusConnection* conn, DBusMessage* msg)
1949 {
1950         DBusError err;
1951         dbus_error_init(&err);
1952
1953         int pid;
1954         char* language;
1955         int ret = VCD_ERROR_OPERATION_FAILED;
1956         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_STRING, &language, DBUS_TYPE_INVALID);
1957
1958         SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD server set language");
1959
1960         if (dbus_error_is_set(&err)) {
1961                 SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd server set language : get arguments error (%s)", err.message);
1962                 dbus_error_free(&err);
1963                 ret = VCD_ERROR_OPERATION_FAILED;
1964         } else {
1965                 SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd server set language : language(%s)", language);
1966                 ret = vcd_server_set_language(language);
1967         }
1968
1969         DBusMessage* reply;
1970         reply = dbus_message_new_method_return(msg);
1971
1972         if (NULL != reply) {
1973                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1974
1975                 if (0 == ret) {
1976                         SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
1977                 } else {
1978                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
1979                 }
1980
1981                 if (!dbus_connection_send(conn, reply, NULL)) {
1982                         SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!");
1983                 }
1984
1985                 dbus_connection_flush(conn);
1986                 dbus_message_unref(reply);
1987         } else {
1988                 SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!");
1989         }
1990
1991         SLOG(LOG_DEBUG, TAG_VCD, "@@@");
1992
1993         return 0;
1994 }