notification-ex/stub.cc

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   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 <dlog.h>
  18 #include <glib.h>
  19 #include <unistd.h>
  20
  21 #include <list>
  22
  23 #include "api/notification_ex_app_control_action.h"
  24 #include "api/notification_ex_button.h"
  25 #include "api/notification_ex_chat_message.h"
  26 #include "api/notification_ex_checkbox.h"
  27 #include "api/notification_ex_entry.h"
  28 #include "api/notification_ex_event_info.h"
  29 #include "api/notification_ex_group.h"
  30 #include "api/notification_ex_image.h"
  31 #include "api/notification_ex_input_selector.h"
  32 #include "api/notification_ex_item.h"
  33 #include "api/notification_ex_manager.h"
  34 #include "api/notification_ex_progress.h"
  35 #include "api/notification_ex_reporter.h"
  36 #include "api/notification_ex_text.h"
  37 #include "api/notification_ex_time.h"
  38 #include "api/notification_ex_visibility_action.h"
  39 #include "notification-ex/reporter.h"
  40 #include "notification-ex/app_control_action.h"
  41 #include "notification-ex/button_item.h"
  42 #include "notification-ex/chat_message_item.h"
  43 #include "notification-ex/checkbox_item.h"
  44 #include "notification-ex/entry_item.h"
  45 #include "notification-ex/group_item.h"
  46
  47 #ifdef LOG_TAG
  48 #undef LOG_TAG
  49 #endif
  50 #define LOG_TAG "NOTIFICATION_EX"
  51
  52 #ifdef EXPORT_API
  53 #undef EXPORT_API
  54 #endif
  55 #define EXPORT_API __attribute__((visibility("default")))
  56
  57 using namespace std;
  58 using namespace notification::item;
  59
  60 extern "C" EXPORT_API int noti_ex_action_app_control_create(
  61     noti_ex_action_h *handle, app_control_h app_control,
  62     const char *extra) {
  63   if (handle == nullptr || app_control == nullptr) {
  64     LOGE("Invalid parameter");
  65     return NOTI_EX_ERROR_INVALID_PARAMETER;
  66   }
  67
  68   auto* p = new (std::nothrow) AppControlAction(app_control, extra);
  69   if (p == nullptr) {
  70     LOGE("Out-of-memory");
  71     return NOTI_EX_ERROR_OUT_OF_MEMORY;
  72   }
  73
  74   *handle = p;
  75
  76   return NOTI_EX_ERROR_NONE;
  77 }
  78
  79 extern "C" EXPORT_API int noti_ex_action_app_control_set(
  80     noti_ex_action_h handle, app_control_h app_control) {
  81   if (handle == nullptr || app_control == nullptr) {
  82     LOGE("Invalid parameter");
  83     return NOTI_EX_ERROR_INVALID_PARAMETER;
  84   }
  85
  86   AppControlAction* p = static_cast<AppControlAction*>(handle);
  87   p->SetAppControl(app_control);
  88
  89   return NOTI_EX_ERROR_NONE;
  90 }
  91
  92 extern "C" EXPORT_API int noti_ex_action_app_control_get(
  93     noti_ex_action_h handle, app_control_h *app_control) {
  94   if (handle == nullptr || app_control == nullptr) {
  95     LOGE("Invalid parameter");
  96     return NOTI_EX_ERROR_INVALID_PARAMETER;
  97   }
  98
  99   AppControlAction* p = static_cast<AppControlAction*>(handle);
 100   *app_control = p->GetAppControl();
 101
 102   return NOTI_EX_ERROR_NONE;
 103 }
 104
 105 extern "C" EXPORT_API int noti_ex_item_button_create(noti_ex_item_h *handle,
 106     const char *id, const char *title) {
 107   ButtonItem* p;
 108
 109   if (handle == nullptr || title == nullptr) {
 110     LOGE("Invalid parameter");
 111     return NOTI_EX_ERROR_INVALID_PARAMETER;
 112   }
 113
 114   if (id)
 115     p = new (std::nothrow) ButtonItem(id, title);
 116   else
 117     p = new (std::nothrow) ButtonItem(title);
 118
 119   if (p == nullptr) {
 120     LOGE("Out-of-memory");
 121     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 122   }
 123
 124   *handle = p;
 125
 126   return NOTI_EX_ERROR_NONE;
 127 }
 128
 129 extern "C" EXPORT_API int noti_ex_item_button_get_title(noti_ex_item_h handle,
 130     char **title) {
 131   if (handle == nullptr || title == nullptr) {
 132     LOGE("Invalid parameter");
 133     return NOTI_EX_ERROR_INVALID_PARAMETER;
 134   }
 135
 136   ButtonItem* p = static_cast<ButtonItem*>(handle);
 137   if (!p->GetTitle().empty()) {
 138     *title = strdup(p->GetTitle().c_str());
 139     if (*title == nullptr) {
 140       LOGE("Out-of-memory");
 141       return NOTI_EX_ERROR_OUT_OF_MEMORY;
 142     }
 143   }
 144
 145   return NOTI_EX_ERROR_NONE;
 146 }
 147
 148 extern "C" EXPORT_API int noti_ex_item_chat_message_create(
 149     noti_ex_item_h *handle, const char *id, noti_ex_item_h name,
 150     noti_ex_item_h text, noti_ex_item_h image, noti_ex_item_h time,
 151     noti_ex_item_chat_message_type_e message_type) {
 152 // To do
 153 #if 0
 154   ChatMessageItem* p;
 155
 156   if (handle == nullptr || message_type < NOTI_EX_ITEM_CHAT_MESSAGE_TYPE_USER
 157       || message_type > NOTI_EX_ITEM_CHAT_MESSAGE_TYPE_SENDER) {
 158     LOGE("Invalid parameter");
 159     return NOTI_EX_ERROR_INVALID_PARAMETER;
 160   }
 161
 162   p = new (std::nothrow) ChatMessageItem(id,
 163                 static_cast<TextItem*>(name),
 164                 static_cast<TextItem*>(text),
 165                 static_cast<ImageItem*>(image),
 166                 static_cast<TimeItem*>(time),
 167                 static_cast<ChatMessageItem::Type>((int)message_type));
 168   if (p == nullptr) {
 169     LOGE("Out-of-memory");
 170     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 171   }
 172
 173   *handle = p;
 174
 175   return NOTI_EX_ERROR_NONE;
 176 #else
 177   return NOTI_EX_ERROR_NONE;
 178 #endif
 179 }
 180
 181 extern "C" EXPORT_API int noti_ex_item_chat_message_get_name(
 182     noti_ex_item_h handle, noti_ex_item_h *name) {
 183   if (handle == nullptr || name == nullptr) {
 184     LOGE("Invalid parameter");
 185     return NOTI_EX_ERROR_INVALID_PARAMETER;
 186   }
 187
 188   ChatMessageItem* p = static_cast<ChatMessageItem*>(handle);
 189   *name = &(p->GetNameItem());
 190
 191   return NOTI_EX_ERROR_NONE;
 192 }
 193
 194 extern "C" EXPORT_API int noti_ex_item_chat_message_get_text(
 195     noti_ex_item_h handle, noti_ex_item_h *text) {
 196   if (handle == nullptr || text == nullptr) {
 197     LOGE("Invalid parameter");
 198     return NOTI_EX_ERROR_INVALID_PARAMETER;
 199   }
 200
 201   ChatMessageItem* p = static_cast<ChatMessageItem*>(handle);
 202   *text = &(p->GetTextItem());
 203
 204   return NOTI_EX_ERROR_NONE;
 205 }
 206
 207 extern "C" EXPORT_API int noti_ex_item_chat_message_get_image(
 208     noti_ex_item_h handle, noti_ex_item_h *image) {
 209   if (handle == nullptr || image == nullptr) {
 210     LOGE("Invalid parameter");
 211     return NOTI_EX_ERROR_INVALID_PARAMETER;
 212   }
 213
 214   ChatMessageItem* p = static_cast<ChatMessageItem*>(handle);
 215   *image =  &(p->GetImageItem());
 216
 217   return NOTI_EX_ERROR_NONE;
 218 }
 219
 220 extern "C" EXPORT_API int noti_ex_item_chat_message_get_time(
 221     noti_ex_item_h handle, noti_ex_item_h *time) {
 222   if (handle == nullptr || time == nullptr) {
 223     LOGE("Invalid parameter");
 224     return NOTI_EX_ERROR_INVALID_PARAMETER;
 225   }
 226
 227   ChatMessageItem* p = static_cast<ChatMessageItem*>(handle);
 228   *time = &(p->GetTimeItem());
 229
 230   return NOTI_EX_ERROR_NONE;
 231 }
 232
 233 extern "C" EXPORT_API int noti_ex_item_chat_message_get_message_type(
 234     noti_ex_item_h handle, noti_ex_item_chat_message_type_e *message_type) {
 235   if (handle == nullptr || message_type == nullptr) {
 236     LOGE("Invalid parameter");
 237     return NOTI_EX_ERROR_INVALID_PARAMETER;
 238   }
 239
 240   // To do
 241   //ChatMessageItem* p = static_cast<ChatMessageItem*>(handle);
 242   //*message_type = p->GetMessageType();
 243
 244   return NOTI_EX_ERROR_NONE;
 245 }
 246
 247 extern "C" EXPORT_API int noti_ex_item_checkbox_create(noti_ex_item_h *handle,
 248     const char *id, const char *title, bool checked) {
 249   CheckBoxItem* p;
 250
 251   if (handle == nullptr || title == nullptr) {
 252     LOGE("Invalid parameter");
 253     return NOTI_EX_ERROR_INVALID_PARAMETER;
 254   }
 255
 256   p = new (std::nothrow) CheckBoxItem(id, title, checked);
 257   if (p == nullptr) {
 258     LOGE("Out-of-memory");
 259     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 260   }
 261
 262   *handle = p;
 263
 264   return NOTI_EX_ERROR_NONE;
 265 }
 266
 267 extern "C" EXPORT_API int noti_ex_item_checkbox_get_title(noti_ex_item_h handle,
 268     char **title) {
 269   if (handle == nullptr || title == nullptr) {
 270     LOGE("Invalid parameter");
 271     return NOTI_EX_ERROR_INVALID_PARAMETER;
 272   }
 273
 274   CheckBoxItem* p = static_cast<CheckBoxItem*>(handle);
 275   if (!p->GetTitle().empty()) {
 276     *title = strdup(p->GetTitle().c_str());
 277     if (*title == nullptr) {
 278         LOGE("Out-of-memory");
 279         return NOTI_EX_ERROR_OUT_OF_MEMORY;
 280     }
 281   }
 282
 283   return NOTI_EX_ERROR_NONE;
 284 }
 285
 286 extern "C" EXPORT_API int noti_ex_item_checkbox_is_checked(noti_ex_item_h handle,
 287     bool *checked) {
 288   if (handle == nullptr || checked == nullptr) {
 289     LOGE("Invalid parameter");
 290     return NOTI_EX_ERROR_INVALID_PARAMETER;
 291   }
 292
 293   CheckBoxItem* p = static_cast<CheckBoxItem*>(handle);
 294   *checked = p->IsChecked();
 295
 296   return NOTI_EX_ERROR_NONE;
 297 }
 298
 299 extern "C" EXPORT_API int noti_ex_item_entry_create(noti_ex_item_h *handle,
 300     const char *id) {
 301   EntryItem* p;
 302
 303   if (handle == nullptr) {
 304     LOGE("Invalid parameter");
 305     return NOTI_EX_ERROR_INVALID_PARAMETER;
 306   }
 307
 308   p = new (std::nothrow) EntryItem(id);
 309   if (p == nullptr) {
 310     LOGE("Out-of-memory");
 311     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 312   }
 313
 314   *handle = p;
 315
 316   return NOTI_EX_ERROR_NONE;
 317 }
 318
 319 extern "C" EXPORT_API int noti_ex_item_entry_get_text(noti_ex_item_h handle,
 320     char **text) {
 321   if (handle == nullptr || text == nullptr) {
 322     LOGE("Invalid parameter");
 323     return NOTI_EX_ERROR_INVALID_PARAMETER;
 324   }
 325
 326   EntryItem* p = static_cast<EntryItem*>(handle);
 327   if (!p->GetText().empty()) {
 328     *text = strdup(p->GetText().c_str());
 329     if (*text == nullptr) {
 330         LOGE("Out-of-memory");
 331         return NOTI_EX_ERROR_OUT_OF_MEMORY;
 332     }
 333   }
 334
 335   return NOTI_EX_ERROR_NONE;
 336 }
 337
 338 extern "C" EXPORT_API int noti_ex_item_entry_set_text(noti_ex_item_h handle,
 339     const char *text) {
 340   if (handle == nullptr || text == nullptr) {
 341     LOGE("Invalid parameter");
 342     return NOTI_EX_ERROR_INVALID_PARAMETER;
 343   }
 344
 345   EntryItem* p = static_cast<EntryItem*>(handle);
 346   p->SetText(std::string(text));
 347
 348   return NOTI_EX_ERROR_NONE;
 349 }
 350
 351 extern "C" EXPORT_API int noti_ex_event_info_create(noti_ex_event_info_h *handle,
 352     noti_ex_event_info_type_e type, const char *owner,
 353     const char *channel, const char *item_id) {
 354   return NOTI_EX_ERROR_NONE;
 355 }
 356
 357 extern "C" EXPORT_API int noti_ex_event_info_destroy(
 358     noti_ex_event_info_h handle) {
 359   return NOTI_EX_ERROR_NONE;
 360 }
 361
 362 extern "C" EXPORT_API int noti_ex_event_info_get_event_type(
 363     noti_ex_event_info_h handle, noti_ex_event_info_type_e *event_type) {
 364   return NOTI_EX_ERROR_NONE;
 365 }
 366
 367 extern "C" EXPORT_API int noti_ex_event_info_get_owner(
 368     noti_ex_event_info_h handle, char **owner) {
 369   return NOTI_EX_ERROR_NONE;
 370 }
 371
 372 extern "C" EXPORT_API int noti_ex_event_info_get_channel(
 373     noti_ex_event_info_h handle, char **channel) {
 374   return NOTI_EX_ERROR_NONE;
 375 }
 376
 377 extern "C" EXPORT_API int noti_ex_event_info_get_item_id(
 378     noti_ex_event_info_h handle, char **item_id) {
 379   return NOTI_EX_ERROR_NONE;
 380 }
 381
 382 extern "C" EXPORT_API int noti_ex_event_info_get_request_id(
 383     noti_ex_event_info_h handle, int *req_id) {
 384   return NOTI_EX_ERROR_NONE;
 385 }
 386
 387 extern "C" EXPORT_API int noti_ex_item_group_create(noti_ex_item_h *handle,
 388     const char *id) {
 389   GroupItem* p;
 390
 391   if (handle == nullptr) {
 392     LOGE("Invalid parameter");
 393     return NOTI_EX_ERROR_INVALID_PARAMETER;
 394   }
 395
 396   if (id)
 397     p = new (std::nothrow) GroupItem(id);
 398   else
 399     p = new (std::nothrow) GroupItem();
 400
 401   if (p == nullptr) {
 402     LOGE("Out-of-memory");
 403     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 404   }
 405
 406   *handle = p;
 407
 408   return NOTI_EX_ERROR_NONE;
 409 }
 410
 411 extern "C" EXPORT_API int noti_ex_item_group_set_direction(noti_ex_item_h handle,
 412     bool vertical) {
 413   if (handle == nullptr) {
 414     LOGE("Invalid parameter");
 415     return NOTI_EX_ERROR_INVALID_PARAMETER;
 416   }
 417
 418   GroupItem* p = static_cast<GroupItem*>(handle);
 419   p->SetDirection(vertical);
 420
 421   return NOTI_EX_ERROR_NONE;
 422 }
 423
 424 extern "C" EXPORT_API int noti_ex_item_group_is_vertical(noti_ex_item_h handle,
 425     bool *vertical) {
 426   if (handle == nullptr) {
 427     LOGE("Invalid parameter");
 428     return NOTI_EX_ERROR_INVALID_PARAMETER;
 429   }
 430
 431   GroupItem* p = static_cast<GroupItem*>(handle);
 432   *vertical = p->IsVertical();
 433
 434   return NOTI_EX_ERROR_NONE;
 435 }
 436
 437 extern "C" EXPORT_API int noti_ex_item_group_get_app_label(noti_ex_item_h handle,
 438     char **label) {
 439   if (handle == nullptr) {
 440     LOGE("Invalid parameter");
 441     return NOTI_EX_ERROR_INVALID_PARAMETER;
 442   }
 443
 444   GroupItem* p = static_cast<GroupItem*>(handle);
 445   if (!p->GetAppLabel().empty()) {
 446     *label = strdup(p->GetAppLabel().c_str());
 447     if (*label == nullptr) {
 448       LOGE("Out-of-memory");
 449       return NOTI_EX_ERROR_OUT_OF_MEMORY;
 450     }
 451   }
 452
 453   return NOTI_EX_ERROR_NONE;
 454 }
 455
 456 extern "C" EXPORT_API int noti_ex_item_group_add_child(noti_ex_item_h handle,
 457     noti_ex_item_h child) {
 458   if (handle == nullptr || child == nullptr) {
 459     LOGE("Invalid parameter");
 460     return NOTI_EX_ERROR_INVALID_PARAMETER;
 461   }
 462
 463   // To do
 464   //GroupItem* p = static_cast<GroupItem*>(handle);
 465   //p->AddChild(static_cast<AbstractItem*>(child));
 466
 467   return NOTI_EX_ERROR_NONE;
 468 }
 469
 470 extern "C" EXPORT_API int noti_ex_item_group_remove_child(noti_ex_item_h handle,
 471     const char *item_id) {
 472   if (handle == nullptr || item_id == nullptr) {
 473     LOGE("Invalid parameter");
 474     return NOTI_EX_ERROR_INVALID_PARAMETER;
 475   }
 476
 477   GroupItem* p = static_cast<GroupItem*>(handle);
 478   p->RemoveChild(std::string(item_id));
 479
 480   return NOTI_EX_ERROR_NONE;
 481 }
 482
 483 extern "C" EXPORT_API int noti_ex_item_group_foreach(
 484     noti_ex_item_group_foreach_cb callback, void *data) {
 485   return 0;
 486 }
 487
 488 extern "C" EXPORT_API int noti_ex_item_image_create(noti_ex_item_h *handle,
 489     const char *id, const char *image_path) {
 490   ImageItem* p;
 491
 492   if (handle == nullptr  || image_path == nullptr) {
 493     LOGE("Invalid parameter");
 494     return NOTI_EX_ERROR_INVALID_PARAMETER;
 495   }
 496
 497   if (id)
 498     p = new (std::nothrow) ImageItem(id, image_path);
 499   else
 500     p = new (std::nothrow) ImageItem(image_path);
 501
 502   if (p == nullptr) {
 503     LOGE("Out-of-memory");
 504     return NOTI_EX_ERROR_OUT_OF_MEMORY;
 505   }
 506
 507   *handle = p;
 508
 509   return NOTI_EX_ERROR_NONE;
 510 }
 511
 512 extern "C" EXPORT_API int noti_ex_item_image_get_image_path(
 513     noti_ex_item_h handle, char **image_path) {
 514   if (handle == nullptr || image_path == nullptr) {
 515     LOGE("Invalid parameter");
 516     return NOTI_EX_ERROR_INVALID_PARAMETER;
 517   }
 518
 519   ImageItem* p = static_cast<ImageItem*>(handle);
 520   if (!p->GetImagePath().empty()) {
 521     *image_path = strdup(p->GetImagePath().c_str());
 522     if (*image_path == nullptr) {
 523       LOGE("Out-of-memory");
 524       return NOTI_EX_ERROR_OUT_OF_MEMORY;
 525     }
 526   }
 527
 528   return NOTI_EX_ERROR_NONE;
 529 }
 530
 531 extern "C" EXPORT_API int noti_ex_item_input_selector_create(
 532     noti_ex_item_h *handle, const char *id) {
 533   return 0;
 534 }
 535
 536 extern "C" EXPORT_API int noti_ex_item_input_selector_get_contents(
 537     noti_ex_item_h handle, char ***list, int *count) {
 538   return 0;
 539 }
 540
 541 extern "C" EXPORT_API int noti_ex_item_input_selector_set_contents(
 542     noti_ex_item_h handle, const char **contents, int count) {
 543   return 0;
 544 }
 545
 546 extern "C" EXPORT_API int noti_ex_color_create(noti_ex_color_h *handle,
 547     unsigned char a, unsigned char r, unsigned char g, unsigned char b) {
 548   return 0;
 549 }
 550
 551 extern "C" EXPORT_API int noti_ex_color_destroy(noti_ex_color_h handle) {
 552   return 0;
 553 }
 554
 555 extern "C" EXPORT_API int noti_ex_color_get_alpha(noti_ex_color_h handle,
 556     unsigned char *val) {
 557   return 0;
 558 }
 559
 560 extern "C" EXPORT_API int noti_ex_color_get_red(noti_ex_color_h handle,
 561     unsigned char *val) {
 562   return 0;
 563 }
 564
 565 extern "C" EXPORT_API int noti_ex_color_get_green(noti_ex_color_h handle,
 566     unsigned char *val) {
 567   return 0;
 568 }
 569
 570 extern "C" EXPORT_API int noti_ex_color_get_blue(noti_ex_color_h handle,
 571     unsigned char *val) {
 572   return 0;
 573 }
 574
 575 extern "C" EXPORT_API int noti_ex_padding_create(noti_ex_padding_h *handle,
 576     int left, int top, int right, int bottom) {
 577   return 0;
 578 }
 579
 580 extern "C" EXPORT_API int noti_ex_padding_destroy(noti_ex_padding_h handle) {
 581   return 0;
 582 }
 583
 584 extern "C" EXPORT_API int noti_ex_padding_get_left(noti_ex_padding_h handle,
 585     int *val) {
 586   return 0;
 587 }
 588
 589 extern "C" EXPORT_API int noti_ex_padding_get_top(noti_ex_padding_h handle,
 590     int *val) {
 591   return 0;
 592 }
 593
 594 extern "C" EXPORT_API int noti_ex_padding_get_right(noti_ex_padding_h handle,
 595     int *val) {
 596   return 0;
 597 }
 598
 599 extern "C" EXPORT_API int noti_ex_padding_get_bottom(noti_ex_padding_h handle,
 600     int *val) {
 601   return 0;
 602 }
 603
 604 extern "C" EXPORT_API int noti_ex_geometry_create(noti_ex_geometry_h *handle,
 605     int x, int y, int w, int h) {
 606   return 0;
 607 }
 608
 609 extern "C" EXPORT_API int noti_ex_geometry_destroy(noti_ex_geometry_h handle) {
 610   return 0;
 611 }
 612
 613 extern "C" EXPORT_API int noti_ex_geometry_get_x(noti_ex_geometry_h handle,
 614     int *val) {
 615   return 0;
 616 }
 617
 618 extern "C" EXPORT_API int noti_ex_geometry_get_y(noti_ex_geometry_h handle,
 619     int *val) {
 620   return 0;
 621 }
 622
 623 extern "C" EXPORT_API int noti_ex_geometry_get_width(noti_ex_geometry_h handle,
 624     int *val) {
 625   return 0;
 626 }
 627
 628 extern "C" EXPORT_API int noti_ex_geometry_get_height(noti_ex_geometry_h handle,
 629     int *val) {
 630   return 0;
 631 }
 632
 633 extern "C" EXPORT_API int noti_ex_style_create(noti_ex_style_h *handle,
 634     noti_ex_color_h color,
 635     noti_ex_padding_h padding,
 636     noti_ex_geometry_h geometry) {
 637   return 0;
 638 }
 639
 640 extern "C" EXPORT_API int noti_ex_style_destroy(noti_ex_style_h handle) {
 641   return 0;
 642 }
 643
 644 extern "C" EXPORT_API int noti_ex_style_get_padding(noti_ex_style_h handle,
 645     const noti_ex_padding_h *padding) {
 646   return 0;
 647 }
 648
 649 extern "C" EXPORT_API int noti_ex_style_get_color(noti_ex_style_h handle,
 650     const noti_ex_color_h *color) {
 651   return 0;
 652 }
 653
 654 extern "C" EXPORT_API int noti_ex_style_get_geometry(noti_ex_style_h handle,
 655     const noti_ex_geometry_h *geometry) {
 656   return 0;
 657 }
 658
 659 extern "C" EXPORT_API int noti_ex_led_info_create(noti_ex_led_info_h *handle,
 660     noti_ex_color_h color) {
 661   return 0;
 662 }
 663
 664 extern "C" EXPORT_API int noti_ex_led_info_destroy(noti_ex_led_info_h handle) {
 665   return 0;
 666 }
 667
 668 extern "C" EXPORT_API int noti_ex_led_info_set_on_period(
 669     noti_ex_led_info_h handle, int ms) {
 670   return 0;
 671 }
 672
 673 extern "C" EXPORT_API int noti_ex_led_info_get_on_period(
 674     noti_ex_led_info_h handle, int *ms) {
 675   return 0;
 676 }
 677
 678 extern "C" EXPORT_API int noti_ex_led_info_set_off_period(
 679     noti_ex_led_info_h handle, int ms) {
 680   return 0;
 681 }
 682
 683 extern "C" EXPORT_API int noti_ex_led_info_get_off_period(
 684     noti_ex_led_info_h handle, int *ms) {
 685   return 0;
 686 }
 687
 688 extern "C" EXPORT_API int noti_ex_led_info_get_color(
 689     noti_ex_led_info_h handle, noti_ex_color_h *color) {
 690   return 0;
 691 }
 692
 693 extern "C" EXPORT_API int noti_ex_action_destroy(noti_ex_action_h handle) {
 694   return 0;
 695 }
 696
 697 extern "C" EXPORT_API int noti_ex_action_get_type(noti_ex_action_h handle,
 698     int *type) {
 699   return 0;
 700 }
 701
 702 extern "C" EXPORT_API int noti_ex_action_is_local(noti_ex_action_h handle,
 703     bool *local) {
 704   return 0;
 705 }
 706
 707 extern "C" EXPORT_API int noti_ex_action_execute(noti_ex_action_h handle,
 708     noti_ex_item_h item) {
 709   return 0;
 710 }
 711
 712 extern "C" EXPORT_API int noti_ex_action_get_extra(noti_ex_action_h handle,
 713     char **extra) {
 714   return 0;
 715 }
 716
 717 extern "C" EXPORT_API int noti_ex_item_info_get_hide_time(
 718     noti_ex_item_info_h handle, int *hide_time) {
 719   return 0;
 720 }
 721
 722 extern "C" EXPORT_API int noti_ex_item_info_set_hide_time(
 723     noti_ex_item_info_h handle, int hide_time) {
 724   return 0;
 725 }
 726
 727 extern "C" EXPORT_API int noti_ex_item_info_get_delete_time(
 728     noti_ex_item_info_h handle, int *delete_time) {
 729   return 0;
 730 }
 731
 732 extern "C" EXPORT_API int noti_ex_item_info_set_delete_time(
 733     noti_ex_item_info_h handle, int delete_time) {
 734   return 0;
 735 }
 736
 737 extern "C" EXPORT_API int noti_ex_item_info_get_time(
 738     noti_ex_item_info_h handle, time_t *time) {
 739   return 0;
 740 }
 741
 742 extern "C" EXPORT_API int noti_ex_item_destroy(noti_ex_item_h handle) {
 743   return 0;
 744 }
 745
 746 extern "C" EXPORT_API int noti_ex_item_find_by_id(noti_ex_item_h handle,
 747     const char *id, const noti_ex_item_h *item) {
 748   return 0;
 749 }
 750
 751 extern "C" EXPORT_API int noti_ex_item_get_type(noti_ex_item_h handle,
 752     int *type) {
 753   return 0;
 754 }
 755
 756 extern "C" EXPORT_API int noti_ex_item_get_shared_path(noti_ex_item_h handle,
 757     char ***path, int *count) {
 758   return 0;
 759 }
 760
 761 extern "C" EXPORT_API int noti_ex_item_get_id(noti_ex_item_h handle,
 762     char **id) {
 763   return 0;
 764 }
 765
 766 extern "C" EXPORT_API int noti_ex_item_set_id(noti_ex_item_h handle,
 767     const char *id) {
 768   return 0;
 769 }
 770
 771 extern "C" EXPORT_API int noti_ex_item_get_action(noti_ex_item_h handle,
 772     noti_ex_action_h *action) {
 773   return 0;
 774 }
 775
 776 extern "C" EXPORT_API int noti_ex_item_set_action(noti_ex_item_h handle,
 777     noti_ex_action_h action) {
 778   return 0;
 779 }
 780
 781 extern "C" EXPORT_API int noti_ex_item_get_style(noti_ex_item_h handle,
 782     noti_ex_style_h *style) {
 783   return 0;
 784 }
 785
 786 extern "C" EXPORT_API int noti_ex_item_set_style(noti_ex_item_h handle,
 787     noti_ex_style_h style) {
 788   return 0;
 789 }
 790
 791 extern "C" EXPORT_API int noti_ex_item_set_visible(noti_ex_item_h handle,
 792     bool visible) {
 793   return 0;
 794 }
 795
 796 extern "C" EXPORT_API int noti_ex_item_get_visible(noti_ex_item_h handle,
 797     bool *visible) {
 798   return 0;
 799 }
 800
 801 extern "C" EXPORT_API int noti_ex_item_set_enable(noti_ex_item_h handle,
 802     bool enable) {
 803   return 0;
 804 }
 805
 806 extern "C" EXPORT_API int noti_ex_item_get_enable(noti_ex_item_h handle,
 807     bool *enable) {
 808   return 0;
 809 }
 810
 811 extern "C" EXPORT_API int noti_ex_item_add_receiver(noti_ex_item_h handle,
 812     const char *receiver_group) {
 813   return 0;
 814 }
 815
 816 extern "C" EXPORT_API int noti_ex_item_remove_receiver(noti_ex_item_h handle,
 817     const char *receiver_group) {
 818   return 0;
 819 }
 820
 821 extern "C" EXPORT_API int noti_ex_item_get_receiver_list(noti_ex_item_h handle,
 822     char ***list, int *count) {
 823   return 0;
 824 }
 825
 826 extern "C" EXPORT_API int noti_ex_item_set_policy(noti_ex_item_h handle,
 827     int policy) {
 828   return 0;
 829 }
 830
 831 extern "C" EXPORT_API int noti_ex_item_get_policy(noti_ex_item_h handle,
 832     int *policy) {
 833   return 0;
 834 }
 835
 836 extern "C" EXPORT_API int noti_ex_item_get_channel(noti_ex_item_h handle,
 837     char **channel) {
 838   return 0;
 839 }
 840
 841 extern "C" EXPORT_API int noti_ex_item_set_channel(noti_ex_item_h handle,
 842     const char *channel) {
 843   return 0;
 844 }
 845
 846 extern "C" EXPORT_API int noti_ex_item_set_led_info(noti_ex_item_h handle,
 847     noti_ex_led_info_h led) {
 848   return 0;
 849 }
 850
 851 extern "C" EXPORT_API int noti_ex_item_get_led_info(noti_ex_item_h handle,
 852     noti_ex_led_info_h *led) {
 853   return 0;
 854 }
 855
 856 extern "C" EXPORT_API int noti_ex_item_set_sound_path(noti_ex_item_h handle,
 857     const char *path) {
 858   return 0;
 859 }
 860
 861 extern "C" EXPORT_API int noti_ex_item_set_vibration_path(noti_ex_item_h handle,
 862     const char *path) {
 863   return 0;
 864 }
 865
 866 extern "C" EXPORT_API int noti_ex_item_get_sound_path(noti_ex_item_h handle,
 867     char **path) {
 868   return 0;
 869 }
 870
 871 extern "C" EXPORT_API int noti_ex_item_get_vibration_path(noti_ex_item_h handle,
 872     char **path) {
 873   return 0;
 874 }
 875
 876 extern "C" EXPORT_API int noti_ex_item_get_info(noti_ex_item_h handle,
 877     noti_ex_item_info_h *info) {
 878   return 0;
 879 }
 880
 881 extern "C" EXPORT_API int noti_ex_item_get_sender_app_id(noti_ex_item_h handle,
 882     char **id) {
 883   return 0;
 884 }
 885
 886 extern "C" EXPORT_API int noti_ex_item_set_sender_app_id(noti_ex_item_h handle,
 887     const char *id) {
 888   return 0;
 889 }
 890
 891 extern "C" EXPORT_API int noti_ex_item_get_tag(noti_ex_item_h handle,
 892     char **tag) {
 893   return 0;
 894 }
 895
 896 extern "C" EXPORT_API int noti_ex_item_set_tag(noti_ex_item_h handle,
 897     const char *tag) {
 898   return 0;
 899 }
 900
 901 extern "C" EXPORT_API int noti_ex_manager_create(noti_ex_manager_h *handle,
 902     const char *receiver_group, noti_ex_manager_events_s ev, void *data) {
 903   return 0;
 904 }
 905
 906 extern "C" EXPORT_API int noti_ex_manager_deatroy(noti_ex_manager_h handle) {
 907   return 0;
 908 }
 909
 910 extern "C" EXPORT_API int noti_ex_manager_get(noti_ex_manager_h handle,
 911     noti_ex_item_h *items, int *cnt) {
 912   return 0;
 913 }
 914
 915 extern "C" EXPORT_API int noti_ex_manager_update(noti_ex_manager_h handle,
 916     noti_ex_item_h noti) {
 917   return 0;
 918 }
 919
 920 extern "C" EXPORT_API int noti_ex_manager_delete(noti_ex_manager_h handle,
 921     noti_ex_item_h noti) {
 922   return 0;
 923 }
 924
 925 extern "C" EXPORT_API int noti_ex_manager_delete_all(noti_ex_manager_h handle) {
 926   return 0;
 927 }
 928
 929 extern "C" EXPORT_API int noti_ex_manager_hide(noti_ex_manager_h handle,
 930     noti_ex_item_h noti) {
 931   return 0;
 932 }
 933
 934 extern "C" EXPORT_API int noti_ex_manager_find_by_root_id(
 935     noti_ex_manager_h handle, const char *id, noti_ex_item_h *item) {
 936   return 0;
 937 }
 938
 939 extern "C" EXPORT_API int noti_ex_manager_send_event(noti_ex_manager_h handle,
 940     noti_ex_event_info_h info, noti_ex_item_h noti) {
 941   return 0;
 942 }
 943
 944 extern "C" EXPORT_API int noti_ex_manager_send_error(noti_ex_manager_h handle,
 945     noti_ex_event_info_h info, noti_ex_error_e error) {
 946   return 0;
 947 }
 948
 949 extern "C" EXPORT_API int noti_ex_manager_get_count(noti_ex_manager_h handle,
 950     int *cnt) {
 951   return 0;
 952 }
 953
 954 extern "C" EXPORT_API int noti_ex_item_progress_create(noti_ex_item_h *handle,
 955     const char *id, float min, float current, float max) {
 956   return 0;
 957 }
 958
 959 extern "C" EXPORT_API int noti_ex_item_progress_get_current(
 960     noti_ex_item_h handle, float *current) {
 961   return 0;
 962 }
 963
 964 extern "C" EXPORT_API int noti_ex_item_progress_set_current(
 965     noti_ex_item_h handle, float current) {
 966   return 0;
 967 }
 968
 969 extern "C" EXPORT_API int noti_ex_item_progress_get_min(noti_ex_item_h handle,
 970     float *min) {
 971   return 0;
 972 }
 973
 974 extern "C" EXPORT_API int noti_ex_item_progress_get_max(noti_ex_item_h handle,
 975     float *max) {
 976   return 0;
 977 }
 978
 979 extern "C" EXPORT_API int noti_ex_reporter_send_event(noti_ex_reporter_h handle,
 980     noti_ex_event_info_h info, noti_ex_item_h noti) {
 981   return 0;
 982 }
 983
 984 extern "C" EXPORT_API int noti_ex_reporter_send_error(noti_ex_reporter_h handle,
 985     noti_ex_event_info_h info, noti_ex_error_e error) {
 986   return 0;
 987 }
 988
 989 extern "C" EXPORT_API int noti_ex_reporter_post(noti_ex_reporter_h handle,
 990     noti_ex_item_h noti) {
 991   return 0;
 992 }
 993
 994 extern "C" EXPORT_API int noti_ex_reporter_post_list(noti_ex_reporter_h handle,
 995     noti_ex_item_h *notiList, int cnt) {
 996   return 0;
 997 }
 998
 999 extern "C" EXPORT_API int noti_ex_reporter_update(noti_ex_reporter_h handle,
1000     noti_ex_item_h noti) {
1001   return 0;
1002 }
1003
1004 extern "C" EXPORT_API int noti_ex_reporter_delete(noti_ex_reporter_h handle,
1005     noti_ex_item_h noti) {
1006   return 0;
1007 }
1008
1009 extern "C" EXPORT_API int noti_ex_reporter_delete_all(
1010     noti_ex_reporter_h handle) {
1011   return 0;
1012 }
1013
1014 extern "C" EXPORT_API int noti_ex_reporter_find_by_root_id(
1015     noti_ex_reporter_h handle, const char *id, const noti_ex_item_h *item) {
1016   return 0;
1017 }
1018
1019 extern "C" EXPORT_API int noti_ex_item_text_create(noti_ex_item_h *handle,
1020     const char *id, const char *text, const char *hyper_link) {
1021   return 0;
1022 }
1023
1024 extern "C" EXPORT_API int noti_ex_item_text_set_contents(noti_ex_item_h handle,
1025     const char *contents) {
1026   return 0;
1027 }
1028
1029 extern "C" EXPORT_API int noti_ex_item_text_get_contents(noti_ex_item_h handle,
1030     char **contents) {
1031   return 0;
1032 }
1033
1034 extern "C" EXPORT_API int noti_ex_item_text_get_hyper_link(
1035     noti_ex_item_h handle, char **hyper_link) {
1036   return 0;
1037 }
1038
1039 extern "C" EXPORT_API int noti_ex_item_time_create(noti_ex_item_h *handle,
1040     const char *id, time_t time) {
1041   return 0;
1042 }
1043
1044 extern "C" EXPORT_API int noti_ex_item_time_get_time(noti_ex_item_h handle,
1045     time_t *time) {
1046   return 0;
1047 }
1048
1049 extern "C" EXPORT_API int noti_ex_action_visibility_create(
1050     noti_ex_action_h *handle, const char *extra) {
1051   return 0;
1052 }
1053
1054 extern "C" EXPORT_API int noti_ex_action_visibility_set(noti_ex_action_h handle,
1055     const char *id, bool visible) {
1056   return 0;
1057 }