server/vcd_dbus.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 #include <dbus/dbus.h>
  18 #include "vcd_client_data.h"
  19 #include "vcd_dbus.h"
  20 #include "vcd_dbus_server.h"
  21 #include "vcd_main.h"
  22
  23
  24 static DBusConnection* g_conn_sender = NULL;
  25 static DBusConnection* g_conn_listener = NULL;
  26
  27 static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
  28
  29 static int g_waiting_time = 3000;
  30
  31 static int g_volume_count = 0;
  32
  33
  34 static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type)
  35 {
  36         char service_name[64] = {0,};
  37         char object_path[64] = {0,};
  38         char target_if_name[128] = {0,};
  39
  40         if (VCD_CLIENT_TYPE_NORMAL == type) {
  41                 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
  42                 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
  43                 snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_INTERFACE);
  44         } else if (VCD_CLIENT_TYPE_WIDGET == type) {
  45                 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
  46                 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
  47                 snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
  48         } else if (VCD_CLIENT_TYPE_MANAGER == type) {
  49                 snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
  50                 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
  51                 snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
  52         } else {
  53                 return NULL;
  54         }
  55
  56         return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
  57 }
  58
  59 int vcdc_send_hello(int pid, vcd_client_type_e type)
  60 {
  61         DBusMessage* msg = NULL;
  62
  63         if (VCD_CLIENT_TYPE_NORMAL == type) {
  64                 msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL);
  65         } else if (VCD_CLIENT_TYPE_WIDGET == type) {
  66                 msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET);
  67         } else if (VCD_CLIENT_TYPE_MANAGER == type) {
  68                 msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
  69         } else {
  70                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
  71                 return -1;
  72         }
  73
  74         if (NULL == msg) {
  75                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
  76                 return VCD_ERROR_OUT_OF_MEMORY;
  77         }
  78
  79         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  80
  81         DBusError err;
  82         dbus_error_init(&err);
  83
  84         DBusMessage* result_msg;
  85         int result = -1;
  86
  87         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
  88         dbus_message_unref(msg);
  89
  90         if (dbus_error_is_set(&err)) {
  91                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
  92                 if (NULL != err.name) {
  93                         if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
  94                                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
  95                                 dbus_error_free(&err);
  96                                 return 0;
  97                         }
  98                 }
  99                 dbus_error_free(&err);
 100         }
 101
 102         if (NULL != result_msg) {
 103                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 104
 105                 if (dbus_error_is_set(&err)) {
 106                         SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
 107                         dbus_error_free(&err);
 108                         result = VCD_ERROR_OPERATION_FAILED;
 109                 }
 110
 111                 dbus_message_unref(result_msg);
 112         } else {
 113                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
 114         }
 115
 116         return result;
 117 }
 118
 119 int vcdc_send_show_tooltip(int pid, bool show)
 120 {
 121         if (0 > pid) {
 122                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid");
 123                 return -1;
 124         }
 125
 126         char service_name[64] = {0, };
 127         memset(service_name, 0, 64);
 128         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 129
 130         char target_if_name[128] = {0, };
 131         snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
 132
 133         DBusMessage* msg;
 134
 135         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
 136
 137         msg = dbus_message_new_method_call(
 138                           service_name,
 139                           VC_WIDGET_SERVICE_OBJECT_PATH,
 140                           target_if_name,
 141                           VCD_WIDGET_METHOD_SHOW_TOOLTIP);
 142
 143         if (NULL == msg) {
 144                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 145                 return VCD_ERROR_OUT_OF_MEMORY;
 146         }
 147
 148         int temp = (int)show;
 149
 150         DBusMessageIter args;
 151         dbus_message_iter_init_append(msg, &args);
 152
 153         /* Append pid & type */
 154         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &pid);
 155         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
 156
 157         dbus_message_set_no_reply(msg, TRUE);
 158
 159         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 160                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 161                 return VCD_ERROR_OPERATION_FAILED;
 162         } else {
 163                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 164                 dbus_connection_flush(g_conn_sender);
 165         }
 166
 167         dbus_message_unref(msg);
 168
 169         return 0;
 170 }
 171
 172 int vcdc_send_set_volume(int manger_pid, float volume)
 173 {
 174         DBusMessage* msg = NULL;
 175
 176         /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */
 177
 178         msg = dbus_message_new_signal(
 179                 VC_MANAGER_SERVICE_OBJECT_PATH,
 180                 VC_MANAGER_SERVICE_INTERFACE,
 181                 VCD_MANAGER_METHOD_SET_VOLUME);
 182
 183         if (NULL == msg) {
 184                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 185                 return VCD_ERROR_OUT_OF_MEMORY;
 186         }
 187
 188         dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
 189
 190         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 191                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 192                 dbus_message_unref(msg);
 193                 return -1;
 194         } else {
 195                 if (10 == g_volume_count) {
 196                         SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send set volume : pid(%d), volume(%f)", manger_pid, volume);
 197                         g_volume_count = 0;
 198                 }
 199
 200                 dbus_connection_flush(g_conn_sender);
 201
 202                 g_volume_count++;
 203         }
 204
 205         dbus_message_unref(msg);
 206
 207         return 0;
 208 }
 209
 210 int vcdc_send_result(int pid, int manager_pid, int cmd_type)
 211 {
 212         DBusMessage* msg = NULL;
 213
 214         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
 215
 216         switch (cmd_type) {
 217         case VC_COMMAND_TYPE_FOREGROUND:
 218         case VC_COMMAND_TYPE_BACKGROUND:
 219                 if (pid == manager_pid) {
 220                         msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 221                 } else {
 222                         msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL);
 223                 }
 224                 break;
 225         case VC_COMMAND_TYPE_WIDGET:
 226                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, VCD_CLIENT_TYPE_WIDGET);
 227                 break;
 228         case VC_COMMAND_TYPE_SYSTEM:
 229         case VC_COMMAND_TYPE_SYSTEM_BACKGROUND:
 230         case VC_COMMAND_TYPE_EXCLUSIVE:
 231                 msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 232                 break;
 233
 234         default:
 235                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
 236                 return -1;
 237         }
 238
 239         if (NULL == msg) {
 240                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 241                 return VCD_ERROR_OUT_OF_MEMORY;
 242         }
 243
 244         dbus_message_set_no_reply(msg, TRUE);
 245
 246         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 247                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 248                 return VCD_ERROR_OPERATION_FAILED;
 249         } else {
 250                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 251                 dbus_connection_flush(g_conn_sender);
 252         }
 253
 254         dbus_message_unref(msg);
 255
 256         return 0;
 257 }
 258
 259 int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
 260 {
 261         DBusError err;
 262         dbus_error_init(&err);
 263
 264         DBusMessage* msg = NULL;
 265
 266         msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
 267
 268         if (NULL == msg) {
 269                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 270                 return VCD_ERROR_OUT_OF_MEMORY;
 271         }
 272
 273         dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
 274
 275         dbus_message_set_no_reply(msg, TRUE);
 276
 277         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 278                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 279                 return VCD_ERROR_OPERATION_FAILED;
 280         } else {
 281                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 282                 dbus_connection_flush(g_conn_sender);
 283         }
 284
 285         return 0;
 286 }
 287
 288 int vcdc_send_result_to_manager(int manger_pid, int result_type)
 289 {
 290         DBusError err;
 291         dbus_error_init(&err);
 292
 293         DBusMessage* msg = NULL;
 294
 295         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
 296
 297         if (NULL == msg) {
 298                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 299                 return VCD_ERROR_OUT_OF_MEMORY;
 300         }
 301
 302         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
 303
 304         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 305
 306         dbus_message_set_no_reply(msg, TRUE);
 307
 308         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 309                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 310                 return VCD_ERROR_OPERATION_FAILED;
 311         } else {
 312                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 313                 dbus_connection_flush(g_conn_sender);
 314         }
 315
 316         dbus_message_unref(msg);
 317
 318         return 0;
 319 }
 320
 321 int vcdc_send_speech_detected(int manger_pid)
 322 {
 323         DBusError err;
 324         dbus_error_init(&err);
 325
 326         /* Send to manager */
 327         DBusMessage* msg = NULL;
 328
 329         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
 330
 331         if (NULL == msg) {
 332                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 333                 return VCD_ERROR_OUT_OF_MEMORY;
 334         }
 335
 336         dbus_message_set_no_reply(msg, TRUE);
 337
 338         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 339                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 340                 return VCD_ERROR_OPERATION_FAILED;
 341         } else {
 342                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 343                 dbus_connection_flush(g_conn_sender);
 344         }
 345
 346         dbus_message_unref(msg);
 347
 348         return 0;
 349 }
 350
 351 int vcdc_send_service_state(vcd_state_e state)
 352 {
 353         DBusError err;
 354         dbus_error_init(&err);
 355
 356         DBusMessage* msg = NULL;
 357
 358         msg = dbus_message_new_signal(
 359                 VC_MANAGER_SERVICE_OBJECT_PATH,
 360                 VC_MANAGER_SERVICE_INTERFACE,
 361                 VCD_MANAGER_METHOD_SET_SERVICE_STATE);
 362
 363         if (NULL == msg) {
 364                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 365                 return VCD_ERROR_OUT_OF_MEMORY;
 366         }
 367
 368         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 369
 370         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 371                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 372                 return VCD_ERROR_OPERATION_FAILED;
 373         } else {
 374                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to manager : state(%d)", state);
 375                 dbus_connection_flush(g_conn_sender);
 376         }
 377
 378         dbus_message_unref(msg);
 379
 380         /* Send to client */
 381         msg = NULL;
 382
 383         msg = dbus_message_new_signal(
 384                 VC_CLIENT_SERVICE_OBJECT_PATH,
 385                 VC_CLIENT_SERVICE_INTERFACE,
 386                 VCD_METHOD_SET_SERVICE_STATE);
 387
 388         if (NULL == msg) {
 389                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 390                 return VCD_ERROR_OUT_OF_MEMORY;
 391         }
 392
 393         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 394
 395         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 396                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 397                 return VCD_ERROR_OPERATION_FAILED;
 398         } else {
 399                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to client : state(%d)", state);
 400                 dbus_connection_flush(g_conn_sender);
 401         }
 402
 403         dbus_message_unref(msg);
 404
 405         msg = NULL;
 406
 407         /* Send to widget client */
 408         msg = dbus_message_new_signal(
 409                 VC_WIDGET_SERVICE_OBJECT_PATH,
 410                 VC_WIDGET_SERVICE_INTERFACE,
 411                 VCD_WIDGET_METHOD_SET_SERVICE_STATE);
 412
 413         if (NULL == msg) {
 414                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 415                 return VCD_ERROR_OUT_OF_MEMORY;
 416         }
 417
 418         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 419
 420         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 421                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 422                 return VCD_ERROR_OPERATION_FAILED;
 423         } else {
 424                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to widget client : state(%d)", state);
 425                 dbus_connection_flush(g_conn_sender);
 426         }
 427
 428         dbus_message_unref(msg);
 429
 430         return 0;
 431 }
 432
 433 int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
 434 {
 435         DBusError err;
 436         dbus_error_init(&err);
 437
 438         DBusMessage* msg = NULL;
 439
 440         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER);
 441
 442         if (NULL == msg) {
 443                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 444                 return VCD_ERROR_OUT_OF_MEMORY;
 445         }
 446
 447         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
 448
 449         dbus_message_append_args(msg,
 450                                 DBUS_TYPE_INT32, &pid,
 451                                 DBUS_TYPE_STRING, &disp_text,
 452                                 DBUS_TYPE_STRING, &utt_text,
 453                                 DBUS_TYPE_INT32, &continuous,
 454                                 DBUS_TYPE_INVALID);
 455
 456         dbus_message_set_no_reply(msg, TRUE);
 457
 458         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 459                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 460                 return VCD_ERROR_OPERATION_FAILED;
 461         } else {
 462                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 463                 dbus_connection_flush(g_conn_sender);
 464         }
 465
 466         dbus_message_unref(msg);
 467
 468         return 0;
 469 }
 470
 471 int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
 472 {
 473         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal to manager");
 474
 475         if (NULL == err_msg) {
 476                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 477                 return VCD_ERROR_INVALID_PARAMETER;
 478         }
 479
 480         int daemon_pid;
 481         DBusError err;
 482         dbus_error_init(&err);
 483
 484         DBusMessage* msg = NULL;
 485
 486         msg = dbus_message_new_signal(
 487                 VC_MANAGER_SERVICE_OBJECT_PATH,
 488                 VC_MANAGER_SERVICE_INTERFACE,
 489                 VCD_MANAGER_METHOD_ERROR);
 490
 491         if (NULL == msg) {
 492                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 493                 return VCD_ERROR_OUT_OF_MEMORY;
 494         }
 495
 496         daemon_pid = getpid();
 497         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 498
 499         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 500                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 501                 return VCD_ERROR_OPERATION_FAILED;
 502         } else {
 503                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager : reason(%d), Error Msg(%s)", reason, err_msg);
 504                 dbus_connection_flush(g_conn_sender);
 505         }
 506
 507         dbus_message_unref(msg);
 508
 509         return 0;
 510 }
 511
 512 int vcdc_send_error_signal(int reason, char *err_msg)
 513 {
 514         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal");
 515
 516         if (NULL == err_msg) {
 517                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 518                 return VCD_ERROR_INVALID_PARAMETER;
 519         }
 520
 521         int daemon_pid;
 522         DBusError err;
 523         dbus_error_init(&err);
 524
 525         DBusMessage* msg = NULL;
 526
 527         msg = dbus_message_new_signal(
 528                 VC_MANAGER_SERVICE_OBJECT_PATH,
 529                 VC_MANAGER_SERVICE_INTERFACE,
 530                 VCD_MANAGER_METHOD_ERROR);
 531
 532         if (NULL == msg) {
 533                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 534                 return VCD_ERROR_OUT_OF_MEMORY;
 535         }
 536
 537         daemon_pid = getpid();
 538         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 539
 540         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 541                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 542                 return VCD_ERROR_OPERATION_FAILED;
 543         } else {
 544                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 545                 dbus_connection_flush(g_conn_sender);
 546         }
 547
 548         dbus_message_unref(msg);
 549
 550         msg = NULL;
 551         msg = dbus_message_new_signal(
 552                 VC_CLIENT_SERVICE_OBJECT_PATH,
 553                 VC_CLIENT_SERVICE_INTERFACE,
 554                 VCD_METHOD_ERROR);
 555
 556         if (NULL == msg) {
 557                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 558                 return VCD_ERROR_OUT_OF_MEMORY;
 559         }
 560
 561         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 562
 563         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 564                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 565                 return VCD_ERROR_OPERATION_FAILED;
 566         } else {
 567                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 568                 dbus_connection_flush(g_conn_sender);
 569         }
 570
 571         dbus_message_unref(msg);
 572
 573         msg = NULL;
 574         msg = dbus_message_new_signal(
 575                 VC_WIDGET_SERVICE_OBJECT_PATH,
 576                 VC_WIDGET_SERVICE_INTERFACE,
 577                 VCD_WIDGET_METHOD_ERROR);
 578
 579         if (NULL == msg) {
 580                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 581                 return VCD_ERROR_OUT_OF_MEMORY;
 582         }
 583
 584         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 585
 586         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 587                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 588                 return VCD_ERROR_OPERATION_FAILED;
 589         } else {
 590                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 591                 dbus_connection_flush(g_conn_sender);
 592         }
 593
 594         dbus_message_unref(msg);
 595
 596         return 0;
 597 }
 598
 599 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 600 {
 601         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 602
 603         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 604
 605         while (1) {
 606                 DBusMessage* msg = NULL;
 607                 msg = dbus_connection_pop_message(g_conn_listener);
 608
 609                 /* loop again if we haven't read a message */
 610                 if (NULL == msg) {
 611                         break;
 612                 }
 613
 614                 /* Common event */
 615                 if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
 616                         vcd_dbus_server_hello(g_conn_listener, msg);
 617
 618                 /* manager event */
 619                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
 620                         vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
 621
 622                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
 623                         vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
 624
 625                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
 626                         vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
 627
 628                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
 629                         vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
 630
 631                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
 632                         vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
 633
 634                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
 635                         vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
 636
 637                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
 638                         vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
 639
 640                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
 641                         vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
 642
 643                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA))
 644                         vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg);
 645
 646                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA))
 647                         vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg);
 648
 649                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
 650                         vcd_dbus_server_mgr_start(g_conn_listener, msg);
 651
 652                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
 653                         vcd_dbus_server_mgr_stop(g_conn_listener, msg);
 654
 655                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
 656                         vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
 657
 658                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
 659                         vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
 660
 661                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN))
 662                         vcd_dbus_server_mgr_set_domain(g_conn_listener, msg);
 663
 664                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION))
 665                         vcd_dbus_server_mgr_do_action(g_conn_listener, msg);
 666
 667                 /* client event */
 668                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
 669                         vcd_dbus_server_initialize(g_conn_listener, msg);
 670
 671                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
 672                         vcd_dbus_server_finalize(g_conn_listener, msg);
 673 #if 0
 674                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
 675                         vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
 676 #endif
 677                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
 678                         vcd_dbus_server_set_command(g_conn_listener, msg);
 679
 680                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
 681                         vcd_dbus_server_unset_command(g_conn_listener, msg);
 682
 683                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
 684                         vcd_dbus_server_set_foreground(g_conn_listener, msg);
 685
 686                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_DIALOG))
 687                         vcd_dbus_server_dialog(g_conn_listener, msg);
 688
 689                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_IS_SYS_COMMAND_VALID))
 690                         vcd_dbus_server_is_system_command_valid(g_conn_listener, msg);
 691
 692 #if 0
 693                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
 694                         vcd_dbus_server_start_request(g_conn_listener, msg);
 695
 696                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
 697                         vcd_dbus_server_stop_request(g_conn_listener, msg);
 698
 699                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
 700                         vcd_dbus_server_cancel_request(g_conn_listener, msg);
 701 #endif
 702                 /* widget event */
 703                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
 704                         vcd_dbus_server_widget_initialize(g_conn_listener, msg);
 705
 706                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
 707                         vcd_dbus_server_widget_finalize(g_conn_listener, msg);
 708
 709                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
 710                         vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
 711
 712                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
 713                         vcd_dbus_server_widget_start(g_conn_listener, msg);
 714
 715                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
 716                         vcd_dbus_server_widget_stop(g_conn_listener, msg);
 717
 718                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
 719                         vcd_dbus_server_widget_cancel(g_conn_listener, msg);
 720
 721                 else {
 722                         SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
 723                         dbus_message_unref(msg);
 724                         break;
 725                 }
 726
 727                 /* free the message */
 728                 dbus_message_unref(msg);
 729         }
 730
 731         return ECORE_CALLBACK_RENEW;
 732 }
 733
 734 int vcd_dbus_open_connection()
 735 {
 736         DBusError err;
 737         dbus_error_init(&err);
 738
 739         int ret;
 740
 741         /* Create connection for sender */
 742         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 743
 744         if (dbus_error_is_set(&err)) {
 745                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 746                 dbus_error_free(&err);
 747         }
 748
 749         if (NULL == g_conn_sender) {
 750                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 751                 return VCD_ERROR_OPERATION_FAILED;
 752         }
 753
 754         /* connect to the bus and check for errors */
 755         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 756
 757         if (dbus_error_is_set(&err)) {
 758                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 759                 dbus_error_free(&err);
 760         }
 761
 762         if (NULL == g_conn_listener) {
 763                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 764                 return VCD_ERROR_OPERATION_FAILED;
 765         }
 766
 767         /* request our name on the bus and check for errors */
 768         ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 769
 770         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 771                 printf("Fail to be primary owner in dbus request.");
 772                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
 773                 return VCD_ERROR_OPERATION_FAILED;
 774         }
 775
 776         if (dbus_error_is_set(&err)) {
 777                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
 778                 dbus_error_free(&err);
 779                 return VCD_ERROR_OPERATION_FAILED;
 780         }
 781
 782         /* add a rule for getting signal */
 783         char rule[128];
 784         snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
 785
 786         /* add a rule for which messages we want to see */
 787         dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
 788         dbus_connection_flush(g_conn_listener);
 789
 790         if (dbus_error_is_set(&err)) {
 791                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
 792                 dbus_error_free(&err);
 793                 return VCD_ERROR_OPERATION_FAILED;
 794         }
 795
 796         int fd = 0;
 797         dbus_connection_get_unix_fd(g_conn_listener, &fd);
 798
 799         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 800
 801         if (NULL == g_dbus_fd_handler) {
 802                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
 803                 return VCD_ERROR_OPERATION_FAILED;
 804         }
 805
 806         return 0;
 807 }
 808
 809 int vcd_dbus_close_connection()
 810 {
 811         DBusError err;
 812         dbus_error_init(&err);
 813
 814         if (NULL != g_dbus_fd_handler) {
 815                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 816                 g_dbus_fd_handler = NULL;
 817         }
 818
 819         dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
 820
 821         if (dbus_error_is_set(&err)) {
 822                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
 823                 dbus_error_free(&err);
 824         }
 825
 826         dbus_connection_close(g_conn_listener);
 827         dbus_connection_close(g_conn_sender);
 828
 829         dbus_connection_unref(g_conn_listener);
 830         dbus_connection_unref(g_conn_sender);
 831
 832         g_conn_listener = NULL;
 833         g_conn_sender = NULL;
 834
 835         return 0;
 836 }