src/notification_ipc.c

   1 /*
   2  *  libnotification
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungtaek Chung <seungtaek.chung@samsung.com>, Mi-Ju Lee <miju52.lee@samsung.com>, Xi Zhichan <zhichan.xi@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <vconf.h>
  27 #include <bundle_internal.h>
  28
  29 #include <notification_ipc.h>
  30 #include <notification_db.h>
  31 #include <notification_type.h>
  32 #include <notification_private.h>
  33 #include <notification_debug.h>
  34 #include <notification_setting.h>
  35 #include <notification_setting_internal.h>
  36 #include <notification_internal.h>
  37
  38 #include <gio/gio.h>
  39
  40 #define PROVIDER_BUS_NAME "org.tizen.data_provider_service"
  41 #define PROVIDER_OBJECT_PATH "/org/tizen/data_provider_service"
  42 #define PROVIDER_NOTI_INTERFACE_NAME "org.tizen.data_provider_noti_service"
  43
  44 #define DBUS_SERVICE_DBUS "org.freedesktop.DBus"
  45 #define DBUS_PATH_DBUS "/org/freedesktop/DBus"
  46 #define DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
  47
  48 static const gchar *_bus_name = NULL;
  49 static GDBusConnection *_gdbus_conn = NULL;
  50 static int monitor_id = 0;
  51 static int provider_monitor_id = 0;
  52 static int is_master_started = 0;
  53
  54 static const char *NOTI_DATA_STRING[] = {
  55     "NOTIFICATION_DATA_TYPE_NOTI_TYPE",
  56     "NOTIFICATION_DATA_TYPE_LAYOUT",
  57     "NOTIFICATION_DATA_TYPE_GROUP_ID",
  58     "NOTIFICATION_DATA_TYPE_INTERNAL_GROUP_ID",
  59     "NOTIFICATION_DATA_TYPE_PRIV_ID",
  60     "NOTIFICATION_DATA_TYPE_CALLER_PKGNAME",
  61     "NOTIFICATION_DATA_TYPE_LAUNCH_PKGNAME",
  62     "NOTIFICATION_DATA_TYPE_ARGS",
  63     "NOTIFICATION_DATA_TYPE_GROUP_ARGS",
  64     "NOTIFICATION_DATA_TYPE_EXECUTE_OPTION",
  65     "NOTIFICATION_DATA_TYPE_SERVICE_RESPONDING",
  66     "NOTIFICATION_DATA_TYPE_SERVICE_SINGLE_LAUNCH",
  67     "NOTIFICATION_DATA_TYPE_SERVICE_MULTI_LAUNCH",
  68     "NOTIFICATION_DATA_TYPE_BUTTON1_EVENT",
  69     "NOTIFICATION_DATA_TYPE_BUTTON2_EVENT",
  70     "NOTIFICATION_DATA_TYPE_BUTTON3_EVENT",
  71     "NOTIFICATION_DATA_TYPE_BUTTON4_EVENT",
  72     "NOTIFICATION_DATA_TYPE_BUTTON5_EVENT",
  73     "NOTIFICATION_DATA_TYPE_BUTTON6_EVENT",
  74     "NOTIFICATION_DATA_TYPE_ICON_EVENT",
  75     "NOTIFICATION_DATA_TYPE_THUMBNAIL_EVENT",
  76     "NOTIFICATION_DATA_TYPE_DOMAIN",
  77     "NOTIFICATION_DATA_TYPE_DIR",
  78     "NOTIFICATION_DATA_TYPE_TEXT",
  79     "NOTIFICATION_DATA_TYPE_KEY",
  80     "NOTIFICATION_DATA_TYPE_FORMAT_ARGS",
  81     "NOTIFICATION_DATA_TYPE_NUM_FORMAT_ARGS",
  82     "NOTIFICATION_DATA_TYPE_IMAGE_PATH",
  83     "NOTIFICATION_DATA_TYPE_SOUND_TYPE",
  84     "NOTIFICATION_DATA_TYPE_SOUND_PATH",
  85     "NOTIFICATION_DATA_TYPE_VIBRATION_TYPE",
  86     "NOTIFICATION_DATA_TYPE_VIBRATION_PATH",
  87     "NOTIFICATION_DATA_TYPE_LED_OPERATION",
  88     "NOTIFICATION_DATA_TYPE_LED_ARGB",
  89     "NOTIFICATION_DATA_TYPE_LED_ON_MS",
  90     "NOTIFICATION_DATA_TYPE_LED_OFF_MS",
  91     "NOTIFICATION_DATA_TYPE_TIME",
  92     "NOTIFICATION_DATA_TYPE_INSERT_TIME",
  93     "NOTIFICATION_DATA_TYPE_FLAGS_FOR_PROPERTY",
  94     "NOTIFICATION_DATA_TYPE_DISPLAY_APPLIST",
  95     "NOTIFICATION_DATA_TYPE_PROGRESS_SIZE",
  96     "NOTIFICATION_DATA_TYPE_PROGRESS_PERCENTAGE",
  97     "NOTIFICATION_DATA_TYPE_APP_ICON_PATH",
  98     "NOTIFICATION_DATA_TYPE_APP_NAME",
  99     "NOTIFICATION_DATA_TYPE_TEMP_TITLE",
 100     "NOTIFICATION_DATA_TYPE_TEMP_CONTENT",
 101     "NOTIFICATION_DATA_TYPE_TAG",
 102     "NOTIFICATION_DATA_TYPE_ONGOING_FLAG",
 103     "NOTIFICATION_DATA_TYPE_AUTO_REMOVE",
 104 };
 105
 106
 107 typedef struct _result_cb_item {
 108         void (*result_cb)(int priv_id, int result, void *data);
 109         void *data;
 110 } result_cb_item;
 111
 112 typedef struct _task_list task_list;
 113 struct _task_list {
 114         task_list *prev;
 115         task_list *next;
 116
 117         void (*task_cb) (void *data);
 118         void *data;
 119 };
 120
 121 static task_list *g_task_list;
 122
 123 static int _ipc_monitor_register(void);
 124 static int _ipc_monitor_deregister(void);
 125 static void _do_deffered_task(void);
 126
 127 static void _print_noti(notification_h noti) {
 128         char *pkgname = NULL;
 129         char *text = NULL;
 130         char *content = NULL;
 131         const char *tag = NULL;
 132
 133         notification_get_pkgname(noti, &pkgname);
 134         notification_get_text(noti, NOTIFICATION_TEXT_TYPE_TITLE, &text);
 135         notification_get_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT, &content);
 136         notification_get_tag(noti, &tag);
 137
 138         NOTIFICATION_DBG("client print_noti  pkgname  = %s ", pkgname );
 139         NOTIFICATION_DBG("client print_noti  title  = %s ", text );
 140         NOTIFICATION_DBG("client print_noti  content  = %s ", content );
 141         NOTIFICATION_DBG("client print_noti  tag  = %s ", tag );
 142         NOTIFICATION_DBG("client print_noti  priv_id  = %d ", noti->priv_id);
 143         NOTIFICATION_DBG("client print_noti  vibration_path  = %s ", noti->vibration_path);
 144 }
 145
 146 static inline char *_string_get(char *string)
 147 {
 148         if (string == NULL)
 149                 return NULL;
 150
 151         if (string[0] == '\0')
 152                 return NULL;
 153
 154         return string;
 155 }
 156
 157
 158 int notification_ipc_is_master_ready(void)
 159 {
 160         GVariant *result;
 161         GError *err = NULL;
 162         gboolean name_exist;
 163
 164         result = g_dbus_connection_call_sync(
 165                         _gdbus_conn,
 166                         DBUS_SERVICE_DBUS,
 167                         DBUS_PATH_DBUS,
 168                         DBUS_INTERFACE_DBUS,
 169                         "NameHasOwner",
 170                         g_variant_new("(s)", PROVIDER_BUS_NAME),
 171                         G_VARIANT_TYPE("(b)"),
 172                         G_DBUS_CALL_FLAGS_NONE,
 173                         -1,
 174                         NULL,
 175                         &err);
 176
 177         if (err || (result == NULL)) {
 178                 if (err) {
 179                 NOTIFICATION_ERR("No reply. error = %s", err->message);
 180                         g_error_free(err);
 181                 }
 182                 is_master_started = 0;
 183         } else {
 184                 g_variant_get(result, "(b)", &name_exist);
 185
 186                 if (!name_exist) {
 187                         NOTIFICATION_ERR("Name not exist %s", PROVIDER_BUS_NAME);
 188                         NOTIFICATION_ERR("the master has been stopped");
 189                         is_master_started = 0;
 190                 } else {
 191                         NOTIFICATION_DBG("the master has been started");
 192                         is_master_started = 1;
 193                 }
 194         }
 195
 196         if(result)
 197                 g_variant_unref(result);
 198
 199         return is_master_started;
 200 }
 201
 202 /* TODO: dbus activation isn't enough ? */
 203 /*
 204  * store tasks when daemon stopped
 205  */
 206 int notification_ipc_add_deffered_task(
 207                 void (*deferred_task_cb)(void *data),
 208                 void *user_data)
 209 {
 210         task_list *list;
 211         task_list *list_new;
 212
 213         list_new =
 214             (task_list *) malloc(sizeof(task_list));
 215
 216         if (list_new == NULL)
 217                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 218
 219         list_new->next = NULL;
 220         list_new->prev = NULL;
 221
 222         list_new->task_cb = deferred_task_cb;
 223         list_new->data = user_data;
 224
 225         if (g_task_list == NULL) {
 226                 g_task_list = list_new;
 227         } else {
 228                 list = g_task_list;
 229
 230                 while (list->next != NULL)
 231                         list = list->next;
 232
 233                 list->next = list_new;
 234                 list_new->prev = list;
 235         }
 236         return NOTIFICATION_ERROR_NONE;
 237 }
 238
 239 int notification_ipc_del_deffered_task(
 240                 void (*deferred_task_cb)(void *data))
 241 {
 242         task_list *list_del;
 243         task_list *list_prev;
 244         task_list *list_next;
 245
 246         list_del = g_task_list;
 247
 248         if (list_del == NULL)
 249                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
 250
 251         while (list_del->prev != NULL)
 252                 list_del = list_del->prev;
 253
 254         do {
 255                 if (list_del->task_cb == deferred_task_cb) {
 256                         list_prev = list_del->prev;
 257                         list_next = list_del->next;
 258
 259                         if (list_prev == NULL)
 260                                 g_task_list = list_next;
 261                         else
 262                                 list_prev->next = list_next;
 263
 264                         if (list_next == NULL) {
 265                                 if (list_prev != NULL)
 266                                         list_prev->next = NULL;
 267                         } else {
 268                                 list_next->prev = list_prev;
 269                         }
 270
 271                         free(list_del);
 272                         return NOTIFICATION_ERROR_NONE;
 273                 }
 274                 list_del = list_del->next;
 275         } while (list_del != NULL);
 276
 277         return NOTIFICATION_ERROR_INVALID_PARAMETER;
 278 }
 279
 280 static void _do_deffered_task(void)
 281 {
 282         task_list *list_do;
 283         task_list *list_temp;
 284
 285         if (g_task_list == NULL)
 286                 return;
 287
 288         list_do = g_task_list;
 289         g_task_list = NULL;
 290
 291         while (list_do->prev != NULL)
 292                 list_do = list_do->prev;
 293
 294         while (list_do != NULL) {
 295                 if (list_do->task_cb != NULL) {
 296                         list_do->task_cb(list_do->data);
 297                         NOTIFICATION_DBG("called:%p", list_do->task_cb);
 298                 }
 299                 list_temp = list_do->next;
 300                 free(list_do);
 301                 list_do = list_temp;
 302         }
 303 }
 304
 305 /*!
 306  * functions to create operation list
 307  */
 308 static notification_op *_ipc_create_op(notification_op_type_e type,
 309                 int num_op, int *list_priv_id, int num_priv_id, notification_h *noti_list)
 310 {
 311         int i;
 312         notification_op *op_list;
 313
 314         if (num_op <= 0)
 315                 return NULL;
 316
 317         op_list = (notification_op *)malloc(sizeof(notification_op) * num_op);
 318
 319         if (op_list == NULL) {
 320                 NOTIFICATION_ERR("malloc failed");
 321                 return NULL;
 322         }
 323
 324         memset(op_list, 0x0, sizeof(notification_op) * num_op);
 325
 326         for (i = 0; i < num_op; i++) {
 327                 (op_list + i)->type = type;
 328                 if (list_priv_id != NULL)
 329                         (op_list + i)->priv_id = *(list_priv_id + i);
 330                 if (noti_list != NULL)
 331                         (op_list + i)->noti = *(noti_list + i);
 332         }
 333
 334         return op_list;
 335 }
 336
 337 /*!
 338  * utility functions creating notification packet
 339  */
 340 static inline char *_dup_string(const char *string)
 341 {
 342         char *ret;
 343
 344         if (string == NULL)
 345                 return NULL;
 346         if (string[0] == '\0')
 347                 return NULL;
 348
 349         ret = strdup(string);
 350         if (!ret)
 351                 NOTIFICATION_ERR("Error: %s\n", strerror(errno));
 352
 353         return ret;
 354 }
 355
 356 static inline bundle *_create_bundle_from_bundle_raw(bundle_raw *string)
 357 {
 358         if (string == NULL)
 359                 return NULL;
 360         if (string[0] == '\0')
 361                 return NULL;
 362
 363         return bundle_decode(string, strlen((char *)string));
 364 }
 365
 366 static void _add_noti_notify(GVariant *parameters)
 367 {
 368         notification_h noti;
 369         notification_op *noti_op;
 370         GVariant *body = NULL;
 371
 372         NOTIFICATION_DBG("add noti notify");
 373         noti = notification_create(NOTIFICATION_TYPE_NOTI);
 374         if (!noti) {
 375                 NOTIFICATION_ERR("failed to create a notification");
 376                 return;
 377         }
 378
 379         g_variant_get(parameters, "(v)", &body);
 380         notification_ipc_make_noti_from_gvariant(noti, body);
 381         _print_noti(noti);
 382         if (noti->flags_for_property & NOTIFICATION_PROP_DISABLE_UPDATE_ON_INSERT) {
 383                 NOTIFICATION_ERR("disable changed callback %d", noti->flags_for_property);
 384                 /* Disable changed cb */
 385         } else {
 386                 /* Enable changed cb */
 387                 noti_op = _ipc_create_op(NOTIFICATION_OP_INSERT, 1, &(noti->priv_id), 1, &noti);
 388
 389                 if (noti_op != NULL) {
 390                         notification_call_changed_cb(noti_op, 1);
 391                         free(noti_op);
 392                 }
 393         }
 394         notification_free(noti);
 395 }
 396
 397 static void _update_noti_notify(GVariant *parameters)
 398 {
 399         notification_h noti;
 400         notification_op *noti_op;
 401         GVariant *body = NULL;
 402
 403         noti = notification_create(NOTIFICATION_TYPE_NOTI);
 404         if (!noti) {
 405                 NOTIFICATION_ERR("failed to create a notification");
 406                 return;
 407         }
 408         g_variant_get(parameters, "(v)", &body);
 409         notification_ipc_make_noti_from_gvariant(noti, body);
 410         _print_noti(noti);
 411
 412         noti_op = _ipc_create_op(NOTIFICATION_OP_UPDATE, 1, &(noti->priv_id), 1, &noti);
 413         if (noti_op != NULL) {
 414                 notification_call_changed_cb(noti_op, 1);
 415                 free(noti_op);
 416         }
 417         notification_free(noti);
 418 }
 419
 420 static void _refresh_noti_notify(GVariant *parameters)
 421 {
 422         notification_op *noti_op = _ipc_create_op(NOTIFICATION_OP_REFRESH, 1, NULL, 0, NULL);
 423
 424         if (noti_op != NULL) {
 425                 notification_call_changed_cb(noti_op, 1);
 426                 free(noti_op);
 427         }
 428 }
 429
 430 static void _delete_single_notify(GVariant *parameters)
 431 {
 432         int num_deleted;
 433         int priv_id;
 434         notification_op *noti_op;
 435
 436         /* num_deleted ?? */
 437         g_variant_get(parameters, "(ii)", &num_deleted, &priv_id);
 438
 439         noti_op = _ipc_create_op(NOTIFICATION_OP_DELETE, 1, &priv_id, 1, NULL);
 440         if (noti_op != NULL) {
 441                 notification_call_changed_cb(noti_op, 1);
 442                 free(noti_op);
 443         }
 444 }
 445
 446 static void _delete_multiple_notify(GVariant *parameters)
 447 {
 448         int buf[100] = {0,};
 449         int idx = 0;
 450         notification_op *noti_op;
 451         GVariantIter *iter;
 452
 453         g_variant_get(parameters, "(a(i))", &iter);
 454         while (g_variant_iter_loop(iter, "(i)", &buf[idx])) {
 455                 NOTIFICATION_DBG("delete_noti_multiple priv_id : %d", buf[idx]);
 456                 idx++;
 457         }
 458         g_variant_iter_free(iter);
 459
 460         NOTIFICATION_DBG("data num deleted:%d", idx);
 461         noti_op = _ipc_create_op(NOTIFICATION_OP_DELETE, idx, buf, idx, NULL);
 462
 463         if (noti_op == NULL) {
 464                 NOTIFICATION_ERR("_ipc_create_op failed");
 465                 return;
 466         }
 467         notification_call_changed_cb(noti_op, idx);
 468         free(noti_op);
 469 }
 470
 471 static void _handle_noti_notify(GDBusConnection *connection,
 472                 const gchar     *sender_name,
 473                 const gchar     *object_path,
 474                 const gchar     *interface_name,
 475                 const gchar     *signal_name,
 476                 GVariant        *parameters,
 477                 gpointer         user_data)
 478 {
 479         NOTIFICATION_DBG("signal_name: %s", signal_name);
 480
 481         if (g_strcmp0(signal_name, "add_noti_notify") == 0)
 482                 _add_noti_notify(parameters);
 483         else if (g_strcmp0(signal_name, "update_noti_notify") == 0)
 484                 _update_noti_notify(parameters);
 485         else if (g_strcmp0(signal_name, "delete_single_notify") == 0)
 486                 _delete_single_notify(parameters);
 487         else if (g_strcmp0(signal_name, "delete_multiple_notify") == 0)
 488                 _delete_multiple_notify(parameters);
 489         else if (g_strcmp0(signal_name, "refresh_noti_notify") == 0)
 490                 _refresh_noti_notify(parameters);
 491 }
 492
 493
 494 static int _dbus_signal_init()
 495 {
 496         int id;
 497         int ret = NOTIFICATION_ERROR_NONE;
 498
 499         if (monitor_id == 0) {
 500                 id = g_dbus_connection_signal_subscribe(_gdbus_conn,
 501                                 PROVIDER_BUS_NAME,
 502                                 PROVIDER_NOTI_INTERFACE_NAME,   /*      interface */
 503                                 NULL,                           /*      member */
 504                                 PROVIDER_OBJECT_PATH,           /*      path */
 505                                 NULL,                           /*      arg0 */
 506                                 G_DBUS_SIGNAL_FLAGS_NONE,
 507                                 _handle_noti_notify,
 508                                 NULL,
 509                                 NULL);
 510
 511                 NOTIFICATION_DBG("subscribe id : %d", id);
 512                 if (id == 0) {
 513                         ret = NOTIFICATION_ERROR_IO_ERROR;
 514                         NOTIFICATION_ERR("Failed to _register_noti_dbus_interface");
 515                 } else {
 516                         monitor_id = id;
 517                         ret = NOTIFICATION_ERROR_NONE;
 518                 }
 519         }
 520         return ret;
 521 }
 522
 523
 524 static int _dbus_init()
 525 {
 526         int ret = NOTIFICATION_ERROR_NONE;
 527         GError *error = NULL;
 528
 529         if (_gdbus_conn == NULL) {
 530                 _gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 531
 532                 if (_gdbus_conn == NULL) {
 533                         if (error != NULL) {
 534                                 NOTIFICATION_ERR("Failed to get dbus [%s]", error->message);
 535                                 g_error_free(error);
 536                         }
 537                         return NOTIFICATION_ERROR_IO_ERROR;
 538                 }
 539                 _bus_name = g_dbus_connection_get_unique_name(_gdbus_conn);
 540                 NOTIFICATION_DBG("bus name : %s", _bus_name);
 541
 542                 notification_error_quark();
 543
 544                 ret = NOTIFICATION_ERROR_NONE;
 545         }
 546         return ret;
 547 }
 548
 549 static int _send_sync_noti(GVariant *body, GDBusMessage **reply, char *cmd)
 550 {
 551         int ret = NOTIFICATION_ERROR_NONE;
 552         GError *err = NULL;
 553         GDBusMessage *msg;
 554
 555         msg = g_dbus_message_new_method_call(
 556                         PROVIDER_BUS_NAME,
 557                         PROVIDER_OBJECT_PATH,
 558                         PROVIDER_NOTI_INTERFACE_NAME,
 559                         cmd);
 560         if (!msg) {
 561                 NOTIFICATION_ERR("Can't allocate new method call");
 562                 if (body)
 563                         g_variant_unref(body);
 564                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 565         }
 566
 567         if (body != NULL)
 568                 g_dbus_message_set_body(msg, body);
 569
 570         *reply = g_dbus_connection_send_message_with_reply_sync(
 571                         _gdbus_conn,
 572                         msg,
 573                         G_DBUS_SEND_MESSAGE_FLAGS_NONE,
 574                         -1,
 575                         NULL,
 576                         NULL,
 577                         &err);
 578
 579         g_object_unref(msg);
 580
 581         if (!*reply) {
 582                 if (err != NULL) {
 583                         NOTIFICATION_ERR("No reply. cmd = %s,  error = %s", cmd, err->message);
 584                         g_error_free(err);
 585                 }
 586                 return NOTIFICATION_ERROR_SERVICE_NOT_READY;
 587         }
 588
 589         if (g_dbus_message_to_gerror(*reply, &err)) {
 590                 ret = err->code;
 591                 NOTIFICATION_ERR("_send_sync_noti cmd = %s, error %s", cmd, err->message);
 592                 g_error_free(err);
 593                 return ret;
 594         }
 595         NOTIFICATION_DBG("_send_sync_noti done !!");
 596         return NOTIFICATION_ERROR_NONE;
 597
 598 }
 599
 600 static void _send_message_with_reply_async_cb(GDBusConnection *connection,
 601                 GAsyncResult *res,
 602                 gpointer user_data)
 603 {
 604         GVariant *body;
 605         int result = NOTIFICATION_ERROR_NONE;
 606         int priv_id;
 607         GDBusMessage *reply = NULL;
 608         GError *err = NULL;
 609         result_cb_item *cb_item = (result_cb_item *)user_data;
 610
 611         if (cb_item == NULL) {
 612                 NOTIFICATION_ERR("Failed to get a callback item");
 613                 return;
 614         }
 615
 616         reply = g_dbus_connection_send_message_with_reply_finish(
 617                         connection,
 618                         res,
 619                         &err);
 620
 621         if (!reply) {
 622                 if (err != NULL) {
 623                         NOTIFICATION_ERR("No reply. error = %s", err->message);
 624                         g_error_free(err);
 625                 }
 626                 result = NOTIFICATION_ERROR_SERVICE_NOT_READY;
 627
 628         } else if (g_dbus_message_to_gerror(reply, &err)) {
 629                 result = err->code;
 630                 g_error_free(err);
 631                 NOTIFICATION_ERR("_send_async_noti error %s", err->message);
 632         }
 633
 634         NOTIFICATION_DBG("_send_async_noti done !![%d]", result);
 635
 636         if (result == NOTIFICATION_ERROR_NONE) {
 637                 body = g_dbus_message_get_body(reply);
 638                 g_variant_get(body, "(i)", &priv_id);
 639
 640                 if (cb_item->result_cb)
 641                         cb_item->result_cb(priv_id, result, cb_item->data);
 642
 643         } else {
 644                 if (cb_item->result_cb)
 645                         cb_item->result_cb(NOTIFICATION_PRIV_ID_NONE, result, cb_item->data);
 646         }
 647
 648         if (reply)
 649                 g_object_unref(reply);
 650         free(cb_item);
 651 }
 652
 653 static int _send_async_noti(GVariant *body, result_cb_item *cb_item, char *cmd)
 654 {
 655         GDBusMessage *msg;
 656
 657         msg = g_dbus_message_new_method_call(
 658                         PROVIDER_BUS_NAME,
 659                         PROVIDER_OBJECT_PATH,
 660                         PROVIDER_NOTI_INTERFACE_NAME,
 661                         cmd);
 662         if (!msg) {
 663                 NOTIFICATION_ERR("Can't allocate new method call");
 664                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 665         }
 666
 667         if (body != NULL)
 668                 g_dbus_message_set_body(msg, body);
 669
 670         g_dbus_connection_send_message_with_reply(
 671                         _gdbus_conn,
 672                         msg,
 673                         G_DBUS_SEND_MESSAGE_FLAGS_NONE,
 674                         -1,
 675                         NULL,
 676                         NULL,
 677                         (GAsyncReadyCallback)_send_message_with_reply_async_cb,
 678                         cb_item);
 679
 680         NOTIFICATION_DBG("_send_async_noti done !!");
 681
 682         g_object_unref(msg);
 683         return NOTIFICATION_ERROR_NONE;
 684 }
 685
 686 int notification_ipc_request_insert(notification_h noti, int *priv_id)
 687 {
 688         int result;
 689         int id;
 690         GDBusMessage *reply = NULL;
 691         GVariant *body;
 692         GVariant *reply_body;
 693
 694         result = _dbus_init();
 695         if (result != NOTIFICATION_ERROR_NONE) {
 696                 NOTIFICATION_ERR("Can't init dbus %d", result);
 697                 return result;
 698         }
 699
 700         /* Initialize private ID */
 701         noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
 702         noti->group_id = NOTIFICATION_GROUP_ID_NONE;
 703         noti->internal_group_id = NOTIFICATION_GROUP_ID_NONE;
 704
 705         _print_noti(noti);
 706         body = notification_ipc_make_gvariant_from_noti(noti);
 707         if (body == NULL) {
 708                 NOTIFICATION_ERR("cannot make gvariant");
 709                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 710         }
 711
 712         result = _send_sync_noti(body, &reply, "add_noti");
 713         NOTIFICATION_DBG("_send_sync_noti %d", result);
 714
 715         if (result == NOTIFICATION_ERROR_NONE) {
 716                 reply_body = g_dbus_message_get_body(reply);
 717                 g_variant_get(reply_body, "(i)", &id);
 718
 719                 if (priv_id != NULL)
 720                         *priv_id = id;
 721         }
 722
 723         if(reply)
 724                 g_object_unref(reply);
 725
 726         NOTIFICATION_DBG("notification_ipc_request_insert done [priv_id : %d, result: %d]", *priv_id, result);
 727         return result;
 728 }
 729
 730 int notification_ipc_request_update(notification_h noti)
 731 {
 732         int result;
 733         int priv_id;
 734
 735         GDBusMessage *reply = NULL;
 736         GVariant *body;
 737         GVariant *reply_body;
 738
 739         result = _dbus_init();
 740         if (result != NOTIFICATION_ERROR_NONE) {
 741                 NOTIFICATION_ERR("Can't init dbus %d", result);
 742                 return result;
 743         }
 744
 745         body = notification_ipc_make_gvariant_from_noti(noti);
 746         if (body == NULL) {
 747                 NOTIFICATION_ERR("cannot make gvariant");
 748                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 749         }
 750
 751         result = _send_sync_noti(body, &reply, "update_noti");
 752         if (result == NOTIFICATION_ERROR_NONE) {
 753                 reply_body = g_dbus_message_get_body(reply);
 754                 g_variant_get(reply_body, "(i)", &priv_id);
 755         }
 756
 757         if(reply)
 758                 g_object_unref(reply);
 759
 760         NOTIFICATION_DBG("notification_ipc_request_update done [result: %d, priv_id :%d]", result, priv_id);
 761         return result;
 762 }
 763
 764 int notification_ipc_request_update_async(notification_h noti,
 765                 void (*result_cb)(int priv_id, int result, void *data), void *user_data)
 766 {
 767         int result;
 768         result_cb_item *cb_item;
 769         GVariant *body;
 770
 771         result = _dbus_init();
 772         if (result != NOTIFICATION_ERROR_NONE) {
 773                 NOTIFICATION_ERR("Can't init dbus %d", result);
 774                 return result;
 775         }
 776
 777         cb_item = calloc(1, sizeof(result_cb_item));
 778         if (cb_item == NULL)
 779                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 780
 781         cb_item->result_cb = result_cb;
 782         cb_item->data = user_data;
 783
 784         body = notification_ipc_make_gvariant_from_noti(noti);
 785         if (body == NULL) {
 786                 NOTIFICATION_ERR("cannot make gvariant");
 787                 free(cb_item);
 788                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 789         }
 790
 791         result = _send_async_noti(body, cb_item, "update_noti");
 792         NOTIFICATION_DBG("notification_ipc_request_update_async done [result: %d]", result);
 793
 794         if (result != NOTIFICATION_ERROR_NONE) {
 795                 free(cb_item);
 796                 cb_item = NULL;
 797         }
 798
 799         g_variant_unref(body);
 800
 801         return result;
 802 }
 803
 804 int notification_ipc_request_refresh(void)
 805 {
 806         int result;
 807         GDBusMessage *reply = NULL;
 808         GVariant *body;
 809
 810         result = _dbus_init();
 811         if (result != NOTIFICATION_ERROR_NONE) {
 812                 NOTIFICATION_ERR("Can't init dbus %d", result);
 813                 return result;
 814         }
 815
 816         body = g_variant_new("(i)", NOTIFICATION_OP_REFRESH);
 817         result = _send_sync_noti(body, &reply, "refresh_noti");
 818
 819         if(reply)
 820                 g_object_unref(reply);
 821
 822         NOTIFICATION_ERR("notification_ipc_request_refresh done [result: %d]", result);
 823         return result;
 824 }
 825
 826 int notification_ipc_request_delete_single(notification_type_e type, char *pkgname, int priv_id)
 827 {
 828         int result;
 829         int id;
 830         GDBusMessage *reply = NULL;
 831         GVariant *body;
 832         GVariant *reply_body;
 833
 834         result = _dbus_init();
 835         if (result != NOTIFICATION_ERROR_NONE) {
 836                 NOTIFICATION_ERR("Can't init dbus %d", result);
 837                 return result;
 838         }
 839
 840         body = g_variant_new("(si)", pkgname, priv_id);
 841         result = _send_sync_noti(body, &reply, "del_noti_single");
 842
 843         if (result == NOTIFICATION_ERROR_NONE) {
 844                 reply_body = g_dbus_message_get_body(reply);
 845                 g_variant_get(reply_body, "(i)", &id);
 846         }
 847
 848         if(reply)
 849                 g_object_unref(reply);
 850
 851         NOTIFICATION_ERR("notification_ipc_request_delete_single done [result: %d]", result);
 852         return result;
 853 }
 854
 855 int notification_ipc_request_delete_multiple(notification_type_e type, char *pkgname)
 856 {
 857         int result;
 858         int num_deleted;
 859         GVariant *body;
 860         GVariant *reply_body;
 861         GDBusMessage *reply = NULL;
 862
 863         result = _dbus_init();
 864         if (result != NOTIFICATION_ERROR_NONE) {
 865                 NOTIFICATION_ERR("Can't init dbus %d", result);
 866                 return result;
 867         }
 868
 869         body = g_variant_new("(si)", pkgname, type);
 870         result = _send_sync_noti(body, &reply, "del_noti_multiple");
 871
 872         if (result == NOTIFICATION_ERROR_NONE) {
 873                 reply_body = g_dbus_message_get_body(reply);
 874                 g_variant_get(reply_body, "(i)", &num_deleted);
 875                 NOTIFICATION_ERR("num deleted:%d", num_deleted);
 876         }
 877
 878         if(reply)
 879                 g_object_unref(reply);
 880
 881         return result;
 882 }
 883
 884 int notification_ipc_request_load_noti_by_tag(notification_h noti, const char *pkgname, const char *tag)
 885 {
 886         int result;
 887         GDBusMessage *reply = NULL;
 888         GVariant *body;
 889         GVariant *reply_body;
 890         GVariant *noti_body;
 891
 892         result = _dbus_init();
 893         if (result != NOTIFICATION_ERROR_NONE) {
 894                 NOTIFICATION_ERR("Can't init dbus %d", result);
 895                 return result;
 896         }
 897
 898         body = g_variant_new("(ss)", pkgname, tag);
 899         result = _send_sync_noti(body, &reply, "load_noti_by_tag");
 900
 901         if (result == NOTIFICATION_ERROR_NONE) {
 902                 reply_body = g_dbus_message_get_body(reply);
 903                 g_variant_get(reply_body, "(v)", &noti_body);
 904
 905                 notification_ipc_make_noti_from_gvariant(noti, noti_body);
 906                 g_variant_unref(noti_body);
 907                 _print_noti(noti);
 908
 909         }
 910
 911         if(reply)
 912                 g_object_unref(reply);
 913
 914         NOTIFICATION_DBG("notification_ipc_request_load_noti_by_tag done [result: %d]", result);
 915         return result;
 916 }
 917
 918 int notification_ipc_request_load_noti_by_priv_id(notification_h noti, const char *pkgname, int priv_id)
 919 {
 920         int result;
 921         GDBusMessage *reply = NULL;
 922         GVariant *body;
 923         GVariant *reply_body;
 924         GVariant *noti_body;
 925
 926         result = _dbus_init();
 927         if (result != NOTIFICATION_ERROR_NONE) {
 928                 NOTIFICATION_ERR("Can't init dbus %d", result);
 929                 return result;
 930         }
 931
 932         body = g_variant_new("(si)", pkgname, priv_id);
 933         result = _send_sync_noti(body, &reply, "load_noti_by_priv_id");
 934
 935         if (result == NOTIFICATION_ERROR_NONE) {
 936                 reply_body = g_dbus_message_get_body(reply);
 937                 g_variant_get(reply_body, "(v)", &noti_body);
 938
 939                 notification_ipc_make_noti_from_gvariant(noti, noti_body);
 940                 g_variant_unref(noti_body);
 941                 _print_noti(noti);
 942         }
 943
 944         if(reply)
 945                 g_object_unref(reply);
 946
 947         NOTIFICATION_DBG("notification_ipc_request_load_noti_by_priv_id done [result: %d]", result);
 948         return result;
 949 }
 950
 951 int notification_ipc_request_get_count(notification_type_e type,
 952                     const char *pkgname, int group_id, int priv_id, int *count)
 953 {
 954         int result;
 955         GDBusMessage *reply = NULL;
 956         GVariant *body;
 957         GVariant *reply_body;
 958         int re_count;
 959
 960         result = _dbus_init();
 961         if (result != NOTIFICATION_ERROR_NONE) {
 962                 NOTIFICATION_ERR("Can't init dbus %d", result);
 963                 return result;
 964         }
 965
 966         body = g_variant_new("(isii)", type, pkgname, group_id, priv_id);
 967         result = _send_sync_noti(body, &reply, "get_noti_count");
 968
 969         if (result == NOTIFICATION_ERROR_NONE) {
 970                 reply_body = g_dbus_message_get_body(reply);
 971                 g_variant_get(reply_body, "(i)", &re_count);
 972
 973                 *count = re_count;
 974                 NOTIFICATION_DBG("noti count [%d]", re_count);
 975         }
 976
 977         if(reply)
 978                 g_object_unref(reply);
 979
 980         NOTIFICATION_DBG("notification_ipc_request_get_count done [result: %d]", result);
 981         return result;
 982 }
 983
 984 int notification_ipc_request_load_noti_grouping_list(notification_type_e type, int count,
 985                 notification_list_h *list)
 986 {
 987         int result;
 988         GDBusMessage *reply = NULL;
 989         GVariant *body;
 990         GVariant *reply_body;
 991         GVariant *iter_body;
 992         GVariantIter *iter;
 993         notification_h noti;
 994         GVariant *noti_body;
 995
 996         result = _dbus_init();
 997         if (result != NOTIFICATION_ERROR_NONE) {
 998                 NOTIFICATION_ERR("Can't init dbus %d", result);
 999                 return result;
1000         }
1001
1002         body = g_variant_new("(ii)", type, count);
1003         result = _send_sync_noti(body, &reply, "load_noti_grouping_list");
1004
1005         if (result == NOTIFICATION_ERROR_NONE) {
1006                 reply_body = g_dbus_message_get_body(reply);
1007                 g_variant_get(reply_body, "(a(v))", &iter);
1008
1009                 while (g_variant_iter_loop(iter, "(v)", &iter_body)) {
1010                         noti = notification_create(NOTIFICATION_TYPE_NOTI);
1011                         g_variant_get(iter_body, "(v)", &noti_body);
1012                         notification_ipc_make_noti_from_gvariant(noti, noti_body);
1013                         _print_noti(noti);
1014                         *list = notification_list_append(*list, noti);
1015                 }
1016                 g_variant_iter_free(iter);
1017         }
1018
1019         if(reply)
1020                 g_object_unref(reply);
1021
1022         NOTIFICATION_DBG("notification_ipc_request_load_noti_grouping_list done [result: %d]", result);
1023         return result;
1024 }
1025
1026 int notification_ipc_request_load_noti_detail_list(const char *pkgname,
1027                 int group_id,
1028                 int priv_id,
1029                 int count,
1030                 notification_list_h *list)
1031 {
1032         int result;
1033         GDBusMessage *reply = NULL;
1034         GVariant *body;
1035         GVariant *reply_body;
1036         GVariant *iter_body;
1037         GVariantIter *iter;
1038         notification_h noti;
1039         GVariant *noti_body;
1040
1041         result = _dbus_init();
1042         if (result != NOTIFICATION_ERROR_NONE) {
1043                 NOTIFICATION_ERR("Can't init dbus %d", result);
1044                 return result;
1045         }
1046
1047         body = g_variant_new("(siii)", pkgname, group_id, priv_id, count);
1048         result = _send_sync_noti(body, &reply, "load_noti_detail_list");
1049
1050         if (result == NOTIFICATION_ERROR_NONE) {
1051                 reply_body = g_dbus_message_get_body(reply);
1052                 g_variant_get(reply_body, "(a(v))", &iter);
1053
1054                 while (g_variant_iter_loop(iter, "(v)", &iter_body)) {
1055                         noti = notification_create(NOTIFICATION_TYPE_NOTI);
1056                         g_variant_get(iter_body, "(v)", &noti_body);
1057                         notification_ipc_make_noti_from_gvariant(noti, noti_body);
1058                         _print_noti(noti);
1059                         *list = notification_list_append(*list, noti);
1060                 }
1061                 g_variant_iter_free(iter);
1062         }
1063
1064         if(reply)
1065                 g_object_unref(reply);
1066
1067         NOTIFICATION_DBG("notification_ipc_request_load_noti_detail_list done [result: %d]", result);
1068         return result;
1069 }
1070
1071 int notification_ipc_request_get_setting_array(
1072                 notification_setting_h *setting_array,
1073                 int *count)
1074 {
1075         int result;
1076         GDBusMessage *reply = NULL;
1077         GVariant *reply_body;
1078         GVariant *iter_body;
1079         GVariantIter *iter;
1080         int setting_cnt;
1081         notification_setting_h result_setting_array;
1082         notification_setting_h temp;
1083         int setting_idx;
1084
1085         result = _dbus_init();
1086         if (result != NOTIFICATION_ERROR_NONE) {
1087                 NOTIFICATION_ERR("Can't init dbus %d", result);
1088                 return result;
1089         }
1090
1091         result = _send_sync_noti(NULL, &reply, "get_setting_array");
1092
1093         if (result == NOTIFICATION_ERROR_NONE) {
1094                 reply_body = g_dbus_message_get_body(reply);
1095                 g_variant_get(reply_body, "(ia(v))", &setting_cnt, &iter);
1096
1097                 NOTIFICATION_DBG("get setting arr cnt: %d", setting_cnt);
1098                 result_setting_array = (struct notification_setting *)malloc(sizeof(struct notification_setting) * setting_cnt);
1099                 if (result_setting_array == NULL) {
1100                         NOTIFICATION_ERR("malloc failed");
1101                         g_object_unref(reply);
1102                         g_variant_iter_free(iter);
1103                         return NOTIFICATION_ERROR_OUT_OF_MEMORY;
1104                 }
1105
1106                 setting_idx = 0;
1107                 while (g_variant_iter_loop(iter, "(v)", &iter_body)) {
1108                         temp = result_setting_array + setting_idx;
1109                         notification_ipc_make_setting_from_gvariant(temp, iter_body);
1110                         setting_idx++;
1111                 }
1112
1113                 *count = setting_cnt;
1114                 *setting_array = result_setting_array;
1115                 g_variant_iter_free(iter);
1116         }
1117
1118         if(reply)
1119                 g_object_unref(reply);
1120
1121         NOTIFICATION_DBG("notification_ipc_request_get_setting_array done [result: %d]", result);
1122         return result;
1123 }
1124
1125 int notification_ipc_request_get_setting_by_package_name(
1126                 const char *package_name, notification_setting_h *setting)
1127 {
1128         int result;
1129         GDBusMessage *reply = NULL;
1130         GVariant *body;
1131         GVariant *reply_body;
1132         GVariant *setting_body;
1133         notification_setting_h result_setting;
1134
1135         result = _dbus_init();
1136         if (result != NOTIFICATION_ERROR_NONE) {
1137                 NOTIFICATION_ERR("Can't init dbus %d", result);
1138                 return result;
1139         }
1140
1141         body = g_variant_new("(s)", package_name);
1142         result = _send_sync_noti(body, &reply, "get_setting_by_package_name");
1143
1144         if (result == NOTIFICATION_ERROR_NONE) {
1145                 reply_body = g_dbus_message_get_body(reply);
1146                 g_variant_get(reply_body, "(v)", &setting_body);
1147
1148                 result_setting = (struct notification_setting *)malloc(sizeof(struct notification_setting));
1149                 if (result_setting == NULL) {
1150                         NOTIFICATION_ERR("malloc failed");
1151                         g_object_unref(reply);
1152                         g_variant_unref(body);
1153                         return NOTIFICATION_ERROR_OUT_OF_MEMORY;
1154                 }
1155                 notification_ipc_make_setting_from_gvariant(result_setting, setting_body);
1156
1157                 *setting = result_setting;
1158                 g_variant_unref(setting_body);
1159         }
1160
1161         if(reply)
1162                 g_object_unref(reply);
1163
1164         NOTIFICATION_DBG("notification_ipc_request_get_setting_by_package_name done [result: %d]", result);
1165         return result;
1166 }
1167
1168 int notification_ipc_request_load_system_setting(notification_system_setting_h *setting)
1169 {
1170         int result;
1171         GDBusMessage *reply = NULL;
1172         GVariant *setting_body;
1173         GVariant *reply_body;
1174         notification_system_setting_h result_setting;
1175
1176         result = _dbus_init();
1177         if (result != NOTIFICATION_ERROR_NONE) {
1178                 NOTIFICATION_ERR("Can't init dbus %d", result);
1179                 return result;
1180         }
1181
1182         result = _send_sync_noti(NULL, &reply, "load_system_setting");
1183
1184         if (result == NOTIFICATION_ERROR_NONE) {
1185                 reply_body = g_dbus_message_get_body(reply);
1186                 g_variant_get(reply_body, "(v)", &setting_body);
1187
1188                 result_setting = (struct notification_system_setting *)malloc(sizeof(struct notification_system_setting));
1189                 if (result_setting == NULL) {
1190                         NOTIFICATION_ERR("malloc failed");
1191                         g_object_unref(reply);
1192                         return NOTIFICATION_ERROR_OUT_OF_MEMORY;
1193                 }
1194                 notification_ipc_make_system_setting_from_gvariant(result_setting, setting_body);
1195
1196                 *setting = result_setting;
1197                 g_variant_unref(setting_body);
1198         }
1199
1200         if(reply)
1201                 g_object_unref(reply);
1202
1203         NOTIFICATION_DBG("notification_ipc_request_load_system_setting done [result: %d]", result);
1204         return result;
1205 }
1206
1207 int notification_ipc_update_setting(notification_setting_h setting)
1208 {
1209         int result;
1210         GDBusMessage *reply = NULL;
1211         GVariant *body;
1212
1213         result = _dbus_init();
1214         if (result != NOTIFICATION_ERROR_NONE) {
1215                 NOTIFICATION_ERR("Can't init dbus %d", result);
1216                 return result;
1217         }
1218
1219         body = g_variant_new("(siii)",
1220                         setting->package_name,
1221                         (int)(setting->allow_to_notify),
1222                         (int)(setting->do_not_disturb_except),
1223                         (int)(setting->visibility_class));
1224
1225         result = _send_sync_noti(body, &reply, "update_noti_setting");
1226
1227         if(reply)
1228                 g_object_unref(reply);
1229
1230         NOTIFICATION_DBG("notification_ipc_update_setting done [result: %d]", result);
1231         return result;
1232 }
1233
1234 int notification_ipc_update_system_setting(notification_system_setting_h system_setting)
1235 {
1236         int result;
1237         GDBusMessage *reply = NULL;
1238         GVariant *body;
1239
1240         result = _dbus_init();
1241         if (result != NOTIFICATION_ERROR_NONE) {
1242                 NOTIFICATION_ERR("Can't init dbus %d", result);
1243                 return result;
1244         }
1245
1246         body = g_variant_new("(ii)",
1247                         (int)(system_setting->do_not_disturb),
1248                         (int)(system_setting->visibility_class));
1249
1250         result = _send_sync_noti(body, &reply, "update_noti_sys_setting");
1251
1252         if (reply)
1253                 g_object_unref(reply);
1254
1255         NOTIFICATION_DBG("notification_ipc_update_system_setting done [result: %d]", result);
1256         return result;
1257 }
1258
1259 int notification_ipc_noti_setting_property_set(const char *pkgname, const char *property, const char *value)
1260 {
1261         int result;
1262         GDBusMessage *reply = NULL;
1263         GVariant *body;
1264
1265         result = _dbus_init();
1266         if (result != NOTIFICATION_ERROR_NONE) {
1267                 NOTIFICATION_ERR("Can't init dbus %d", result);
1268                 return result;
1269         }
1270         body = g_variant_new("(sss)", pkgname, property, value);
1271
1272         result = _send_sync_noti(body, &reply, "set_noti_property");
1273
1274         if (reply)
1275                 g_object_unref(reply);
1276
1277         NOTIFICATION_DBG("notification_ipc_noti_setting_property_set done [result: %d]", result);
1278         return result;
1279 }
1280
1281 int notification_ipc_noti_setting_property_get(const char *pkgname, const char *property, char **value)
1282 {
1283         int result;
1284         GDBusMessage *reply = NULL;
1285         GVariant *body;
1286         GVariant *reply_body = NULL;
1287         gchar *ret_val;
1288
1289         result = _dbus_init();
1290
1291         if (result != NOTIFICATION_ERROR_NONE) {
1292                 NOTIFICATION_ERR("Can't init dbus %d", result);
1293                 return result;
1294         }
1295
1296         body = g_variant_new("(ss)", pkgname, property);
1297         result = _send_sync_noti(body, &reply, "get_noti_property");
1298
1299         if (result == NOTIFICATION_ERROR_NONE) {
1300                 reply_body = g_dbus_message_get_body(reply);
1301                 g_variant_get(body, "(s)", &ret_val);
1302
1303                 if (ret_val != NULL) {
1304                         *value = g_strdup(ret_val);
1305                         g_free(ret_val);
1306                 }
1307         }
1308
1309         if(reply)
1310                 g_object_unref(reply);
1311
1312         NOTIFICATION_DBG("notification_ipc_noti_setting_property_get done [result: %d]", result);
1313         return result;
1314 }
1315
1316 EXPORT_API GVariant *notification_ipc_make_gvariant_from_noti(notification_h noti)
1317 {
1318         NOTIFICATION_DBG("make gvariant from noti");
1319         int i = 0;
1320         int b_encode_len = 0;
1321         bundle_raw *args = NULL;
1322         bundle_raw *group_args = NULL;
1323         bundle_raw *b_image_path = NULL;
1324         bundle_raw *b_execute_option = NULL;
1325         bundle_raw *b_service_responding = NULL;
1326         bundle_raw *b_service_single_launch = NULL;
1327         bundle_raw *b_service_multi_launch = NULL;
1328         bundle_raw *b_event_handler[NOTIFICATION_EVENT_TYPE_MAX] = {NULL, };
1329         bundle_raw *b_text = NULL;
1330         bundle_raw *b_key = NULL;
1331         bundle_raw *b_format_args = NULL;
1332         GVariant *body = NULL;
1333         GVariant *result_body = NULL;
1334         GVariantBuilder builder;
1335
1336         g_variant_builder_init(&builder, G_VARIANT_TYPE("a{iv}"));
1337         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_NOTI_TYPE, g_variant_new_int32(noti->type));
1338         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LAYOUT, g_variant_new_int32(noti->layout));
1339         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_GROUP_ID, g_variant_new_int32(noti->group_id));
1340         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_INTERNAL_GROUP_ID, g_variant_new_int32(noti->internal_group_id));
1341         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_PRIV_ID, g_variant_new_int32(noti->priv_id));
1342         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_CALLER_PKGNAME, g_variant_new_string((const gchar *)noti->caller_pkgname));
1343         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_DISPLAY_APPLIST, g_variant_new_int32(noti->display_applist));
1344
1345         if (noti->args) {
1346                 bundle_encode(noti->args, (bundle_raw **)&args, NULL);
1347                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_ARGS, g_variant_new_string((const gchar *)args));
1348
1349                 if (args)
1350                         bundle_free_encoded_rawdata(&args);
1351         }
1352
1353         if (noti->group_args) {
1354                 bundle_encode(noti->group_args, (bundle_raw **)&group_args,
1355                               &b_encode_len);
1356                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_GROUP_ARGS, g_variant_new_string((const gchar *)group_args));
1357
1358                 if (group_args)
1359                         bundle_free_encoded_rawdata(&group_args);
1360         }
1361
1362         if (noti->b_execute_option) {
1363                 bundle_encode(noti->b_execute_option,
1364                               (bundle_raw **)&b_execute_option, &b_encode_len);
1365                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_EXECUTE_OPTION, g_variant_new_string((const gchar *)b_execute_option));
1366
1367                 if (b_execute_option)
1368                         bundle_free_encoded_rawdata(&b_execute_option);
1369         }
1370
1371         if (noti->b_service_responding) {
1372                 bundle_encode(noti->b_service_responding,
1373                               (bundle_raw **)&b_service_responding, &b_encode_len);
1374                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_SERVICE_RESPONDING, g_variant_new_string((const gchar *)b_service_responding));
1375
1376                 if (b_service_responding)
1377                         bundle_free_encoded_rawdata(&b_service_responding);
1378         }
1379
1380         if (noti->b_service_single_launch) {
1381                 bundle_encode(noti->b_service_single_launch,
1382                               (bundle_raw **)&b_service_single_launch, &b_encode_len);
1383                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_SERVICE_SINGLE_LAUNCH, g_variant_new_string((const gchar *)b_service_single_launch));
1384
1385                 if (b_service_single_launch)
1386                         bundle_free_encoded_rawdata(&b_service_single_launch);
1387         }
1388
1389         if (noti->b_service_multi_launch) {
1390                 bundle_encode(noti->b_service_multi_launch,
1391                               (bundle_raw **)&b_service_multi_launch, &b_encode_len);
1392                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_SERVICE_MULTI_LAUNCH, g_variant_new_string((const gchar *)b_service_multi_launch));
1393
1394                 if (b_service_multi_launch)
1395                         bundle_free_encoded_rawdata(&b_service_multi_launch);
1396         }
1397
1398         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
1399                 if (noti->b_event_handler[i]) {
1400                         bundle_encode(noti->b_event_handler[i],
1401                                         (bundle_raw **)&b_event_handler[i], &b_encode_len);
1402                         g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_BUTTON1_EVENT + i, g_variant_new_string((const gchar *)b_event_handler[i]));
1403
1404                         if (b_event_handler[i])
1405                                 bundle_free_encoded_rawdata(&b_event_handler[i]);
1406                 }
1407         }
1408
1409         if (noti->launch_pkgname)
1410                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LAUNCH_PKGNAME, g_variant_new_string((const gchar *)noti->launch_pkgname));
1411
1412         if (noti->domain != NULL)
1413                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_DOMAIN, g_variant_new_string((const gchar *)noti->domain));
1414
1415         if (noti->dir != NULL)
1416                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_DIR, g_variant_new_string((const gchar *)noti->dir));
1417
1418         if (noti->b_text) {
1419                 bundle_encode(noti->b_text, (bundle_raw **)&b_text, &b_encode_len);
1420                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_TEXT, g_variant_new_string((const gchar *)b_text));
1421
1422                 if (b_text)
1423                         bundle_free_encoded_rawdata(&b_text);
1424         }
1425
1426         if (noti->b_key) {
1427                 bundle_encode(noti->b_key, (bundle_raw **)&b_key, &b_encode_len);
1428                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_KEY, g_variant_new_string((const gchar *)b_key));
1429
1430                 if (b_key)
1431                         bundle_free_encoded_rawdata(&b_key);
1432         }
1433
1434         if (noti->b_format_args) {
1435                 bundle_encode(noti->b_format_args,
1436                               (bundle_raw **)&b_format_args, &b_encode_len);
1437                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_FORMAT_ARGS, g_variant_new_string((const gchar *)b_format_args));
1438
1439                 if (b_format_args)
1440                         bundle_free_encoded_rawdata(&b_format_args);
1441         }
1442
1443         if (noti->num_format_args != 0)
1444                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_NUM_FORMAT_ARGS, g_variant_new_int32(noti->num_format_args));
1445
1446         if (noti->b_image_path) {
1447                 bundle_encode(noti->b_image_path,
1448                               (bundle_raw **)&b_image_path, &b_encode_len);
1449                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_IMAGE_PATH, g_variant_new_string((const gchar *)b_image_path));
1450
1451                 if (b_image_path)
1452                         bundle_free_encoded_rawdata(&b_image_path);
1453         }
1454
1455         if (noti->sound_type != NOTIFICATION_SOUND_TYPE_NONE)
1456                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_SOUND_TYPE, g_variant_new_int32(noti->sound_type));
1457
1458         if (noti->sound_path)
1459                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_SOUND_PATH, g_variant_new_string((const gchar *)noti->sound_path));
1460
1461         if (noti->vibration_type != NOTIFICATION_VIBRATION_TYPE_NONE)
1462                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_VIBRATION_TYPE, g_variant_new_int32(noti->vibration_type));
1463
1464         if (noti->vibration_path)
1465                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_VIBRATION_PATH, g_variant_new_string((const gchar *)noti->vibration_path));
1466
1467         if (noti->led_operation != NOTIFICATION_LED_OP_OFF)
1468                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LED_OPERATION, g_variant_new_int32(noti->led_operation));
1469
1470         if (noti->led_argb != 0)
1471                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LED_ARGB, g_variant_new_int32(noti->led_argb));
1472
1473         if (noti->led_on_ms != 0)
1474                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LED_ON_MS, g_variant_new_int32(noti->led_on_ms));
1475
1476         if (noti->led_off_ms != 0)
1477                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_LED_OFF_MS, g_variant_new_int32(noti->led_off_ms));
1478
1479         if (noti->time != 0)
1480                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_TIME, g_variant_new_int32(noti->time));
1481
1482         if (noti->insert_time != 0)
1483                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_INSERT_TIME, g_variant_new_int32(noti->insert_time));
1484
1485         if (noti->flags_for_property != 0)
1486                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_FLAGS_FOR_PROPERTY, g_variant_new_int32(noti->flags_for_property));
1487
1488         if (noti->progress_size != 0.0)
1489                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_PROGRESS_SIZE, g_variant_new_double(noti->progress_size));
1490
1491         if (noti->progress_percentage != 0.0)
1492                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_PROGRESS_PERCENTAGE, g_variant_new_double(noti->progress_percentage));
1493
1494         if (noti->app_icon_path != NULL)
1495                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_APP_ICON_PATH, g_variant_new_string((const gchar *)noti->app_icon_path));
1496         if (noti->app_name != NULL)
1497                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_APP_NAME, g_variant_new_string((const gchar *)noti->app_name));
1498         if (noti->temp_title != NULL)
1499                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_TEMP_TITLE, g_variant_new_string((const gchar *)noti->temp_title));
1500         if (noti->temp_content != NULL)
1501                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_TEMP_CONTENT, g_variant_new_string((const gchar *)noti->temp_content));
1502         if (noti->tag != NULL)
1503                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_TAG, g_variant_new_string((const gchar *)noti->tag));
1504
1505         if (noti->ongoing_flag != 0)
1506                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_ONGOING_FLAG, g_variant_new_int32(noti->ongoing_flag));
1507         if (noti->auto_remove != 0)
1508                 g_variant_builder_add(&builder, "{iv}", NOTIFICATION_DATA_TYPE_AUTO_REMOVE, g_variant_new_int32(noti->auto_remove));
1509
1510         result_body = g_variant_builder_end(&builder);
1511         body = g_variant_new("(v)", result_body);
1512
1513         return body;
1514 }
1515
1516 static gboolean _variant_to_int_dict(GHashTable **dict, GVariant *variant) {
1517
1518         GVariantIter iter;
1519         int key;
1520         int *hash_key;
1521         GVariant *value;
1522
1523         *dict = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, (GDestroyNotify)g_variant_unref);
1524         if (*dict == NULL)
1525                 return FALSE;
1526
1527         g_variant_iter_init(&iter, variant);
1528         while (g_variant_iter_next(&iter, "{iv}", &key, &value)) {
1529                 hash_key = (int *)calloc(sizeof(int), 1);
1530                 if (hash_key == NULL) {
1531                         g_hash_table_remove_all(*dict);
1532                         return FALSE;
1533                 }
1534                 *hash_key = key;
1535                 g_hash_table_insert(*dict, (gpointer)hash_key, value);
1536         }
1537         return TRUE;
1538 }
1539
1540 static gboolean _variant_dict_lookup(GHashTable *dict,
1541                 int key,
1542                 const gchar  *format_string,
1543                 ...)
1544 {
1545         GVariant *value;
1546         va_list ap;
1547
1548         value = g_hash_table_lookup(dict, (gpointer)&key);
1549
1550         if (value == NULL || !g_variant_check_format_string(value, format_string, FALSE))
1551                 return FALSE;
1552
1553         va_start(ap, format_string);
1554         g_variant_get_va(value, format_string, NULL, &ap);
1555         va_end(ap);
1556
1557         return TRUE;
1558 }
1559
1560 /*!
1561  * functions creating notification packet
1562  */
1563 EXPORT_API int notification_ipc_make_noti_from_gvariant(notification_h noti,
1564                 GVariant *variant) {
1565
1566         NOTIFICATION_DBG("make noti from GVariant");
1567         GHashTable *dict;
1568
1569         int i;
1570         char *caller_pkgname = NULL;
1571         char *launch_pkgname = NULL;
1572         bundle_raw *args = NULL;
1573         bundle_raw *group_args = NULL;
1574         bundle_raw *b_execute_option = NULL;
1575         bundle_raw *b_service_responding = NULL;
1576         bundle_raw *b_service_single_launch = NULL;
1577         bundle_raw *b_service_multi_launch = NULL;
1578         bundle_raw *b_event_handler[NOTIFICATION_EVENT_TYPE_MAX] = { NULL, };
1579         char *domain = NULL;
1580         char *dir = NULL;
1581         bundle_raw *b_text = NULL;
1582         bundle_raw *b_key = NULL;
1583         bundle_raw *b_format_args = NULL;
1584         bundle_raw *b_image_path = NULL;
1585         char *sound_path = NULL;
1586         char *vibration_path = NULL;
1587         char *app_icon_path = NULL;
1588         char *app_name = NULL;
1589         char *temp_title = NULL;
1590         char *temp_content = NULL;
1591         char *tag = NULL;
1592
1593         if (noti == NULL) {
1594                 NOTIFICATION_ERR("invalid data noti NULL");
1595                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
1596         }
1597
1598         if (variant == NULL) {
1599                 NOTIFICATION_ERR("invalid data variant NULL");
1600                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
1601         }
1602
1603         if (!_variant_to_int_dict(&dict, variant))
1604                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
1605
1606         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_NOTI_TYPE, "i", &noti->type);
1607         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LAYOUT, "i", &noti->layout);
1608         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_GROUP_ID, "i", &noti->group_id);
1609         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_INTERNAL_GROUP_ID, "i", &noti->internal_group_id);
1610         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_PRIV_ID, "i", &noti->priv_id);
1611         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_CALLER_PKGNAME, "&s", &caller_pkgname);
1612         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LAUNCH_PKGNAME, "&s", &launch_pkgname);
1613         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_ARGS, "&s", &args);
1614         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_GROUP_ARGS, "&s", &group_args);
1615         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_EXECUTE_OPTION, "&s", &b_execute_option);
1616         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_SERVICE_RESPONDING, "&s", &b_service_responding);
1617         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_SERVICE_SINGLE_LAUNCH, "&s", &b_service_single_launch);
1618         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_SERVICE_MULTI_LAUNCH, "&s", &b_service_multi_launch);
1619         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON1_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1]);
1620         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON2_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_2]);
1621         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON3_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_3]);
1622         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON4_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_4]);
1623         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON5_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_5]);
1624         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_BUTTON6_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_6]);
1625         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_ICON_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_ICON]);
1626         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_THUMBNAIL_EVENT, "&s", &noti->b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL]);
1627         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_DOMAIN, "&s", &domain);
1628         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_DIR, "&s", &dir);
1629         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_TEXT, "&s", &b_text);
1630         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_KEY, "&s", &b_key);
1631         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_FORMAT_ARGS, "&s", &b_format_args);
1632         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_NUM_FORMAT_ARGS, "i", &noti->num_format_args);
1633         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_IMAGE_PATH, "&s", &b_image_path);
1634         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_SOUND_TYPE, "i", &noti->sound_type);
1635         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_SOUND_PATH, "&s", &sound_path);
1636         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_VIBRATION_TYPE, "i", &noti->vibration_type);
1637         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_VIBRATION_PATH, "&s", &vibration_path);
1638         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LED_OPERATION, "i", &noti->led_operation);
1639         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LED_ARGB, "i", &noti->led_argb);
1640         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LED_ON_MS, "i", &noti->led_on_ms);
1641         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_LED_OFF_MS, "i", &noti->led_off_ms);
1642         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_TIME, "i", &noti->time);
1643         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_INSERT_TIME, "i", &noti->insert_time);
1644         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_FLAGS_FOR_PROPERTY, "i", &noti->flags_for_property);
1645         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_DISPLAY_APPLIST, "i", &noti->display_applist);
1646         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_PROGRESS_SIZE, "d", &noti->progress_size);
1647         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_PROGRESS_PERCENTAGE, "d", &noti->progress_percentage);
1648         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_APP_ICON_PATH, "&s", &app_icon_path);
1649         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_APP_NAME, "&s", &app_name);
1650         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_TEMP_TITLE, "&s", &temp_title);
1651         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_TEMP_CONTENT, "&s", &temp_content);
1652         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_TAG, "&s", &tag);
1653         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_ONGOING_FLAG, "i", &noti->ongoing_flag);
1654         _variant_dict_lookup(dict, NOTIFICATION_DATA_TYPE_AUTO_REMOVE, "i", &noti->auto_remove);
1655
1656         noti->caller_pkgname = _dup_string(caller_pkgname);
1657         noti->launch_pkgname = _dup_string(launch_pkgname);
1658         noti->args = _create_bundle_from_bundle_raw(args);
1659         noti->group_args = _create_bundle_from_bundle_raw(group_args);
1660         noti->b_execute_option = _create_bundle_from_bundle_raw(b_execute_option);
1661         noti->b_service_responding = _create_bundle_from_bundle_raw(
1662                         b_service_responding);
1663         noti->b_service_single_launch = _create_bundle_from_bundle_raw(
1664                         b_service_single_launch);
1665         noti->b_service_multi_launch = _create_bundle_from_bundle_raw(
1666                         b_service_multi_launch);
1667         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
1668                 noti->b_event_handler[i] = _create_bundle_from_bundle_raw(
1669                                 b_event_handler[i]);
1670         }
1671         noti->domain = _dup_string(domain);
1672         noti->dir = _dup_string(dir);
1673         noti->b_text = _create_bundle_from_bundle_raw(b_text);
1674         noti->b_key = _create_bundle_from_bundle_raw(b_key);
1675         noti->b_format_args = _create_bundle_from_bundle_raw(b_format_args);
1676         noti->b_image_path = _create_bundle_from_bundle_raw(b_image_path);
1677         noti->sound_path = _dup_string(sound_path);
1678         noti->vibration_path = _dup_string(vibration_path);
1679         noti->app_icon_path = _dup_string(app_icon_path);
1680         noti->app_name = _dup_string(app_name);
1681         noti->temp_title = _dup_string(temp_title);
1682         noti->temp_content = _dup_string(temp_content);
1683         noti->tag = _dup_string(tag);
1684
1685         g_hash_table_remove_all(dict);
1686
1687         return NOTIFICATION_ERROR_NONE;
1688 }
1689
1690 EXPORT_API GVariant *notification_ipc_make_gvariant_from_system_setting(struct notification_system_setting *noti_setting)
1691 {
1692         GVariant *body = NULL;
1693         body = g_variant_new("(ii)",
1694                         noti_setting->do_not_disturb,
1695                         noti_setting->visibility_class);
1696         return body;
1697 }
1698
1699 EXPORT_API int notification_ipc_make_system_setting_from_gvariant(struct notification_system_setting *noti_setting,
1700                 GVariant *variant)
1701 {
1702         int do_not_disturb;
1703         int visibility_class;
1704
1705         if (noti_setting == NULL) {
1706                 NOTIFICATION_ERR("invalid data");
1707                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
1708         }
1709         g_variant_get(variant,
1710                         "(ii)",
1711                         &do_not_disturb,
1712                         &visibility_class);
1713
1714         NOTIFICATION_DBG("system setting  #### %d, %d",
1715                         do_not_disturb, visibility_class);
1716
1717         noti_setting->do_not_disturb = do_not_disturb;
1718         noti_setting->visibility_class = visibility_class;
1719
1720         NOTIFICATION_DBG("system setting2  #### %d, %d",
1721                         noti_setting->do_not_disturb, noti_setting->visibility_class);
1722
1723         return NOTIFICATION_ERROR_NONE;
1724 }
1725
1726 EXPORT_API GVariant *notification_ipc_make_gvariant_from_setting(struct notification_setting *noti_setting)
1727 {
1728         GVariant *body = NULL;
1729
1730         body = g_variant_new("(siii)",
1731                         noti_setting->package_name,
1732                         noti_setting->allow_to_notify,
1733                         noti_setting->do_not_disturb_except,
1734                         noti_setting->visibility_class);
1735
1736         return body;
1737 }
1738
1739 EXPORT_API int notification_ipc_make_setting_from_gvariant(struct notification_setting *noti_setting,
1740                 GVariant *variant)
1741 {
1742         NOTIFICATION_DBG("notification_ipc_make_setting_from_gvariant !!!!");
1743         char *pkgname;
1744         int allow_to_notify;
1745         int do_not_disturb_except;
1746         int visibility_class;
1747
1748         if (noti_setting == NULL || variant == NULL) {
1749                 NOTIFICATION_ERR("invalid data");
1750                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
1751         }
1752         g_variant_get(variant,
1753                         "(&siii)",
1754                         &pkgname,
1755                         &allow_to_notify,
1756                         &do_not_disturb_except,
1757                         &visibility_class);
1758
1759         NOTIFICATION_DBG("setting from variant %s !!", pkgname);
1760
1761         noti_setting->package_name = _dup_string(pkgname);
1762         noti_setting->allow_to_notify = allow_to_notify;
1763         noti_setting->do_not_disturb_except = do_not_disturb_except;
1764         noti_setting->visibility_class = visibility_class;
1765
1766         NOTIFICATION_DBG("setting from variant %s, %s",
1767                         noti_setting->package_name, pkgname);
1768
1769         return NOTIFICATION_ERROR_NONE;
1770 }
1771
1772 static int _send_service_register()
1773 {
1774         NOTIFICATION_DBG("service register");
1775         GDBusMessage *reply = NULL;
1776         int result;
1777
1778         result = _send_sync_noti(NULL, &reply, "noti_service_register");
1779
1780         if(reply)
1781                 g_object_unref(reply);
1782
1783         NOTIFICATION_ERR("_send_service_register done = %s, result = %d", _bus_name, result);
1784         return result;
1785 }
1786
1787 static int _ipc_monitor_register(void)
1788 {
1789         NOTIFICATION_ERR("register a service\n");
1790
1791         return  _send_service_register();
1792 }
1793
1794 static void _on_name_appeared(GDBusConnection *connection,
1795                 const gchar     *name,
1796                 const gchar     *name_owner,
1797                 gpointer         user_data)
1798 {
1799         NOTIFICATION_DBG("name appeared : %s", name);
1800         is_master_started = 1;
1801         _ipc_monitor_register();
1802
1803         /* TODO: dbus activation isn't enough ? */
1804         _do_deffered_task();
1805 }
1806
1807 static void _on_name_vanished(GDBusConnection *connection,
1808                 const gchar     *name,
1809                 gpointer         user_data)
1810 {
1811         NOTIFICATION_DBG("name vanished : %s", name);
1812         is_master_started = 0;
1813 }
1814
1815 int notification_ipc_monitor_init(void)
1816 {
1817         int ret;
1818
1819         ret = _dbus_init();
1820         if (ret != NOTIFICATION_ERROR_NONE) {
1821                 NOTIFICATION_ERR("Can't init dbus %d", ret);
1822                 return ret;
1823         }
1824
1825         ret = _dbus_signal_init();
1826         if (ret != NOTIFICATION_ERROR_NONE) {
1827                 NOTIFICATION_ERR("Can't signal_init %d", ret);
1828                 return ret;
1829         }
1830
1831         ret = _ipc_monitor_register();
1832         if (ret != NOTIFICATION_ERROR_NONE) {
1833                 NOTIFICATION_ERR("Can't init ipc_monitor_register %d", ret);
1834                 return ret;
1835         }
1836
1837         if (provider_monitor_id == 0) {
1838                 provider_monitor_id = g_bus_watch_name_on_connection(
1839                                 _gdbus_conn,
1840                                 PROVIDER_BUS_NAME,
1841                                 G_BUS_NAME_WATCHER_FLAGS_NONE,
1842                                 _on_name_appeared,
1843                                 _on_name_vanished,
1844                                 NULL,
1845                                 NULL);
1846
1847                 if (provider_monitor_id == 0) {
1848                         g_dbus_connection_signal_unsubscribe(_gdbus_conn, monitor_id);
1849                         monitor_id = 0;
1850                         NOTIFICATION_ERR("watch on name fail");
1851                         return NOTIFICATION_ERROR_IO_ERROR;
1852                 }
1853         }
1854
1855         return NOTIFICATION_ERROR_NONE;
1856 }
1857
1858 static int _ipc_monitor_deregister(void)
1859 {
1860         if (provider_monitor_id) {
1861                 g_bus_unwatch_name(provider_monitor_id);
1862                 provider_monitor_id = 0;
1863         }
1864
1865         if (monitor_id) {
1866                 g_dbus_connection_signal_unsubscribe(_gdbus_conn, monitor_id);
1867                 monitor_id = 0;
1868         }
1869
1870         return NOTIFICATION_ERROR_NONE;
1871 }
1872
1873 int notification_ipc_monitor_fini(void)
1874 {
1875         return  _ipc_monitor_deregister();
1876 }