src/livebox.c

   1 /*
   2  * Copyright 2013  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <errno.h>
  19 #include <stdlib.h> /* malloc */
  20 #include <string.h> /* strdup */
  21 #include <math.h>
  22
  23 #include <aul.h>
  24 #include <dlog.h>
  25
  26 #include <com-core_packet.h>
  27 #include <packet.h>
  28 #include <livebox-service.h>
  29 #include <livebox-errno.h>
  30
  31 #include "debug.h"
  32 #include "fb.h"
  33 #include "livebox.h"
  34 #include "livebox_internal.h"
  35 #include "dlist.h"
  36 #include "util.h"
  37 #include "master_rpc.h"
  38 #include "client.h"
  39 #include "critical_log.h"
  40
  41 #define EAPI __attribute__((visibility("default")))
  42 #define MINIMUM_EVENT   s_info.event_filter
  43
  44 #if defined(FLOG)
  45 FILE *__file_log_fp;
  46 #endif
  47
  48 static struct info {
  49         struct dlist *livebox_list;
  50         struct dlist *event_list;
  51         struct dlist *fault_list;
  52         int init_count;
  53         int prevent_overwrite;
  54         double event_filter;
  55 } s_info = {
  56         .livebox_list = NULL,
  57         .event_list = NULL,
  58         .fault_list = NULL,
  59         .init_count = 0,
  60         .prevent_overwrite = 0,
  61         .event_filter = 0.02f,
  62 };
  63
  64 struct cb_info {
  65         ret_cb_t cb;
  66         void *data;
  67 };
  68
  69 struct event_info {
  70         int (*handler)(struct livebox *handler, enum livebox_event_type event, void *data);
  71         void *user_data;
  72 };
  73
  74 struct fault_info {
  75         int (*handler)(enum livebox_fault_type event, const char *pkgname, const char *filename, const char *func, void *data);
  76         void *user_data;
  77 };
  78
  79 static inline void default_create_cb(struct livebox *handler, int ret, void *data)
  80 {
  81         DbgPrint("Default created event handler: %d\n", ret);
  82 }
  83
  84 static inline void default_delete_cb(struct livebox *handler, int ret, void *data)
  85 {
  86         DbgPrint("Default deleted event handler: %d\n", ret);
  87 }
  88
  89 static inline void default_pinup_cb(struct livebox *handler, int ret, void *data)
  90 {
  91         DbgPrint("Default pinup event handler: %d\n", ret);
  92 }
  93
  94 static inline void default_group_changed_cb(struct livebox *handler, int ret, void *data)
  95 {
  96         DbgPrint("Default group changed event handler: %d\n", ret);
  97 }
  98
  99 static inline void default_period_changed_cb(struct livebox *handler, int ret, void *data)
 100 {
 101         DbgPrint("Default period changed event handler: %d\n", ret);
 102 }
 103
 104 static inline void default_pd_created_cb(struct livebox *handler, int ret, void *data)
 105 {
 106         DbgPrint("Default PD created event handler: %d\n", ret);
 107 }
 108
 109 static inline void default_pd_destroyed_cb(struct livebox *handler, int ret, void *data)
 110 {
 111         DbgPrint("Default PD destroyed event handler: %d\n", ret);
 112 }
 113
 114 static inline void default_lb_size_changed_cb(struct livebox *handler, int ret, void *data)
 115 {
 116         DbgPrint("Default LB size changed event handler: %d\n", ret);
 117 }
 118
 119 static inline void default_update_mode_cb(struct livebox *handler, int ret, void *data)
 120 {
 121         DbgPrint("Default update mode set event handler: %d\n", ret);
 122 }
 123
 124 static inline void default_access_event_cb(struct livebox *handler, int ret, void *data)
 125 {
 126         DbgPrint("Default access event handler: %d\n", ret);
 127 }
 128
 129 static inline __attribute__((always_inline)) struct cb_info *create_cb_info(ret_cb_t cb, void *data)
 130 {
 131         struct cb_info *info;
 132
 133         info = malloc(sizeof(*info));
 134         if (!info) {
 135                 CRITICAL_LOG("Heap: %s\n", strerror(errno));
 136                 return NULL;
 137         }
 138
 139         info->cb = cb;
 140         info->data = data;
 141         return info;
 142 }
 143
 144 static inline void destroy_cb_info(struct cb_info *info)
 145 {
 146         free(info);
 147 }
 148
 149 static void update_mode_cb(struct livebox *handler, const struct packet *result, void *data)
 150 {
 151         int ret;
 152
 153         if (!result) {
 154                 ret = LB_STATUS_ERROR_FAULT;
 155                 goto errout;
 156         } else if (packet_get(result, "i", &ret) != 1) {
 157                 ErrPrint("Invalid argument\n");
 158                 ret = LB_STATUS_ERROR_INVALID;
 159                 goto errout;
 160         }
 161
 162         if (ret < 0) {
 163                 DbgPrint("Resize request is failed: %d\n", ret);
 164                 goto errout;
 165         }
 166
 167         return;
 168
 169 errout:
 170         handler->update_mode_cb(handler, ret, handler->update_mode_cbdata);
 171         handler->update_mode_cb = NULL;
 172         handler->update_mode_cbdata = NULL;
 173         return;
 174 }
 175
 176 static void resize_cb(struct livebox *handler, const struct packet *result, void *data)
 177 {
 178         int ret;
 179         struct cb_info *info = data;
 180         ret_cb_t cb;
 181         void *cbdata;
 182
 183         cb = info->cb;
 184         cbdata = info->data;
 185         destroy_cb_info(info);
 186
 187         if (!result) {
 188                 ret = LB_STATUS_ERROR_FAULT;
 189                 goto errout;
 190         } else if (packet_get(result, "i", &ret) != 1) {
 191                 ErrPrint("Invalid argument\n");
 192                 ret = LB_STATUS_ERROR_INVALID;
 193                 goto errout;
 194         }
 195
 196         /*!
 197          * \note
 198          * In case of resize request,
 199          * The livebox handler will not have resized value right after this callback,
 200          * It can only get the new size when it makes updates.
 201          *
 202          * So the user can only get the resized value(result) from the first update event
 203          * after this request.
 204          */
 205         if (ret < 0) {
 206                 DbgPrint("Resize request is failed: %d\n", ret);
 207                 goto errout;
 208         }
 209
 210         DbgPrint("Resize request is successfully sent\n");
 211         return;
 212
 213 errout:
 214         handler->size_changed_cb(handler, ret, handler->size_cbdata);
 215         handler->size_changed_cb = NULL;
 216         handler->size_cbdata = NULL;
 217 }
 218
 219 static void text_signal_cb(struct livebox *handler, const struct packet *result, void *data)
 220 {
 221         int ret;
 222         void *cbdata;
 223         struct cb_info *info = data;
 224         ret_cb_t cb;
 225
 226         cbdata = info->data;
 227         cb = info->cb;
 228         destroy_cb_info(info);
 229
 230         if (!result) {
 231                 ret = LB_STATUS_ERROR_FAULT;
 232         } else if (packet_get(result, "i", &ret) != 1) {
 233                 ErrPrint("Invalid argument\n");
 234                 ret = LB_STATUS_ERROR_INVALID;
 235         }
 236
 237         if (cb)
 238                 cb(handler, ret, cbdata);
 239         return;
 240 }
 241
 242 static void set_group_ret_cb(struct livebox *handler, const struct packet *result, void *data)
 243 {
 244         int ret;
 245
 246         if (!result) {
 247                 ret = LB_STATUS_ERROR_FAULT;
 248                 goto errout;
 249         } else if (packet_get(result, "i", &ret) != 1) {
 250                 ErrPrint("Invalid argument\n");
 251                 ret = LB_STATUS_ERROR_INVALID;
 252                 goto errout;
 253         }
 254
 255         if (ret < 0)
 256                 goto errout;
 257
 258         return;
 259
 260 errout:
 261         handler->group_changed_cb(handler, ret, handler->group_cbdata);
 262         handler->group_changed_cb = NULL;
 263         handler->group_cbdata = NULL;
 264 }
 265
 266 static void period_ret_cb(struct livebox *handler, const struct packet *result, void *data)
 267 {
 268         int ret;
 269
 270         if (!result) {
 271                 ret = LB_STATUS_ERROR_FAULT;
 272                 goto errout;
 273         } else if (packet_get(result, "i", &ret) != 1) {
 274                 ErrPrint("Invalid argument\n");
 275                 ret = LB_STATUS_ERROR_INVALID;
 276                 goto errout;
 277         }
 278
 279         if (ret < 0)
 280                 goto errout;
 281
 282         DbgPrint("Succeed to send period change request, waiting result\n");
 283         return;
 284
 285 errout:
 286         handler->period_changed_cb(handler, ret, handler->period_cbdata);
 287         handler->period_changed_cb = NULL;
 288         handler->period_cbdata = NULL;
 289 }
 290
 291 static void del_ret_cb(struct livebox *handler, const struct packet *result, void *data)
 292 {
 293         struct cb_info *info = data;
 294         int ret;
 295         ret_cb_t cb;
 296         void *cbdata;
 297
 298         cb = info->cb;
 299         cbdata = info->data;
 300         destroy_cb_info(info);
 301
 302         if (!result) {
 303                 ErrPrint("Connection lost?\n");
 304                 ret = LB_STATUS_ERROR_FAULT;
 305         } else if (packet_get(result, "i", &ret) != 1) {
 306                 ErrPrint("Invalid argument\n");
 307                 ret = LB_STATUS_ERROR_INVALID;
 308         }
 309
 310         if (ret == 0) {
 311                 DbgPrint("Returns %d (waiting deleted event)\n", ret);
 312                 handler->deleted_cb = cb;
 313                 handler->deleted_cbdata = cbdata;
 314         } else if (cb) {
 315                 cb(handler, ret, cbdata);
 316         }
 317
 318         /*!
 319          * \note
 320          * Do not call the deleted callback from here.
 321          * master will send the "deleted" event.
 322          * Then invoke this callback.
 323          *
 324          * if (handler->deleted_cb)
 325          *      handler->deleted_cb(handler, ret, handler->deleted_cbdata);
 326          */
 327 }
 328
 329 static void new_ret_cb(struct livebox *handler, const struct packet *result, void *data)
 330 {
 331         int ret;
 332         struct cb_info *info = data;
 333         ret_cb_t cb;
 334         void *cbdata;
 335
 336         cb = info->cb;
 337         cbdata = info->data;
 338         destroy_cb_info(info);
 339
 340         if (!result) {
 341                 ret = LB_STATUS_ERROR_FAULT;
 342         } else if (packet_get(result, "i", &ret) != 1) {
 343                 ret = LB_STATUS_ERROR_INVALID;
 344         }
 345
 346         if (ret >= 0) {
 347                 DbgPrint("new request is sent, just waiting the created event\n");
 348                 handler->created_cb = cb;
 349                 handler->created_cbdata = cbdata;
 350
 351                 /*!
 352                  * \note
 353                  * Don't go anymore ;)
 354                  */
 355                 return;
 356         } else if (cb) {
 357                 /*!
 358                  * \note
 359                  * It means the current instance is not created,
 360                  * so user has to know about this.
 361                  * notice it to user using "deleted" event.
 362                  */
 363                 cb(handler, ret, cbdata);
 364         }
 365
 366         lb_unref(handler);
 367 }
 368
 369 static void pd_create_cb(struct livebox *handler, const struct packet *result, void *data)
 370 {
 371         int ret;
 372
 373         if (!result) {
 374                 ret = LB_STATUS_ERROR_FAULT;
 375                 goto errout;
 376         } else if (packet_get(result, "i", &ret) != 1) {
 377                 ret = LB_STATUS_ERROR_INVALID;
 378                 goto errout;
 379         }
 380
 381         if (ret < 0) {
 382                 DbgPrint("Failed to create a PD\n");
 383                 goto errout;
 384         }
 385
 386         return;
 387
 388 errout:
 389         handler->pd_created_cb(handler, ret, handler->pd_created_cbdata);
 390         handler->pd_created_cb = NULL;
 391         handler->pd_created_cbdata = NULL;
 392 }
 393
 394 static void activated_cb(struct livebox *handler, const struct packet *result, void *data)
 395 {
 396         int ret;
 397         struct cb_info *info = data;
 398         void *cbdata;
 399         ret_cb_t cb;
 400         const char *pkgname = "";
 401
 402         cbdata = info->data;
 403         cb = info->cb;
 404         destroy_cb_info(info);
 405
 406         if (!result) {
 407                 ret = LB_STATUS_ERROR_FAULT;
 408         } else if (packet_get(result, "is", &ret, &pkgname) != 2) {
 409                 ret = LB_STATUS_ERROR_INVALID;
 410         }
 411
 412         if (cb)
 413                 cb(handler, ret, cbdata);
 414 }
 415
 416 static void pd_destroy_cb(struct livebox *handler, const struct packet *result, void *data)
 417 {
 418         int ret;
 419         ret_cb_t cb;
 420         void *cbdata;
 421         struct cb_info *info = data;
 422
 423         cbdata = info->data;
 424         cb = info->cb;
 425         destroy_cb_info(info);
 426
 427         if (!result) {
 428                 DbgPrint("Result is NIL (may connection lost)\n");
 429                 ret = LB_STATUS_ERROR_FAULT;
 430         } else if (packet_get(result, "i", &ret) != 1) {
 431                 DbgPrint("Invalid parameter\n");
 432                 ret = LB_STATUS_ERROR_INVALID;
 433         }
 434
 435         if (ret == 0) {
 436                 DbgPrint("PD Destroyed callback prepared\n");
 437                 handler->pd_destroyed_cb = cb;
 438                 handler->pd_destroyed_cbdata = cbdata;
 439         } else if (cb) {
 440                 DbgPrint("PD is not desroyed (forcely reset, pd flag)\n");
 441                 handler->is_pd_created = 0;
 442                 cb(handler, ret, cbdata);
 443         }
 444 }
 445
 446 static void delete_cluster_cb(struct livebox *handler, const struct packet *result, void *data)
 447 {
 448         struct cb_info *info = data;
 449         int ret;
 450         ret_cb_t cb;
 451         void *cbdata;
 452
 453         cb = info->cb;
 454         cbdata = info->data;
 455         destroy_cb_info(info);
 456
 457         if (!result) {
 458                 ret = LB_STATUS_ERROR_FAULT;
 459         } else if (packet_get(result, "i", &ret) != 1) {
 460                 ret = LB_STATUS_ERROR_INVALID;
 461         }
 462
 463         DbgPrint("Delete category returns: %d\n", ret);
 464
 465         if (cb)
 466                 cb(handler, ret, cbdata);
 467 }
 468
 469 static void delete_category_cb(struct livebox *handler, const struct packet *result, void *data)
 470 {
 471         struct cb_info *info = data;
 472         int ret;
 473         ret_cb_t cb;
 474         void *cbdata;
 475
 476         cb = info->cb;
 477         cbdata = info->data;
 478         destroy_cb_info(info);
 479
 480         if (!result)
 481                 ret = LB_STATUS_ERROR_FAULT;
 482         else if (packet_get(result, "i", &ret) != 1)
 483                 ret = LB_STATUS_ERROR_INVALID;
 484
 485         DbgPrint("Delete category returns: %d\n", ret);
 486
 487         if (cb)
 488                 cb(handler, ret, cbdata);
 489 }
 490
 491 static void pixmap_acquired_cb(struct livebox *handler, const struct packet *result, void *data)
 492 {
 493         int ret;
 494         ret_cb_t cb;
 495         void *cbdata;
 496         struct cb_info *info = data;
 497
 498         cb = info->cb;
 499         cbdata = info->data;
 500         destroy_cb_info(info);
 501
 502         if (!result)
 503                 ret = 0; /* PIXMAP 0 means error */
 504         else if (packet_get(result, "i", &ret) != 1)
 505                 ret = 0;
 506
 507         if (cb)
 508                 cb(handler, ret, cbdata);
 509 }
 510
 511 static void pinup_done_cb(struct livebox *handler, const struct packet *result, void *data)
 512 {
 513         int ret;
 514
 515         if (!result) {
 516                 ret = LB_STATUS_ERROR_FAULT;
 517                 goto errout;
 518         } else if (packet_get(result, "i", &ret) != 1) {
 519                 goto errout;
 520         }
 521
 522         if (ret < 0)
 523                 goto errout;
 524
 525         return;
 526
 527 errout:
 528         handler->pinup_cb(handler, ret, handler->pinup_cbdata);
 529         handler->pinup_cb = NULL;
 530         handler->pinup_cbdata = NULL;
 531 }
 532
 533 static void access_ret_cb(struct livebox *handler, const struct packet *result, void *data)
 534 {
 535         int ret;
 536
 537         if (!result) {
 538                 ret = LB_STATUS_ERROR_FAULT;
 539                 return;
 540         }
 541
 542         if (packet_get(result, "i", &ret) != 1) {
 543                 ret = LB_STATUS_ERROR_INVALID;
 544                 return;
 545         }
 546
 547         if (ret != LB_STATUS_SUCCESS) {
 548                 goto errout;
 549         }
 550
 551         DbgPrint("Access event is successfully sent. waiting result\n");
 552         return;
 553
 554 errout:
 555         handler->access_event_cb(handler, ret, handler->access_event_cbdata);
 556         handler->access_event_cb = NULL;
 557         handler->access_event_cbdata = NULL;
 558         return;
 559 }
 560
 561 static int send_access_event(struct livebox *handler, const char *event, int x, int y)
 562 {
 563         struct packet *packet;
 564         double timestamp;
 565
 566         timestamp = util_timestamp();
 567
 568         packet = packet_create(event, "ssdii", handler->pkgname, handler->id, timestamp, x, y);
 569         if (!packet) {
 570                 ErrPrint("Failed to build packet\n");
 571                 return LB_STATUS_ERROR_FAULT;
 572         }
 573
 574         DbgPrint("Send: %dx%d\n", x, y);
 575
 576         return master_rpc_async_request(handler, packet, 0, access_ret_cb, NULL);
 577 }
 578
 579 static int send_mouse_event(struct livebox *handler, const char *event, int x, int y)
 580 {
 581         struct packet *packet;
 582         double timestamp;
 583
 584         timestamp = util_timestamp();
 585         packet = packet_create_noack(event, "ssdii", handler->pkgname, handler->id, timestamp, x, y);
 586         if (!packet) {
 587                 ErrPrint("Failed to build param\n");
 588                 return LB_STATUS_ERROR_FAULT;
 589         }
 590
 591         DbgPrint("Send: %dx%d\n", x, y);
 592
 593         return master_rpc_request_only(handler, packet);
 594 }
 595
 596 EAPI int livebox_init(void *disp)
 597 {
 598         const char *env;
 599
 600         if (s_info.init_count > 0) {
 601                 s_info.init_count++;
 602                 return LB_STATUS_SUCCESS;
 603         }
 604         env = getenv("PROVIDER_DISABLE_PREVENT_OVERWRITE");
 605         if (env && !strcasecmp(env, "true"))
 606                 s_info.prevent_overwrite = 1;
 607
 608         env = getenv("PROVIDER_EVENT_FILTER");
 609         if (env)
 610                 sscanf(env, "%lf", &MINIMUM_EVENT);
 611
 612 #if defined(FLOG)
 613         char filename[BUFSIZ];
 614         snprintf(filename, sizeof(filename), "/tmp/%d.box.log", getpid());
 615         __file_log_fp = fopen(filename, "w+t");
 616         if (!__file_log_fp)
 617                 __file_log_fp = fdopen(1, "w+t");
 618 #endif
 619         critical_log_init("viewer");
 620         livebox_service_init();
 621         fb_init(disp);
 622
 623         client_init();
 624
 625         s_info.init_count++;
 626         return LB_STATUS_SUCCESS;
 627 }
 628
 629 EAPI int livebox_fini(void)
 630 {
 631         if (s_info.init_count <= 0) {
 632                 DbgPrint("Didn't initialized\n");
 633                 return LB_STATUS_ERROR_INVALID;
 634         }
 635
 636         s_info.init_count--;
 637         if (s_info.init_count > 0) {
 638                 DbgPrint("init count : %d\n", s_info.init_count);
 639                 return LB_STATUS_SUCCESS;
 640         }
 641
 642         client_fini();
 643         fb_fini();
 644         livebox_service_fini();
 645         critical_log_fini();
 646         return LB_STATUS_SUCCESS;
 647 }
 648
 649 static inline char *lb_pkgname(const char *pkgname)
 650 {
 651         char *lb;
 652
 653         lb = livebox_service_pkgname(pkgname);
 654         if (!lb) {
 655                 if (util_validate_livebox_package(pkgname) == 0)
 656                         return strdup(pkgname);
 657         }
 658
 659         return lb;
 660 }
 661
 662 /*!
 663  * Just wrapping the livebox_add_with_size function.
 664  */
 665 EAPI struct livebox *livebox_add(const char *pkgname, const char *content, const char *cluster, const char *category, double period, ret_cb_t cb, void *data)
 666 {
 667         return livebox_add_with_size(pkgname, content, cluster, category, period, LB_SIZE_TYPE_UNKNOWN, cb, data);
 668 }
 669
 670 EAPI struct livebox *livebox_add_with_size(const char *pkgname, const char *content, const char *cluster, const char *category, double period, int type, ret_cb_t cb, void *data)
 671 {
 672         struct livebox *handler;
 673         struct packet *packet;
 674         int ret;
 675         int width = 0;
 676         int height = 0;
 677         struct cb_info *cbinfo;
 678
 679         if (!pkgname || !cluster || !category) {
 680                 ErrPrint("Invalid arguments: pkgname[%p], cluster[%p], category[%p]\n",
 681                                                                 pkgname, cluster, category);
 682                 return NULL;
 683         }
 684
 685         if (type != LB_SIZE_TYPE_UNKNOWN)
 686                 livebox_service_get_size(type, &width, &height);
 687
 688         handler = calloc(1, sizeof(*handler));
 689         if (!handler) {
 690                 ErrPrint("Error: %s\n", strerror(errno));
 691                 return NULL;
 692         }
 693
 694         handler->pkgname = lb_pkgname(pkgname);
 695         if (!handler->pkgname) {
 696                 free(handler);
 697                 return NULL;
 698         }
 699
 700         if (livebox_service_is_enabled(handler->pkgname) == 0) {
 701                 DbgPrint("Livebox [%s](%s) is disabled package\n", handler->pkgname, pkgname);
 702                 free(handler->pkgname);
 703                 free(handler);
 704                 return NULL;
 705         }
 706
 707         if (content) {
 708                 handler->content = strdup(content);
 709                 if (!handler->content) {
 710                         ErrPrint("Error: %s\n", strerror(errno));
 711                         free(handler->pkgname);
 712                         free(handler);
 713                         return NULL;
 714                 }
 715         } else {
 716                 handler->content = livebox_service_content(handler->pkgname);
 717         }
 718
 719         handler->cluster = strdup(cluster);
 720         if (!handler->cluster) {
 721                 ErrPrint("Error: %s\n", strerror(errno));
 722                 free(handler->content);
 723                 free(handler->pkgname);
 724                 free(handler);
 725                 return NULL;
 726         }
 727
 728         handler->category = strdup(category);
 729         if (!handler->category) {
 730                 ErrPrint("Error: %s\n", strerror(errno));
 731                 free(handler->cluster);
 732                 free(handler->content);
 733                 free(handler->pkgname);
 734                 free(handler);
 735                 return NULL;
 736         }
 737
 738         if (!cb)
 739                 cb = default_create_cb;
 740
 741         /* Data provider will set this */
 742         handler->lb.type = _LB_TYPE_FILE;
 743         handler->pd.type = _PD_TYPE_SCRIPT;
 744         handler->lb.period = period;
 745
 746         /* Used for handling the mouse event on a box */
 747         handler->lb.mouse_event = livebox_service_mouse_event(handler->pkgname);
 748
 749         /* Cluster infomration is not determined yet */
 750         handler->nr_of_sizes = 0x01;
 751
 752         handler->timestamp = util_timestamp();
 753         handler->is_user = 1;
 754         handler->visible = LB_SHOW;
 755
 756         s_info.livebox_list = dlist_append(s_info.livebox_list, handler);
 757
 758         packet = packet_create("new", "dssssdii", handler->timestamp, handler->pkgname, handler->content, cluster, category, period, width, height);
 759         if (!packet) {
 760                 ErrPrint("Failed to create a new packet\n");
 761                 free(handler->category);
 762                 free(handler->cluster);
 763                 free(handler->content);
 764                 free(handler->pkgname);
 765                 free(handler);
 766                 return NULL;
 767         }
 768
 769         cbinfo = create_cb_info(cb, data);
 770         if (!cbinfo) {
 771                 ErrPrint("Failed to create a cbinfo\n");
 772                 packet_destroy(packet);
 773                 free(handler->category);
 774                 free(handler->cluster);
 775                 free(handler->content);
 776                 free(handler->pkgname);
 777                 free(handler);
 778                 return NULL;
 779         }
 780
 781         ret = master_rpc_async_request(handler, packet, 0, new_ret_cb, cbinfo);
 782         if (ret < 0) {
 783                 ErrPrint("Failed to send a new packet\n");
 784                 destroy_cb_info(cbinfo);
 785                 free(handler->category);
 786                 free(handler->cluster);
 787                 free(handler->content);
 788                 free(handler->pkgname);
 789                 free(handler);
 790                 return NULL;
 791         }
 792
 793         DbgPrint("Successfully sent a new request ([%lf] %s)\n", handler->timestamp, handler->pkgname);
 794         handler->state = CREATE;
 795         return lb_ref(handler);
 796 }
 797
 798 EAPI double livebox_period(struct livebox *handler)
 799 {
 800         if (!handler || handler->state != CREATE || !handler->id) {
 801                 ErrPrint("Handler is not valid\n");
 802                 return 0.0f;
 803         }
 804
 805         return handler->lb.period;
 806 }
 807
 808 EAPI int livebox_set_period(struct livebox *handler, double period, ret_cb_t cb, void *data)
 809 {
 810         struct packet *packet;
 811         int ret;
 812
 813         if (!handler || handler->state != CREATE || !handler->id) {
 814                 ErrPrint("Handler is not valid\n");
 815                 return LB_STATUS_ERROR_INVALID;
 816         }
 817
 818         if (handler->period_changed_cb) {
 819                 ErrPrint("Previous request for changing period is not finished\n");
 820                 return LB_STATUS_ERROR_BUSY;
 821         }
 822
 823         if (!handler->is_user) {
 824                 ErrPrint("CA Livebox is not able to change the period\n");
 825                 return LB_STATUS_ERROR_PERMISSION;
 826         }
 827
 828         if (handler->lb.period == period) {
 829                 DbgPrint("No changes\n");
 830                 return LB_STATUS_ERROR_ALREADY;
 831         }
 832
 833         packet = packet_create("set_period", "ssd", handler->pkgname, handler->id, period);
 834         if (!packet) {
 835                 ErrPrint("Failed to build a packet %s\n", handler->pkgname);
 836                 return LB_STATUS_ERROR_FAULT;
 837         }
 838
 839         if (!cb)
 840                 cb = default_period_changed_cb;
 841
 842         handler->period_changed_cb = cb;
 843         handler->period_cbdata = data;
 844
 845         ret = master_rpc_async_request(handler, packet, 0, period_ret_cb, NULL);
 846         if (ret < 0) {
 847                 handler->period_changed_cb = NULL;
 848                 handler->period_cbdata = NULL;
 849         }
 850
 851         return ret;
 852 }
 853
 854 EAPI int livebox_del(struct livebox *handler, ret_cb_t cb, void *data)
 855 {
 856         if (!handler) {
 857                 ErrPrint("Handler is NIL\n");
 858                 return LB_STATUS_ERROR_INVALID;
 859         }
 860
 861         if (handler->state != CREATE) {
 862                 ErrPrint("Handler is already deleted\n");
 863                 return LB_STATUS_ERROR_INVALID;
 864         }
 865
 866         handler->state = DELETE;
 867
 868         if (!handler->id) {
 869                 /*!
 870                  * \note
 871                  * The id is not determined yet.
 872                  * It means a user didn't receive created event yet.
 873                  * Then just stop to delete procedure from here.
 874                  * Because the "created" event handler will release this.
 875                  * By the way, if the user adds any callback for getting return status of this,
 876                  * call it at here.
 877                  */
 878                 if (cb)
 879                         cb(handler, 0, data);
 880                 return LB_STATUS_SUCCESS;
 881         }
 882
 883         if (!cb)
 884                 cb = default_delete_cb;
 885
 886         return lb_send_delete(handler, cb, data);
 887 }
 888
 889 EAPI int livebox_set_fault_handler(int (*cb)(enum livebox_fault_type, const char *, const char *, const char *, void *), void *data)
 890 {
 891         struct fault_info *info;
 892
 893         if (!cb)
 894                 return LB_STATUS_ERROR_INVALID;
 895
 896         info = malloc(sizeof(*info));
 897         if (!info) {
 898                 CRITICAL_LOG("Heap: %s\n", strerror(errno));
 899                 return LB_STATUS_ERROR_MEMORY;
 900         }
 901
 902         info->handler = cb;
 903         info->user_data = data;
 904
 905         s_info.fault_list = dlist_append(s_info.fault_list, info);
 906         return LB_STATUS_SUCCESS;
 907 }
 908
 909 EAPI void *livebox_unset_fault_handler(int (*cb)(enum livebox_fault_type, const char *, const char *, const char *, void *))
 910 {
 911         struct fault_info *info;
 912         struct dlist *l;
 913
 914         dlist_foreach(s_info.fault_list, l, info) {
 915                 if (info->handler == cb) {
 916                         void *data;
 917                         s_info.fault_list = dlist_remove(s_info.fault_list, l);
 918                         data = info->user_data;
 919                         free(info);
 920
 921                         return data;
 922                 }
 923         }
 924
 925         return NULL;
 926 }
 927
 928 EAPI int livebox_set_event_handler(int (*cb)(struct livebox *, enum livebox_event_type, void *), void *data)
 929 {
 930         struct event_info *info;
 931
 932         if (!cb) {
 933                 ErrPrint("Invalid argument cb is nil\n");
 934                 return LB_STATUS_ERROR_INVALID;
 935         }
 936
 937         info = malloc(sizeof(*info));
 938         if (!info) {
 939                 CRITICAL_LOG("Heap: %s\n", strerror(errno));
 940                 return LB_STATUS_ERROR_MEMORY;
 941         }
 942
 943         info->handler = cb;
 944         info->user_data = data;
 945
 946         s_info.event_list = dlist_append(s_info.event_list, info);
 947         return LB_STATUS_SUCCESS;
 948 }
 949
 950 EAPI void *livebox_unset_event_handler(int (*cb)(struct livebox *, enum livebox_event_type, void *))
 951 {
 952         struct event_info *info;
 953         struct dlist *l;
 954
 955         dlist_foreach(s_info.event_list, l, info) {
 956                 if (info->handler == cb) {
 957                         void *data;
 958
 959                         s_info.event_list = dlist_remove(s_info.event_list, l);
 960                         data = info->user_data;
 961                         free(info);
 962
 963                         return data;
 964                 }
 965         }
 966
 967         return NULL;
 968 }
 969
 970 EAPI int livebox_set_update_mode(struct livebox *handler, int active_update, ret_cb_t cb, void *data)
 971 {
 972         struct packet *packet;
 973         int ret;
 974
 975         if (!handler) {
 976                 ErrPrint("Handler is NIL\n");
 977                 return LB_STATUS_ERROR_INVALID;
 978         }
 979
 980         if (handler->state != CREATE || !handler->id)
 981                 return LB_STATUS_ERROR_INVALID;
 982
 983         if (handler->update_mode_cb) {
 984                 ErrPrint("Previous update_mode cb is not finished yet\n");
 985                 return LB_STATUS_ERROR_BUSY;
 986         }
 987
 988         if (handler->is_active_update == active_update)
 989                 return LB_STATUS_ERROR_ALREADY;
 990
 991         if (!handler->is_user)
 992                 return LB_STATUS_ERROR_PERMISSION;
 993
 994         packet = packet_create("update_mode", "ssi", handler->pkgname, handler->id, active_update);
 995         if (!packet)
 996                 return LB_STATUS_ERROR_FAULT;
 997
 998         if (!cb)
 999                 cb = default_update_mode_cb;
1000
1001         handler->update_mode_cb = cb;
1002         handler->update_mode_cbdata = data;
1003
1004         ret = master_rpc_async_request(handler, packet, 0, update_mode_cb, NULL);
1005         if (ret < 0) {
1006                 handler->update_mode_cb = NULL;
1007                 handler->update_mode_cbdata = NULL;
1008         }
1009
1010         return ret;
1011 }
1012
1013 EAPI int livebox_is_active_update(struct livebox *handler)
1014 {
1015         if (!handler) {
1016                 ErrPrint("Handler is NIL\n");
1017                 return LB_STATUS_ERROR_INVALID;
1018         }
1019
1020         if (handler->state != CREATE || !handler->id)
1021                 return LB_STATUS_ERROR_INVALID;
1022
1023         return handler->is_active_update;
1024 }
1025
1026 EAPI int livebox_resize(struct livebox *handler, int type, ret_cb_t cb, void *data)
1027 {
1028         struct packet *packet;
1029         int w;
1030         int h;
1031         int ret;
1032
1033         if (!handler) {
1034                 ErrPrint("Handler is NIL\n");
1035                 return LB_STATUS_ERROR_INVALID;
1036         }
1037
1038         if (handler->state != CREATE || !handler->id) {
1039                 ErrPrint("Handler is not valid\n");
1040                 return LB_STATUS_ERROR_INVALID;
1041         }
1042
1043         if (handler->size_changed_cb) {
1044                 ErrPrint("Previous resize request is not finished yet\n");
1045                 return LB_STATUS_ERROR_BUSY;
1046         }
1047
1048         if (!handler->is_user) {
1049                 ErrPrint("CA Livebox is not able to be resized\n");
1050                 return LB_STATUS_ERROR_PERMISSION;
1051         }
1052
1053         if (livebox_service_get_size(type, &w, &h) != 0) {
1054                 ErrPrint("Invalid size type\n");
1055                 return LB_STATUS_ERROR_INVALID;
1056         }
1057
1058         if (handler->lb.width == w && handler->lb.height == h) {
1059                 DbgPrint("No changes\n");
1060                 return LB_STATUS_ERROR_ALREADY;;
1061         }
1062
1063         packet = packet_create("resize", "ssii", handler->pkgname, handler->id, w, h);
1064         if (!packet) {
1065                 ErrPrint("Failed to build param\n");
1066                 return LB_STATUS_ERROR_FAULT;
1067         }
1068
1069         if (!cb)
1070                 cb = default_lb_size_changed_cb;
1071
1072         handler->size_changed_cb = cb;
1073         handler->size_cbdata = data;
1074
1075         ret = master_rpc_async_request(handler, packet, 0, resize_cb, NULL);
1076         if (ret < 0) {
1077                 handler->size_changed_cb = NULL;
1078                 handler->size_cbdata = NULL;
1079         }
1080
1081         return ret;
1082 }
1083
1084 EAPI int livebox_click(struct livebox *handler, double x, double y)
1085 {
1086         struct packet *packet;
1087         double timestamp;
1088         int ret;
1089
1090         if (!handler) {
1091                 ErrPrint("Handler is NIL\n");
1092                 return LB_STATUS_ERROR_INVALID;
1093         }
1094
1095         if (handler->state != CREATE || !handler->id) {
1096                 ErrPrint("Handler is not valid\n");
1097                 return LB_STATUS_ERROR_INVALID;
1098         }
1099
1100         if (handler->lb.auto_launch) {
1101                 DbgPrint("Auto-launch enabled: %s\n", handler->lb.auto_launch);
1102                 if (aul_launch_app(handler->lb.auto_launch, NULL) < 0)
1103                         ErrPrint("Failed to launch app %s\n", handler->lb.auto_launch);
1104         }
1105
1106         timestamp = util_timestamp();
1107         packet = packet_create_noack("clicked", "sssddd", handler->pkgname, handler->id, "clicked", timestamp, x, y);
1108         if (!packet) {
1109                 ErrPrint("Failed to build param\n");
1110                 return LB_STATUS_ERROR_FAULT;
1111         }
1112
1113         ret = master_rpc_request_only(handler, packet);
1114         DbgPrint("Click request: %d\n", ret);
1115
1116         if (!handler->lb.mouse_event && (handler->lb.type == _LB_TYPE_BUFFER || handler->lb.type == _LB_TYPE_SCRIPT)) {
1117                 int ret; /* Shadow variable */
1118                 ret = send_mouse_event(handler, "lb_mouse_down", x * handler->lb.width, y * handler->lb.height);
1119                 if (ret < 0)
1120                         DbgPrint("Failed to send Down: %d\n", ret);
1121
1122                 ret = send_mouse_event(handler, "lb_mouse_move", x * handler->lb.width, y * handler->lb.height);
1123                 if (ret < 0)
1124                         DbgPrint("Failed to send Move: %d\n", ret);
1125
1126                 ret = send_mouse_event(handler, "lb_mouse_up", x * handler->lb.width, y * handler->lb.height);
1127                 if (ret < 0)
1128                         DbgPrint("Failed to send Up: %d\n", ret);
1129         }
1130
1131         return ret;
1132 }
1133
1134 EAPI int livebox_has_pd(struct livebox *handler)
1135 {
1136         if (!handler) {
1137                 ErrPrint("Handler is NIL\n");
1138                 return LB_STATUS_ERROR_INVALID;
1139         }
1140
1141         if (handler->state != CREATE || !handler->id) {
1142                 ErrPrint("Handler is not valid\n");
1143                 return LB_STATUS_ERROR_INVALID;
1144         }
1145
1146         return !!handler->pd.data.fb;
1147 }
1148
1149 EAPI int livebox_pd_is_created(struct livebox *handler)
1150 {
1151         if (!handler) {
1152                 ErrPrint("Handler is NIL\n");
1153                 return LB_STATUS_ERROR_INVALID;
1154         }
1155
1156         if (!handler->pd.data.fb || handler->state != CREATE || !handler->id) {
1157                 ErrPrint("Handler is not valid\n");
1158                 return LB_STATUS_ERROR_INVALID;
1159         }
1160
1161         return handler->is_pd_created;
1162 }
1163
1164 EAPI int livebox_create_pd(struct livebox *handler, ret_cb_t cb, void *data)
1165 {
1166         return livebox_create_pd_with_position(handler, -1.0, -1.0, cb, data);
1167 }
1168
1169 EAPI int livebox_create_pd_with_position(struct livebox *handler, double x, double y, ret_cb_t cb, void *data)
1170 {
1171         struct packet *packet;
1172         int ret;
1173
1174         if (!handler) {
1175                 ErrPrint("Handler is NIL\n");
1176                 return LB_STATUS_ERROR_INVALID;
1177         }
1178
1179         if (!handler->pd.data.fb || handler->state != CREATE || !handler->id) {
1180                 ErrPrint("Handler is not valid\n");
1181                 return LB_STATUS_ERROR_INVALID;
1182         }
1183
1184         if (handler->is_pd_created == 1) {
1185                 DbgPrint("PD already created\n");
1186                 return LB_STATUS_SUCCESS;
1187         }
1188
1189         if (handler->pd_created_cb) {
1190                 ErrPrint("Previous request is not completed yet\n");
1191                 return LB_STATUS_ERROR_BUSY;
1192         }
1193
1194         packet = packet_create("create_pd", "ssdd", handler->pkgname, handler->id, x, y);
1195         if (!packet) {
1196                 ErrPrint("Failed to build param\n");
1197                 return LB_STATUS_ERROR_FAULT;
1198         }
1199
1200         if (!cb)
1201                 cb = default_pd_created_cb;
1202
1203         handler->pd_created_cb = cb;
1204         handler->pd_created_cbdata = data;
1205
1206         ret = master_rpc_async_request(handler, packet, 0, pd_create_cb, NULL);
1207         if (ret < 0) {
1208                 handler->pd_created_cb = NULL;
1209                 handler->pd_created_cbdata = NULL;
1210         }
1211
1212         return ret;
1213 }
1214
1215 EAPI int livebox_move_pd(struct livebox *handler, double x, double y)
1216 {
1217         struct packet *packet;
1218
1219         if (!handler) {
1220                 ErrPrint("Handler is NIL\n");
1221                 return LB_STATUS_ERROR_INVALID;
1222         }
1223
1224         if (!handler->pd.data.fb || handler->state != CREATE || !handler->id) {
1225                 ErrPrint("Handler is not valid\n");
1226                 return LB_STATUS_ERROR_INVALID;
1227         }
1228
1229         if (!handler->is_pd_created) {
1230                 DbgPrint("PD is not created\n");
1231                 return LB_STATUS_ERROR_INVALID;
1232         }
1233
1234         packet = packet_create_noack("pd_move", "ssdd", handler->pkgname, handler->id, x, y);
1235         if (!packet) {
1236                 ErrPrint("Failed to build param\n");
1237                 return LB_STATUS_ERROR_FAULT;
1238         }
1239
1240         return master_rpc_request_only(handler, packet);
1241 }
1242
1243 EAPI int livebox_activate(const char *pkgname, ret_cb_t cb, void *data)
1244 {
1245         struct packet *packet;
1246         struct cb_info *cbinfo;
1247         int ret;
1248
1249         if (!pkgname)
1250                 return LB_STATUS_ERROR_INVALID;
1251
1252         packet = packet_create("activate_package", "s", pkgname);
1253         if (!packet) {
1254                 ErrPrint("Failed to build a param\n");
1255                 return LB_STATUS_ERROR_FAULT;
1256         }
1257
1258         cbinfo = create_cb_info(cb, data);
1259         if (!cbinfo) {
1260                 ErrPrint("Unable to create cbinfo\n");
1261                 packet_destroy(packet);
1262                 return LB_STATUS_ERROR_FAULT;
1263         }
1264
1265         ret = master_rpc_async_request(NULL, packet, 0, activated_cb, cbinfo);
1266         if (ret < 0)
1267                 destroy_cb_info(cbinfo);
1268
1269         return ret;
1270 }
1271
1272 EAPI int livebox_destroy_pd(struct livebox *handler, ret_cb_t cb, void *data)
1273 {
1274         struct packet *packet;
1275         struct cb_info *cbinfo;
1276         int ret;
1277
1278         if (!handler) {
1279                 ErrPrint("Handler is NIL\n");
1280                 return LB_STATUS_ERROR_INVALID;
1281         }
1282
1283         if (!handler->pd.data.fb || handler->state != CREATE || !handler->id) {
1284                 ErrPrint("Handler is not valid\n");
1285                 return LB_STATUS_ERROR_INVALID;
1286         }
1287
1288         if (!handler->is_pd_created) {
1289                 ErrPrint("PD is not created\n");
1290                 return LB_STATUS_ERROR_INVALID;
1291         }
1292
1293         packet = packet_create("destroy_pd", "ss", handler->pkgname, handler->id);
1294         if (!packet) {
1295                 ErrPrint("Failed to build a param\n");
1296                 return LB_STATUS_ERROR_FAULT;
1297         }
1298
1299         if (!cb)
1300                 cb = default_pd_destroyed_cb;
1301
1302         cbinfo = create_cb_info(cb, data);
1303         if (!cbinfo) {
1304                 packet_destroy(packet);
1305                 return LB_STATUS_ERROR_FAULT;
1306         }
1307
1308         ret = master_rpc_async_request(handler, packet, 0, pd_destroy_cb, cbinfo);
1309         if (ret < 0)
1310                 destroy_cb_info(cbinfo);
1311
1312         return ret;
1313 }
1314
1315 EAPI int livebox_access_event(struct livebox *handler, enum access_event_type type, double x, double y, ret_cb_t cb, void *data)
1316 {
1317         int w = 1;
1318         int h = 1;
1319         char cmd[32] = { '\0', };
1320         char *ptr = cmd;
1321         int ret;
1322
1323         if (!handler) {
1324                 ErrPrint("Handler is NIL\n");
1325                 return LB_STATUS_ERROR_INVALID;
1326         }
1327
1328         if (handler->state != CREATE || !handler->id) {
1329                 ErrPrint("Handler is not valid\n");
1330                 return LB_STATUS_ERROR_INVALID;
1331         }
1332
1333         if (handler->access_event_cb) {
1334                 ErrPrint("Previous access event is not yet done\n");
1335                 return LB_STATUS_ERROR_BUSY;
1336         }
1337
1338         if (type & ACCESS_EVENT_PD_MASK) {
1339                 if (!handler->is_pd_created) {
1340                         ErrPrint("PD is not created\n");
1341                         return LB_STATUS_ERROR_INVALID;
1342                 }
1343                 *ptr++ = 'p';
1344                 *ptr++ = 'd';
1345                 w = handler->pd.width;
1346                 h = handler->pd.height;
1347         } else if (type & ACCESS_EVENT_LB_MASK) {
1348                 *ptr++ = 'l';
1349                 *ptr++ = 'b';
1350                 w = handler->lb.width;
1351                 h = handler->lb.height;
1352         } else {
1353                 ErrPrint("Invalid event type\n");
1354                 return LB_STATUS_ERROR_INVALID;
1355         }
1356
1357         switch (type & ~ACCESS_EVENT_PD_MASK) {
1358         case ACCESS_EVENT_HIGHLIGHT:
1359                 strcpy(ptr, "_access_hl");
1360                 break;
1361         case ACCESS_EVENT_HIGHLIGHT_NEXT:
1362                 strcpy(ptr, "_access_hl_next");
1363                 break;
1364         case ACCESS_EVENT_HIGHLIGHT_PREV:
1365                 strcpy(ptr, "_access_hl_prev");
1366                 break;
1367         case ACCESS_EVENT_ACTIVATE:
1368                 strcpy(ptr, "_access_activate");
1369                 break;
1370         case ACCESS_EVENT_VALUE_CHANGE:
1371                 strcpy(ptr, "_access_value_change");
1372                 break;
1373         case ACCESS_EVENT_UNHIGHLIGHT:
1374                 strcpy(ptr, "_access_unhighlight");
1375                 break;
1376         case ACCESS_EVENT_SCROLL_DOWN:
1377                 strcpy(ptr, "_access_scroll_down");
1378                 break;
1379         case ACCESS_EVENT_SCROLL_MOVE:
1380                 strcpy(ptr, "_access_scroll_move");
1381                 break;
1382         case ACCESS_EVENT_SCROLL_UP:
1383                 strcpy(ptr, "_access_scroll_up");
1384                 break;
1385         default:
1386                 return LB_STATUS_ERROR_INVALID;
1387         }
1388
1389         if (!cb)
1390                 cb = default_access_event_cb;
1391
1392         handler->access_event_cb = cb;
1393         handler->access_event_cbdata = data;
1394
1395         ret = send_access_event(handler, cmd, x * w, y * h);
1396         if (ret < 0) {
1397                 handler->access_event_cb = NULL;
1398                 handler->access_event_cbdata = NULL;
1399         }
1400
1401         return ret;
1402 }
1403
1404 EAPI int livebox_content_event(struct livebox *handler, enum content_event_type type, double x, double y)
1405 {
1406         int w = 1;
1407         int h = 1;
1408         char cmd[32] = { '\0', };
1409         char *ptr = cmd;
1410
1411         if (!handler) {
1412                 ErrPrint("Handler is NIL\n");
1413                 return LB_STATUS_ERROR_INVALID;
1414         }
1415
1416         if (handler->state != CREATE || !handler->id) {
1417                 ErrPrint("Handler is not valid\n");
1418                 return LB_STATUS_ERROR_INVALID;
1419         }
1420
1421         if (type & CONTENT_EVENT_PD_MASK) {
1422                 int flag = 1;
1423
1424                 if (!handler->is_pd_created) {
1425                         ErrPrint("PD is not created\n");
1426                         return LB_STATUS_ERROR_INVALID;
1427                 }
1428
1429                 if (type & CONTENT_EVENT_MOUSE_MASK) {
1430                         if (!handler->pd.data.fb) {
1431                                 ErrPrint("Handler is not valid\n");
1432                                 return LB_STATUS_ERROR_INVALID;
1433                         }
1434
1435                         if (type & CONTENT_EVENT_MOUSE_MOVE) {
1436                                 if (fabs(x - handler->pd.x) < MINIMUM_EVENT && fabs(y - handler->pd.y) < MINIMUM_EVENT)
1437                                         return LB_STATUS_ERROR_BUSY;
1438                         } else if (type & CONTENT_EVENT_MOUSE_SET) {
1439                                 flag = 0;
1440                         }
1441                 }
1442
1443                 if (flag) {
1444                         w = handler->pd.width;
1445                         h = handler->pd.height;
1446                         handler->pd.x = x;
1447                         handler->pd.y = y;
1448                 }
1449                 *ptr++ = 'p';
1450                 *ptr++ = 'd';
1451         } else {
1452                 int flag = 1;
1453
1454                 if (type & CONTENT_EVENT_MOUSE_MASK) {
1455                         if (!handler->lb.mouse_event) {
1456                                 ErrPrint("Box is not support the mouse event\n");
1457                                 return LB_STATUS_ERROR_INVALID;
1458                         }
1459
1460                         if (!handler->lb.data.fb) {
1461                                 ErrPrint("Handler is not valid\n");
1462                                 return LB_STATUS_ERROR_INVALID;
1463                         }
1464
1465                         if (type & CONTENT_EVENT_MOUSE_MOVE) {
1466                                 if (fabs(x - handler->lb.x) < MINIMUM_EVENT && fabs(y - handler->lb.y) < MINIMUM_EVENT)
1467                                         return LB_STATUS_ERROR_BUSY;
1468                         } else if (type & CONTENT_EVENT_MOUSE_SET) {
1469                                 flag = 0;
1470                         }
1471                 }
1472
1473                 if (flag) {
1474                         w = handler->lb.width;
1475                         h = handler->lb.height;
1476                         handler->lb.x = x;
1477                         handler->lb.y = y;
1478                 }
1479                 *ptr++ = 'l';
1480                 *ptr++ = 'b';
1481         }
1482
1483         /*!
1484          * Must be short than 29 bytes.
1485          */
1486         switch ((type & ~CONTENT_EVENT_PD_MASK)) {
1487         case CONTENT_EVENT_MOUSE_ENTER | CONTENT_EVENT_MOUSE_MASK:
1488                 strcpy(ptr, "_mouse_enter");
1489                 break;
1490         case CONTENT_EVENT_MOUSE_LEAVE | CONTENT_EVENT_MOUSE_MASK:
1491                 strcpy(ptr, "_mouse_leave");
1492                 break;
1493         case CONTENT_EVENT_MOUSE_UP | CONTENT_EVENT_MOUSE_MASK:
1494                 strcpy(ptr, "_mouse_up");
1495                 break;
1496         case CONTENT_EVENT_MOUSE_DOWN | CONTENT_EVENT_MOUSE_MASK:
1497                 strcpy(ptr, "_mouse_down");
1498                 break;
1499         case CONTENT_EVENT_MOUSE_MOVE | CONTENT_EVENT_MOUSE_MASK:
1500                 strcpy(ptr, "_mouse_move");
1501                 break;
1502         case CONTENT_EVENT_MOUSE_SET | CONTENT_EVENT_MOUSE_MASK:
1503                 strcpy(ptr, "_mouse_set");
1504                 break;
1505         case CONTENT_EVENT_MOUSE_UNSET | CONTENT_EVENT_MOUSE_MASK:
1506                 strcpy(ptr, "_mouse_unset");
1507                 break;
1508         case CONTENT_EVENT_KEY_DOWN | CONTENT_EVENT_KEY_MASK:
1509                 strcpy(ptr, "_key_down");
1510                 break;
1511         case CONTENT_EVENT_KEY_UP | CONTENT_EVENT_KEY_MASK:
1512                 strcpy(ptr, "_key_up");
1513                 break;
1514         default:
1515                 ErrPrint("Invalid event type\n");
1516                 return LB_STATUS_ERROR_INVALID;
1517         }
1518
1519         return send_mouse_event(handler, cmd, x * w, y * h);
1520 }
1521
1522 EAPI const char *livebox_filename(struct livebox *handler)
1523 {
1524         if (!handler) {
1525                 ErrPrint("Handler is NIL\n");
1526                 return NULL;
1527         }
1528
1529         if (handler->state != CREATE || !handler->id) {
1530                 ErrPrint("Handler is not valid\n");
1531                 return NULL;
1532         }
1533
1534         if (handler->filename)
1535                 return handler->filename;
1536
1537         /* Oooops */
1538         return util_uri_to_path(handler->id);
1539 }
1540
1541 EAPI int livebox_get_pdsize(struct livebox *handler, int *w, int *h)
1542 {
1543         int _w;
1544         int _h;
1545
1546         if (!handler) {
1547                 ErrPrint("Handler is NIL\n");
1548                 return LB_STATUS_ERROR_INVALID;
1549         }
1550
1551         if (handler->state != CREATE || !handler->id) {
1552                 ErrPrint("Handler is not valid\n");
1553                 return LB_STATUS_ERROR_INVALID;
1554         }
1555
1556         if (!w)
1557                 w = &_w;
1558         if (!h)
1559                 h = &_h;
1560
1561         if (!handler->is_pd_created) {
1562                 DbgPrint("Buffer is not created yet [%dx%d]\n", *w, *h);
1563                 *w = handler->pd.default_width;
1564                 *h = handler->pd.default_height;
1565         } else {
1566                 *w = handler->pd.width;
1567                 *h = handler->pd.height;
1568         }
1569
1570         return LB_STATUS_SUCCESS;
1571 }
1572
1573 EAPI int livebox_size(struct livebox *handler)
1574 {
1575         int w;
1576         int h;
1577
1578         if (!handler) {
1579                 ErrPrint("Handler is NIL\n");
1580                 return LB_STATUS_ERROR_INVALID;
1581         }
1582
1583         if (handler->state != CREATE || !handler->id) {
1584                 ErrPrint("Handler is not valid\n");
1585                 return LB_STATUS_ERROR_INVALID;
1586         }
1587
1588         w = handler->lb.width;
1589         h = handler->lb.height;
1590
1591         switch (handler->lb.type) {
1592         case _LB_TYPE_BUFFER:
1593         case _LB_TYPE_SCRIPT:
1594                 if (!fb_is_created(handler->lb.data.fb)) {
1595                         DbgPrint("Buffer is not created yet - reset size\n");
1596                         w = 0;
1597                         h = 0;
1598                 }
1599                 break;
1600         default:
1601                 break;
1602         }
1603
1604         return livebox_service_size_type(w, h);
1605 }
1606
1607 EAPI int livebox_set_group(struct livebox *handler, const char *cluster, const char *category, ret_cb_t cb, void *data)
1608 {
1609         struct packet *packet;
1610         int ret;
1611
1612         if (!handler) {
1613                 ErrPrint("Handler is NIL\n");
1614                 return LB_STATUS_ERROR_INVALID;
1615         }
1616
1617         if (!cluster || !category || handler->state != CREATE || !handler->id) {
1618                 ErrPrint("Invalid argument\n");
1619                 return LB_STATUS_ERROR_INVALID;
1620         }
1621
1622         if (handler->group_changed_cb) {
1623                 ErrPrint("Previous group changing request is not finished yet\n");
1624                 return LB_STATUS_ERROR_BUSY;
1625         }
1626
1627         if (!handler->is_user) {
1628                 ErrPrint("CA Livebox is not able to change the group\n");
1629                 return LB_STATUS_ERROR_PERMISSION;
1630         }
1631
1632         if (!strcmp(handler->cluster, cluster) && !strcmp(handler->category, category)) {
1633                 DbgPrint("No changes\n");
1634                 return LB_STATUS_ERROR_ALREADY;
1635         }
1636
1637         packet = packet_create("change_group", "ssss", handler->pkgname, handler->id, cluster, category);
1638         if (!packet) {
1639                 ErrPrint("Failed to build a param\n");
1640                 return LB_STATUS_ERROR_FAULT;
1641         }
1642
1643         if (!cb)
1644                 cb = default_group_changed_cb;
1645
1646         handler->group_changed_cb = cb;
1647         handler->group_cbdata = data;
1648
1649         ret = master_rpc_async_request(handler, packet, 0, set_group_ret_cb, NULL);
1650         if (ret < 0) {
1651                 handler->group_changed_cb = NULL;
1652                 handler->group_cbdata = NULL;
1653         }
1654
1655         return ret;
1656 }
1657
1658 EAPI int livebox_get_group(struct livebox *handler, char ** const cluster, char ** const category)
1659 {
1660         if (!handler) {
1661                 ErrPrint("Handler is NIL\n");
1662                 return LB_STATUS_ERROR_INVALID;
1663         }
1664
1665         if (!cluster || !category || handler->state != CREATE || !handler->id) {
1666                 ErrPrint("Invalid argument\n");
1667                 return LB_STATUS_ERROR_INVALID;
1668         }
1669
1670         *cluster = handler->cluster;
1671         *category = handler->category;
1672         return LB_STATUS_SUCCESS;
1673 }
1674
1675 EAPI int livebox_get_supported_sizes(struct livebox *handler, int *cnt, int *size_list)
1676 {
1677         register int i;
1678         register int j;
1679
1680         if (!handler || !size_list) {
1681                 ErrPrint("Invalid argument, handler(%p), size_list(%p)\n", handler, size_list);
1682                 return LB_STATUS_ERROR_INVALID;
1683         }
1684
1685         if (!cnt || handler->state != CREATE || !handler->id) {
1686                 ErrPrint("Handler is not valid\n");
1687                 return LB_STATUS_ERROR_INVALID;
1688         }
1689
1690         for (j = i = 0; i < NR_OF_SIZE_LIST; i++) {
1691                 if (handler->lb.size_list & (0x01 << i)) {
1692                         if (j == *cnt)
1693                                 break;
1694
1695                         size_list[j++] = (0x01 << i);
1696                 }
1697         }
1698
1699         *cnt = j;
1700         return LB_STATUS_SUCCESS;
1701 }
1702
1703 EAPI const char *livebox_pkgname(struct livebox *handler)
1704 {
1705         if (!handler) {
1706                 ErrPrint("Handler is NIL\n");
1707                 return NULL;
1708         }
1709
1710         if (handler->state != CREATE) {
1711                 ErrPrint("Handler is not valid\n");
1712                 return NULL;
1713         }
1714
1715         return handler->pkgname;
1716 }
1717
1718 EAPI double livebox_priority(struct livebox *handler)
1719 {
1720         if (!handler) {
1721                 ErrPrint("Handler is NIL\n");
1722                 return 0.0f;
1723         }
1724
1725         if (handler->state != CREATE || !handler->id) {
1726                 ErrPrint("Handler is not valid (%p)\n", handler);
1727                 return -1.0f;
1728         }
1729
1730         return handler->lb.priority;
1731 }
1732
1733 EAPI int livebox_delete_cluster(const char *cluster, ret_cb_t cb, void *data)
1734 {
1735         struct packet *packet;
1736         struct cb_info *cbinfo;
1737         int ret;
1738
1739         packet = packet_create("delete_cluster", "s", cluster);
1740         if (!packet) {
1741                 ErrPrint("Failed to build a param\n");
1742                 return LB_STATUS_ERROR_FAULT;
1743         }
1744
1745         cbinfo = create_cb_info(cb, data);
1746         if (!cbinfo) {
1747                 packet_destroy(packet);
1748                 return LB_STATUS_ERROR_FAULT;
1749         }
1750
1751         ret = master_rpc_async_request(NULL, packet, 0, delete_cluster_cb, cbinfo);
1752         if (ret < 0)
1753                 destroy_cb_info(cbinfo);
1754
1755         return ret;
1756 }
1757
1758 EAPI int livebox_delete_category(const char *cluster, const char *category, ret_cb_t cb, void *data)
1759 {
1760         struct packet *packet;
1761         struct cb_info *cbinfo;
1762         int ret;
1763
1764         packet = packet_create("delete_category", "ss", cluster, category);
1765         if (!packet) {
1766                 ErrPrint("Failed to build a param\n");
1767                 return LB_STATUS_ERROR_FAULT;
1768         }
1769
1770         cbinfo = create_cb_info(cb, data);
1771         if (!cbinfo) {
1772                 packet_destroy(packet);
1773                 return LB_STATUS_ERROR_FAULT;
1774         }
1775
1776         ret = master_rpc_async_request(NULL, packet, 0, delete_category_cb, cbinfo);
1777         if (ret < 0)
1778                 destroy_cb_info(cbinfo);
1779
1780         return ret;
1781 }
1782
1783 EAPI enum livebox_lb_type livebox_lb_type(struct livebox *handler)
1784 {
1785         if (!handler) {
1786                 ErrPrint("Handler is NIL\n");
1787                 return LB_TYPE_INVALID;
1788         }
1789
1790         if (handler->state != CREATE || !handler->id) {
1791                 ErrPrint("Handler is not valid\n");
1792                 return LB_TYPE_INVALID;
1793         }
1794
1795         switch (handler->lb.type) {
1796         case _LB_TYPE_FILE:
1797                 return LB_TYPE_IMAGE;
1798         case _LB_TYPE_BUFFER:
1799         case _LB_TYPE_SCRIPT:
1800                 {
1801                         const char *id;
1802                         id = fb_id(handler->lb.data.fb);
1803                         if (id && !strncasecmp(id, SCHEMA_PIXMAP, strlen(SCHEMA_PIXMAP)))
1804                                 return LB_TYPE_PIXMAP;
1805                 }
1806                 return LB_TYPE_BUFFER;
1807         case _LB_TYPE_TEXT:
1808                 return LB_TYPE_TEXT;
1809         default:
1810                 break;
1811         }
1812
1813         return LB_TYPE_INVALID;
1814 }
1815
1816 EAPI enum livebox_pd_type livebox_pd_type(struct livebox *handler)
1817 {
1818         if (!handler) {
1819                 ErrPrint("Handler is NIL\n");
1820                 return PD_TYPE_INVALID;
1821         }
1822
1823         if (handler->state != CREATE || !handler->id) {
1824                 ErrPrint("Handler is not valid\n");
1825                 return PD_TYPE_INVALID;
1826         }
1827
1828         switch (handler->pd.type) {
1829         case _PD_TYPE_TEXT:
1830                 return PD_TYPE_TEXT;
1831         case _PD_TYPE_BUFFER:
1832         case _PD_TYPE_SCRIPT:
1833                 {
1834                         const char *id;
1835                         id = fb_id(handler->pd.data.fb);
1836                         if (id && !strncasecmp(id, SCHEMA_PIXMAP, strlen(SCHEMA_PIXMAP)))
1837                                 return PD_TYPE_PIXMAP;
1838                 }
1839                 return PD_TYPE_BUFFER;
1840         default:
1841                 break;
1842         }
1843
1844         return PD_TYPE_INVALID;
1845 }
1846
1847 EAPI int livebox_set_pd_text_handler(struct livebox *handler, struct livebox_script_operators *ops)
1848 {
1849         if (!handler) {
1850                 ErrPrint("Handler is NIL\n");
1851                 return LB_STATUS_ERROR_INVALID;
1852         }
1853
1854         if (handler->state != CREATE) {
1855                 ErrPrint("Handler is not valid\n");
1856                 return LB_STATUS_ERROR_INVALID;
1857         }
1858
1859         memcpy(&handler->pd.data.ops, ops, sizeof(*ops));
1860         return LB_STATUS_SUCCESS;
1861 }
1862
1863 EAPI int livebox_set_text_handler(struct livebox *handler, struct livebox_script_operators *ops)
1864 {
1865         if (!handler) {
1866                 ErrPrint("Handler is NIL\n");
1867                 return LB_STATUS_ERROR_INVALID;
1868         }
1869
1870         if (handler->state != CREATE) {
1871                 ErrPrint("Handler is not valid\n");
1872                 return LB_STATUS_ERROR_INVALID;
1873         }
1874
1875         memcpy(&handler->lb.data.ops, ops, sizeof(*ops));
1876         return LB_STATUS_SUCCESS;
1877 }
1878
1879 EAPI int livebox_acquire_lb_pixmap(struct livebox *handler, ret_cb_t cb, void *data)
1880 {
1881         struct packet *packet;
1882         struct cb_info *cbinfo;
1883         const char *id;
1884         int ret;
1885
1886         if (!handler) {
1887                 ErrPrint("Handler is NIL\n");
1888                 return LB_STATUS_ERROR_INVALID;
1889         }
1890
1891         if (handler->state != CREATE || !handler->id) {
1892                 ErrPrint("Invalid handle\n");
1893                 return LB_STATUS_ERROR_INVALID;
1894         }
1895
1896         if (handler->lb.type != _LB_TYPE_SCRIPT && handler->lb.type != _LB_TYPE_BUFFER) {
1897                 ErrPrint("Handler is not valid type\n");
1898                 return LB_STATUS_ERROR_INVALID;
1899         }
1900
1901         id = fb_id(handler->lb.data.fb);
1902         if (!id || strncasecmp(id, SCHEMA_PIXMAP, strlen(SCHEMA_PIXMAP)))
1903                 return LB_STATUS_ERROR_INVALID;
1904
1905         packet = packet_create("lb_acquire_pixmap", "ss", handler->pkgname, handler->id);
1906         if (!packet) {
1907                 ErrPrint("Failed to build a param\n");
1908                 return LB_STATUS_ERROR_FAULT;
1909         }
1910
1911         cbinfo = create_cb_info(cb, data);
1912         if (!cbinfo) {
1913                 packet_destroy(packet);
1914                 return LB_STATUS_ERROR_FAULT;
1915         }
1916
1917         ret = master_rpc_async_request(handler, packet, 0, pixmap_acquired_cb, cbinfo);
1918         if (ret < 0)
1919                 destroy_cb_info(cbinfo);
1920
1921         return ret;
1922 }
1923
1924 EAPI int livebox_release_lb_pixmap(struct livebox *handler, int pixmap)
1925 {
1926         struct packet *packet;
1927
1928         if (!handler) {
1929                 ErrPrint("Handler is NIL\n");
1930                 return LB_STATUS_ERROR_INVALID;
1931         }
1932
1933         if (handler->state != CREATE || !handler->id) {
1934                 ErrPrint("Invalid handle\n");
1935                 return LB_STATUS_ERROR_INVALID;
1936         }
1937
1938         if (handler->lb.type != _LB_TYPE_SCRIPT && handler->lb.type != _LB_TYPE_BUFFER) {
1939                 ErrPrint("Handler is not valid type\n");
1940                 return LB_STATUS_ERROR_INVALID;
1941         }
1942
1943         packet = packet_create_noack("lb_release_pixmap", "ssi", handler->pkgname, handler->id, pixmap);
1944         if (!packet) {
1945                 ErrPrint("Failed to build a param\n");
1946                 return LB_STATUS_ERROR_INVALID;
1947         }
1948
1949         return master_rpc_request_only(handler, packet);
1950 }
1951
1952 EAPI int livebox_acquire_pd_pixmap(struct livebox *handler, ret_cb_t cb, void *data)
1953 {
1954         struct packet *packet;
1955         struct cb_info *cbinfo;
1956         const char *id;
1957         int ret;
1958
1959         if (!handler) {
1960                 ErrPrint("Handler is NIL\n");
1961                 return LB_STATUS_ERROR_INVALID;
1962         }
1963
1964         if (handler->state != CREATE || !handler->id) {
1965                 ErrPrint("Invalid handle\n");
1966                 return LB_STATUS_ERROR_INVALID;
1967         }
1968
1969         if (handler->pd.type != _PD_TYPE_SCRIPT && handler->pd.type != _PD_TYPE_BUFFER) {
1970                 ErrPrint("Handler is not valid type\n");
1971                 return LB_STATUS_ERROR_INVALID;
1972         }
1973
1974         id = fb_id(handler->pd.data.fb);
1975         if (!id || strncasecmp(id, SCHEMA_PIXMAP, strlen(SCHEMA_PIXMAP)))
1976                 return LB_STATUS_ERROR_INVALID;
1977
1978         packet = packet_create("pd_acquire_pixmap", "ss", handler->pkgname, handler->id);
1979         if (!packet) {
1980                 ErrPrint("Failed to build a param\n");
1981                 return LB_STATUS_ERROR_FAULT;
1982         }
1983
1984         cbinfo = create_cb_info(cb, data);
1985         if (!cbinfo) {
1986                 packet_destroy(packet);
1987                 return LB_STATUS_ERROR_FAULT;
1988         }
1989
1990         ret = master_rpc_async_request(handler, packet, 0, pixmap_acquired_cb, cbinfo);
1991         if (ret < 0)
1992                 destroy_cb_info(cbinfo);
1993
1994         return ret;
1995 }
1996
1997 EAPI int livebox_pd_pixmap(const struct livebox *handler)
1998 {
1999         const char *id;
2000         int pixmap = 0;
2001
2002         if (!handler) {
2003                 ErrPrint("Handler is NIL\n");
2004                 return 0;
2005         }
2006
2007         if (handler->state != CREATE || !handler->id) {
2008                 ErrPrint("Invalid handler\n");
2009                 return 0;
2010         }
2011
2012         if (handler->pd.type != _PD_TYPE_SCRIPT && handler->pd.type != _PD_TYPE_BUFFER) {
2013                 ErrPrint("Invalid handler\n");
2014                 return 0;
2015         }
2016
2017         id = fb_id(handler->pd.data.fb);
2018         if (id && sscanf(id, SCHEMA_PIXMAP "%d", &pixmap) != 1) {
2019                 ErrPrint("PIXMAP Id is not valid\n");
2020                 return 0;
2021         }
2022
2023         return pixmap;
2024 }
2025
2026 EAPI int livebox_lb_pixmap(const struct livebox *handler)
2027 {
2028         const char *id;
2029         int pixmap = 0;
2030
2031         if (!handler) {
2032                 ErrPrint("Handler is NIL\n");
2033                 return 0;
2034         }
2035
2036         if (handler->state != CREATE || !handler->id) {
2037                 ErrPrint("Invalid handler\n");
2038                 return 0;
2039         }
2040
2041         if (handler->lb.type != _LB_TYPE_SCRIPT && handler->lb.type != _LB_TYPE_BUFFER) {
2042                 ErrPrint("Invalid handler\n");
2043                 return 0;
2044         }
2045
2046         id = fb_id(handler->lb.data.fb);
2047         if (id && sscanf(id, SCHEMA_PIXMAP "%d", &pixmap) != 1) {
2048                 ErrPrint("PIXMAP Id is not valid\n");
2049                 return 0;
2050         }
2051
2052         return pixmap;
2053 }
2054
2055 EAPI int livebox_release_pd_pixmap(struct livebox *handler, int pixmap)
2056 {
2057         struct packet *packet;
2058
2059         if (!handler) {
2060                 ErrPrint("Handler is NIL\n");
2061                 return LB_STATUS_ERROR_INVALID;
2062         }
2063
2064         if (handler->state != CREATE || !handler->id) {
2065                 ErrPrint("Invalid handle\n");
2066                 return LB_STATUS_ERROR_INVALID;
2067         }
2068
2069         if (handler->pd.type != _PD_TYPE_SCRIPT && handler->pd.type != _PD_TYPE_BUFFER) {
2070                 ErrPrint("Handler is not valid type\n");
2071                 return LB_STATUS_ERROR_INVALID;
2072         }
2073
2074         packet = packet_create_noack("pd_release_pixmap", "ssi", handler->pkgname, handler->id, pixmap);
2075         if (!packet) {
2076                 ErrPrint("Failed to build a param\n");
2077                 return LB_STATUS_ERROR_FAULT;
2078         }
2079
2080         return master_rpc_request_only(handler, packet);
2081 }
2082
2083 EAPI void *livebox_acquire_fb(struct livebox *handler)
2084 {
2085         if (!handler) {
2086                 ErrPrint("Handler is NIL\n");
2087                 return NULL;
2088         }
2089
2090         if (handler->state != CREATE || !handler->id) {
2091                 ErrPrint("Invalid handle\n");
2092                 return NULL;
2093         }
2094
2095         if (handler->lb.type != _LB_TYPE_SCRIPT && handler->lb.type != _LB_TYPE_BUFFER) {
2096                 ErrPrint("Handler is not valid type\n");
2097                 return NULL;
2098         }
2099
2100         return fb_acquire_buffer(handler->lb.data.fb);
2101 }
2102
2103 EAPI int livebox_release_fb(void *buffer)
2104 {
2105         return fb_release_buffer(buffer);
2106 }
2107
2108 EAPI int livebox_fb_refcnt(void *buffer)
2109 {
2110         return fb_refcnt(buffer);
2111 }
2112
2113 EAPI void *livebox_acquire_pdfb(struct livebox *handler)
2114 {
2115         if (!handler) {
2116                 ErrPrint("Handler is NIL\n");
2117                 return NULL;
2118         }
2119
2120         if (handler->state != CREATE || !handler->id) {
2121                 ErrPrint("Invalid handler\n");
2122                 return NULL;
2123         }
2124
2125         if (handler->pd.type != _PD_TYPE_SCRIPT && handler->pd.type != _PD_TYPE_BUFFER) {
2126                 ErrPrint("Handler is not valid type\n");
2127                 return NULL;
2128         }
2129
2130         return fb_acquire_buffer(handler->pd.data.fb);
2131 }
2132
2133 EAPI int livebox_release_pdfb(void *buffer)
2134 {
2135         return fb_release_buffer(buffer);
2136 }
2137
2138 EAPI int livebox_pdfb_refcnt(void *buffer)
2139 {
2140         return fb_refcnt(buffer);
2141 }
2142
2143 EAPI int livebox_pdfb_bufsz(struct livebox *handler)
2144 {
2145         if (!handler) {
2146                 ErrPrint("Handler is NIL\n");
2147                 return LB_STATUS_ERROR_INVALID;
2148         }
2149
2150         if (handler->state != CREATE || !handler->id) {
2151                 ErrPrint("Handler is not valid\n");
2152                 return LB_STATUS_ERROR_INVALID;
2153         }
2154
2155         return fb_size(handler->pd.data.fb);
2156 }
2157
2158 EAPI int livebox_lbfb_bufsz(struct livebox *handler)
2159 {
2160         if (!handler) {
2161                 ErrPrint("Handler is NIL\n");
2162                 return LB_STATUS_ERROR_INVALID;
2163         }
2164
2165         if (handler->state != CREATE || !handler->id) {
2166                 ErrPrint("Handler is not valid\n");
2167                 return LB_STATUS_ERROR_INVALID;
2168         }
2169
2170         return fb_size(handler->lb.data.fb);
2171 }
2172
2173 EAPI int livebox_is_user(struct livebox *handler)
2174 {
2175         if (!handler) {
2176                 ErrPrint("Handler is NIL\n");
2177                 return LB_STATUS_ERROR_INVALID;
2178         }
2179
2180         if (handler->state != CREATE) {
2181                 ErrPrint("Handler is invalid\n");
2182                 return LB_STATUS_ERROR_INVALID;
2183         }
2184
2185         return handler->is_user;
2186 }
2187
2188 EAPI int livebox_set_pinup(struct livebox *handler, int flag, ret_cb_t cb, void *data)
2189 {
2190         struct packet *packet;
2191         int ret;
2192
2193         if (!handler) {
2194                 ErrPrint("Handler is NIL\n");
2195                 return LB_STATUS_ERROR_INVALID;
2196         }
2197
2198         if (handler->state != CREATE || !handler->id) {
2199                 ErrPrint("Handler is not valid\n");
2200                 return LB_STATUS_ERROR_INVALID;
2201         }
2202
2203         if (handler->pinup_cb) {
2204                 ErrPrint("Previous pinup request is not finished\n");
2205                 return LB_STATUS_ERROR_BUSY;
2206         }
2207
2208         if (handler->is_pinned_up == flag) {
2209                 DbgPrint("No changes\n");
2210                 return LB_STATUS_ERROR_ALREADY;
2211         }
2212
2213         packet = packet_create("pinup_changed", "ssi", handler->pkgname, handler->id, flag);
2214         if (!packet) {
2215                 ErrPrint("Failed to build a param\n");
2216                 return LB_STATUS_ERROR_FAULT;
2217         }
2218
2219         if (!cb)
2220                 cb = default_pinup_cb;
2221
2222         handler->pinup_cb = cb;
2223         handler->pinup_cbdata = data;
2224
2225         ret = master_rpc_async_request(handler, packet, 0, pinup_done_cb, NULL);
2226         if (ret < 0) {
2227                 handler->pinup_cb = NULL;
2228                 handler->pinup_cbdata = NULL;
2229         }
2230
2231         return ret;
2232 }
2233
2234 EAPI int livebox_is_pinned_up(struct livebox *handler)
2235 {
2236         if (!handler) {
2237                 ErrPrint("Handler is NIL\n");
2238                 return LB_STATUS_ERROR_INVALID;
2239         }
2240
2241         if (handler->state != CREATE || !handler->id)
2242                 return LB_STATUS_ERROR_INVALID;
2243
2244         return handler->is_pinned_up;
2245 }
2246
2247 EAPI int livebox_has_pinup(struct livebox *handler)
2248 {
2249         if (!handler) {
2250                 ErrPrint("Handler is NIL\n");
2251                 return LB_STATUS_ERROR_INVALID;
2252         }
2253
2254         if (handler->state != CREATE || !handler->id)
2255                 return LB_STATUS_ERROR_INVALID;
2256
2257         return handler->lb.pinup_supported;
2258 }
2259
2260 EAPI int livebox_set_data(struct livebox *handler, void *data)
2261 {
2262         if (!handler) {
2263                 ErrPrint("Handler is NIL\n");
2264                 return LB_STATUS_ERROR_INVALID;
2265         }
2266
2267         if (handler->state != CREATE)
2268                 return LB_STATUS_ERROR_INVALID;
2269
2270         handler->data = data;
2271         return LB_STATUS_SUCCESS;
2272 }
2273
2274 EAPI void *livebox_get_data(struct livebox *handler)
2275 {
2276         if (!handler) {
2277                 ErrPrint("Handler is NIL\n");
2278                 return NULL;
2279         }
2280
2281         if (handler->state != CREATE)
2282                 return NULL;
2283
2284         return handler->data;
2285 }
2286
2287 EAPI int livebox_is_exists(const char *pkgname)
2288 {
2289         char *lb;
2290
2291         lb = lb_pkgname(pkgname);
2292         if (lb) {
2293                 free(lb);
2294                 return 1;
2295         }
2296
2297         return 0;
2298 }
2299
2300 EAPI const char *livebox_content(struct livebox *handler)
2301 {
2302         if (!handler) {
2303                 ErrPrint("Handler is NIL\n");
2304                 return NULL;
2305         }
2306
2307         if (handler->state != CREATE)
2308                 return NULL;
2309
2310         return handler->content;
2311 }
2312
2313 EAPI const char *livebox_category_title(struct livebox *handler)
2314 {
2315         if (!handler) {
2316                 ErrPrint("Handler is NIL\n");
2317                 return NULL;
2318         }
2319
2320         if (handler->state != CREATE)
2321                 return NULL;
2322
2323         return handler->title;
2324 }
2325
2326 EAPI int livebox_emit_text_signal(struct livebox *handler, const char *emission, const char *source, double sx, double sy, double ex, double ey, ret_cb_t cb, void *data)
2327 {
2328         struct packet *packet;
2329         struct cb_info *cbinfo;
2330         int ret;
2331
2332         if (!handler) {
2333                 ErrPrint("Handler is NIL\n");
2334                 return LB_STATUS_ERROR_INVALID;
2335         }
2336
2337         if ((handler->lb.type != _LB_TYPE_TEXT && handler->pd.type != _PD_TYPE_TEXT) || handler->state != CREATE || !handler->id) {
2338                 ErrPrint("Handler is not valid\n");
2339                 return LB_STATUS_ERROR_INVALID;
2340         }
2341
2342         if (!emission)
2343                 emission = "";
2344
2345         if (!source)
2346                 source = "";
2347
2348         packet = packet_create("text_signal", "ssssdddd",
2349                                 handler->pkgname, handler->id, emission, source, sx, sy, ex, ey);
2350         if (!packet) {
2351                 ErrPrint("Failed to build a param\n");
2352                 return LB_STATUS_ERROR_FAULT;
2353         }
2354
2355         cbinfo = create_cb_info(cb, data);
2356         if (!cbinfo) {
2357                 packet_destroy(packet);
2358                 return LB_STATUS_ERROR_FAULT;
2359         }
2360
2361         ret = master_rpc_async_request(handler, packet, 0, text_signal_cb, cbinfo);
2362         if (ret < 0)
2363                 destroy_cb_info(cbinfo);
2364
2365         return LB_STATUS_ERROR_FAULT;
2366 }
2367
2368 EAPI int livebox_subscribe_group(const char *cluster, const char *category)
2369 {
2370         struct packet *packet;
2371
2372         /*!
2373          * \TODO
2374          * Validate the group info using DB
2375          * If the group info is not valid, do not send this request
2376          */
2377
2378         packet = packet_create_noack("subscribe", "ss", cluster ? cluster : "", category ? category : "");
2379         if (!packet) {
2380                 ErrPrint("Failed to create a packet\n");
2381                 return LB_STATUS_ERROR_FAULT;
2382         }
2383
2384         return master_rpc_request_only(NULL, packet);
2385 }
2386
2387 EAPI int livebox_unsubscribe_group(const char *cluster, const char *category)
2388 {
2389         struct packet *packet;
2390
2391         /*!
2392          * \TODO
2393          * Validate the group info using DB
2394          * If the group info is not valid, do not send this request
2395          * AND Check the subscribed or not too
2396          */
2397
2398         packet = packet_create_noack("unsubscribe", "ss", cluster ? cluster : "", category ? category : "");
2399         if (!packet) {
2400                 ErrPrint("Failed to create a packet\n");
2401                 return LB_STATUS_ERROR_FAULT;
2402         }
2403
2404         return master_rpc_request_only(NULL, packet);
2405 }
2406
2407 EAPI int livebox_refresh(struct livebox *handler)
2408 {
2409         struct packet *packet;
2410
2411         if (!handler) {
2412                 ErrPrint("Hnalder is NIL\n");
2413                 return LB_STATUS_ERROR_INVALID;
2414         }
2415
2416         if (handler->state != CREATE || !handler->id)
2417                 return LB_STATUS_ERROR_INVALID;
2418
2419         packet = packet_create_noack("update", "ss", handler->pkgname, handler->id);
2420         if (!packet) {
2421                 ErrPrint("Failed to create a packet\n");
2422                 return LB_STATUS_ERROR_FAULT;
2423         }
2424
2425         return master_rpc_request_only(handler, packet);
2426 }
2427
2428 EAPI int livebox_refresh_group(const char *cluster, const char *category)
2429 {
2430         struct packet *packet;
2431
2432         if (!cluster || !category) {
2433                 ErrPrint("Invalid argument\n");
2434                 return LB_STATUS_ERROR_INVALID;
2435         }
2436
2437         packet = packet_create_noack("refresh_group", "ss", cluster, category);
2438         if (!packet) {
2439                 ErrPrint("Failed to create a packet\n");
2440                 return LB_STATUS_ERROR_FAULT;
2441         }
2442
2443         return master_rpc_request_only(NULL, packet);
2444 }
2445
2446 EAPI int livebox_set_visibility(struct livebox *handler, enum livebox_visible_state state)
2447 {
2448         struct packet *packet;
2449         int ret;
2450
2451         if (!handler) {
2452                 ErrPrint("Handler is NIL\n");
2453                 return LB_STATUS_ERROR_INVALID;
2454         }
2455
2456         if (handler->state != CREATE || !handler->id)
2457                 return LB_STATUS_ERROR_INVALID;
2458
2459         if (!handler->is_user) {
2460                 /* System cluster livebox cannot be changed its visible states */
2461                 if (state == LB_HIDE_WITH_PAUSE) {
2462                         ErrPrint("CA Livebox is not able to change the visibility\n");
2463                         return LB_STATUS_ERROR_PERMISSION;
2464                 }
2465         }
2466
2467         DbgPrint("Change the visibility %d <> %d, %s\n", handler->visible, state, handler->id);
2468
2469         if (handler->visible == state)
2470                 return LB_STATUS_ERROR_ALREADY;
2471
2472         packet = packet_create_noack("change,visibility", "ssi", handler->pkgname, handler->id, (int)state);
2473         if (!packet) {
2474                 ErrPrint("Failed to create a packet\n");
2475                 return LB_STATUS_ERROR_FAULT;
2476         }
2477
2478         ret = master_rpc_request_only(handler, packet);
2479         if (ret == 0)
2480                 handler->visible = state;
2481
2482         return ret;
2483 }
2484
2485 EAPI enum livebox_visible_state livebox_visibility(struct livebox *handler)
2486 {
2487         if (!handler) {
2488                 ErrPrint("Handler is NIL\n");
2489                 return LB_VISIBLE_ERROR;
2490         }
2491
2492         if (handler->state != CREATE || !handler->id)
2493                 return LB_VISIBLE_ERROR;
2494
2495         return handler->visible;
2496 }
2497
2498 int lb_set_group(struct livebox *handler, const char *cluster, const char *category)
2499 {
2500         void *pc = NULL;
2501         void *ps = NULL;
2502
2503         if (cluster) {
2504                 pc = strdup(cluster);
2505                 if (!pc) {
2506                         CRITICAL_LOG("Heap: %s (cluster: %s)\n", strerror(errno), cluster);
2507                         return LB_STATUS_ERROR_MEMORY;
2508                 }
2509         }
2510
2511         if (category) {
2512                 ps = strdup(category);
2513                 if (!ps) {
2514                         CRITICAL_LOG("Heap: %s (category: %s)\n", strerror(errno), category);
2515                         free(pc);
2516                         return LB_STATUS_ERROR_MEMORY;
2517                 }
2518         }
2519
2520         if (handler->cluster)
2521                 free(handler->cluster);
2522
2523         if (handler->category)
2524                 free(handler->category);
2525
2526         handler->cluster = pc;
2527         handler->category = ps;
2528
2529         return LB_STATUS_SUCCESS;
2530 }
2531
2532 void lb_set_size(struct livebox *handler, int w, int h)
2533 {
2534         handler->lb.width = w;
2535         handler->lb.height = h;
2536 }
2537
2538 void lb_set_update_mode(struct livebox *handle, int active_mode)
2539 {
2540         handle->is_active_update = active_mode;
2541 }
2542
2543 void lb_set_pdsize(struct livebox *handler, int w, int h)
2544 {
2545         handler->pd.width = w;
2546         handler->pd.height = h;
2547 }
2548
2549 void lb_set_default_pdsize(struct livebox *handler, int w, int h)
2550 {
2551         handler->pd.default_width = w;
2552         handler->pd.default_height = h;
2553 }
2554
2555 void lb_invoke_fault_handler(enum livebox_fault_type event, const char *pkgname, const char *file, const char *func)
2556 {
2557         struct dlist *l;
2558         struct dlist *n;
2559         struct fault_info *info;
2560
2561         dlist_foreach_safe(s_info.fault_list, l, n, info) {
2562                 if (info->handler(event, pkgname, file, func, info->user_data) == EXIT_FAILURE)
2563                         s_info.fault_list = dlist_remove(s_info.fault_list, l);
2564         }
2565 }
2566
2567 void lb_invoke_event_handler(struct livebox *handler, enum livebox_event_type event)
2568 {
2569         struct dlist *l;
2570         struct dlist *n;
2571         struct event_info *info;
2572
2573         dlist_foreach_safe(s_info.event_list, l, n, info) {
2574                 if (info->handler(handler, event, info->user_data) == EXIT_FAILURE)
2575                         s_info.event_list = dlist_remove(s_info.event_list, l);
2576         }
2577 }
2578
2579 struct livebox *lb_find_livebox(const char *pkgname, const char *id)
2580 {
2581         struct dlist *l;
2582         struct livebox *handler;
2583
2584         dlist_foreach(s_info.livebox_list, l, handler) {
2585                 if (!handler->id)
2586                         continue;
2587
2588                 if (!strcmp(handler->pkgname, pkgname) && !strcmp(handler->id, id))
2589                         return handler;
2590         }
2591
2592         return NULL;
2593 }
2594
2595 struct livebox *lb_find_livebox_by_timestamp(double timestamp)
2596 {
2597         struct dlist *l;
2598         struct livebox *handler;
2599
2600         dlist_foreach(s_info.livebox_list, l, handler) {
2601                 if (handler->timestamp == timestamp)
2602                         return handler;
2603         }
2604
2605         return NULL;
2606 }
2607
2608 static inline char *get_file_kept_in_safe(const char *id)
2609 {
2610         const char *path;
2611         char *new_path;
2612         int len;
2613         int base_idx;
2614
2615         path = util_uri_to_path(id);
2616         if (!path) {
2617                 ErrPrint("Invalid URI(%s)\n", id);
2618                 return NULL;
2619         }
2620
2621         /*!
2622          * \TODO: REMOVE ME
2623          */
2624         if (s_info.prevent_overwrite) {
2625                 new_path = strdup(path);
2626                 if (!new_path)
2627                         ErrPrint("Heap: %s\n", strerror(errno));
2628
2629                 return new_path;
2630         }
2631
2632
2633         len = strlen(path);
2634         base_idx = len - 1;
2635
2636         while (base_idx > 0 && path[base_idx] != '/') base_idx--;
2637         base_idx += (path[base_idx] == '/');
2638
2639         new_path = malloc(len + 10);
2640         if (!new_path) {
2641                 ErrPrint("Heap: %s\n", strerror(errno));
2642                 return NULL;
2643         }
2644
2645         strncpy(new_path, path, base_idx);
2646         snprintf(new_path + base_idx, len + 10 - base_idx, "reader/%s", path + base_idx);
2647         return new_path;
2648 }
2649
2650 struct livebox *lb_new_livebox(const char *pkgname, const char *id, double timestamp)
2651 {
2652         struct livebox *handler;
2653
2654         handler = calloc(1, sizeof(*handler));
2655         if (!handler) {
2656                 ErrPrint("Failed to create a new livebox\n");
2657                 return NULL;
2658         }
2659
2660         handler->pkgname = strdup(pkgname);
2661         if (!handler->pkgname) {
2662                 ErrPrint("%s\n", strerror(errno));
2663                 free(handler);
2664                 return NULL;
2665         }
2666
2667         handler->id = strdup(id);
2668         if (!handler->id) {
2669                 ErrPrint("%s\n", strerror(errno));
2670                 free(handler->pkgname);
2671                 free(handler);
2672                 return NULL;
2673         }
2674
2675         handler->filename = get_file_kept_in_safe(id);
2676         if (!handler->filename) {
2677                 handler->filename = strdup(util_uri_to_path(id));
2678                 if (!handler->filename)
2679                         ErrPrint("Error: %s\n", strerror(errno));
2680         }
2681
2682         handler->timestamp = timestamp;
2683         handler->lb.type = _LB_TYPE_FILE;
2684         handler->pd.type = _PD_TYPE_SCRIPT;
2685         handler->state = CREATE;
2686         handler->visible = LB_SHOW;
2687
2688         s_info.livebox_list = dlist_append(s_info.livebox_list, handler);
2689         lb_ref(handler);
2690         return handler;
2691 }
2692
2693 int lb_delete_all(void)
2694 {
2695         struct dlist *l;
2696         struct dlist *n;
2697         struct livebox *handler;
2698
2699         dlist_foreach_safe(s_info.livebox_list, l, n, handler) {
2700                 lb_invoke_event_handler(handler, LB_EVENT_DELETED);
2701                 lb_unref(handler);
2702         }
2703
2704         return LB_STATUS_SUCCESS;
2705 }
2706
2707 int lb_set_content(struct livebox *handler, const char *content)
2708 {
2709         if (handler->content) {
2710                 free(handler->content);
2711                 handler->content = NULL;
2712         }
2713
2714         if (content) {
2715                 handler->content = strdup(content);
2716                 if (!handler->content) {
2717                         CRITICAL_LOG("Heap: %s (content: %s)\n", strerror(errno), content);
2718                         return LB_STATUS_ERROR_MEMORY;
2719                 }
2720         }
2721
2722         return LB_STATUS_SUCCESS;
2723 }
2724
2725 int lb_set_title(struct livebox *handler, const char *title)
2726 {
2727         if (handler->title) {
2728                 free(handler->title);
2729                 handler->title = NULL;
2730         }
2731
2732         if (title) {
2733                 handler->title = strdup(title);
2734                 if (!handler->title) {
2735                         CRITICAL_LOG("Heap: %s (title: %s)\n", strerror(errno), title);
2736                         return LB_STATUS_ERROR_MEMORY;
2737                 }
2738         }
2739
2740         return LB_STATUS_SUCCESS;
2741 }
2742
2743 void lb_set_size_list(struct livebox *handler, int size_list)
2744 {
2745         handler->lb.size_list = size_list;
2746 }
2747
2748 void lb_set_auto_launch(struct livebox *handler, const char *auto_launch)
2749 {
2750         if (!strlen(auto_launch))
2751                 return;
2752
2753         handler->lb.auto_launch = strdup(auto_launch);
2754         if (!handler->lb.auto_launch)
2755                 ErrPrint("Heap: %s\n", strerror(errno));
2756 }
2757
2758 void lb_set_priority(struct livebox *handler, double priority)
2759 {
2760         handler->lb.priority = priority;
2761 }
2762
2763 void lb_set_id(struct livebox *handler, const char *id)
2764 {
2765         if (handler->id)
2766                 free(handler->id);
2767
2768         handler->id = strdup(id);
2769         if (!handler->id)
2770                 ErrPrint("Error: %s\n", strerror(errno));
2771
2772         if (handler->filename)
2773                 free(handler->filename);
2774
2775         handler->filename = get_file_kept_in_safe(id);
2776         if (!handler->filename) {
2777                 handler->filename = strdup(util_uri_to_path(id));
2778                 if (!handler->filename)
2779                         ErrPrint("Error: %s\n", strerror(errno));
2780         }
2781 }
2782
2783 int lb_set_lb_fb(struct livebox *handler, const char *filename)
2784 {
2785         struct fb_info *fb;
2786
2787         if (!handler)
2788                 return LB_STATUS_ERROR_INVALID;
2789
2790         fb = handler->lb.data.fb;
2791         if (fb && !strcmp(fb_id(fb), filename)) /*!< BUFFER is not changed, */
2792                 return LB_STATUS_SUCCESS;
2793
2794         handler->lb.data.fb = NULL;
2795
2796         if (!filename || filename[0] == '\0') {
2797                 if (fb)
2798                         fb_destroy(fb);
2799                 return LB_STATUS_SUCCESS;
2800         }
2801
2802         handler->lb.data.fb = fb_create(filename, handler->lb.width, handler->lb.height);
2803         if (!handler->lb.data.fb) {
2804                 ErrPrint("Faield to create a FB\n");
2805                 if (fb)
2806                         fb_destroy(fb);
2807                 return LB_STATUS_ERROR_FAULT;
2808         }
2809
2810         if (fb)
2811                 fb_destroy(fb);
2812
2813         return LB_STATUS_SUCCESS;
2814 }
2815
2816 int lb_set_pd_fb(struct livebox *handler, const char *filename)
2817 {
2818         struct fb_info *fb;
2819
2820         if (!handler)
2821                 return LB_STATUS_ERROR_INVALID;
2822
2823         fb = handler->pd.data.fb;
2824         if (fb && !strcmp(fb_id(fb), filename)) {
2825                 /* BUFFER is not changed, just update the content */
2826                 return LB_STATUS_ERROR_EXIST;
2827         }
2828         handler->pd.data.fb = NULL;
2829
2830         if (!filename || filename[0] == '\0') {
2831                 if (fb)
2832                         fb_destroy(fb);
2833                 return LB_STATUS_SUCCESS;
2834         }
2835
2836         handler->pd.data.fb = fb_create(filename, handler->pd.width, handler->pd.height);
2837         if (!handler->pd.data.fb) {
2838                 ErrPrint("Failed to create a FB\n");
2839                 if (fb)
2840                         fb_destroy(fb);
2841                 return LB_STATUS_ERROR_FAULT;
2842         }
2843
2844         if (fb)
2845                 fb_destroy(fb);
2846         return LB_STATUS_SUCCESS;
2847 }
2848
2849 struct fb_info *lb_get_lb_fb(struct livebox *handler)
2850 {
2851         return handler->lb.data.fb;
2852 }
2853
2854 struct fb_info *lb_get_pd_fb(struct livebox *handler)
2855 {
2856         return handler->pd.data.fb;
2857 }
2858
2859 void lb_set_user(struct livebox *handler, int user)
2860 {
2861         handler->is_user = user;
2862 }
2863
2864 void lb_set_pinup(struct livebox *handler, int pinup_supported)
2865 {
2866         handler->lb.pinup_supported = pinup_supported;
2867 }
2868
2869 void lb_set_text_lb(struct livebox *handler)
2870 {
2871         handler->lb.type = _LB_TYPE_TEXT;
2872 }
2873
2874 void lb_set_text_pd(struct livebox *handler)
2875 {
2876         handler->pd.type = _PD_TYPE_TEXT;
2877 }
2878
2879 int lb_text_lb(struct livebox *handler)
2880 {
2881         return handler->lb.type == _LB_TYPE_TEXT;
2882 }
2883
2884 int lb_text_pd(struct livebox *handler)
2885 {
2886         return handler->pd.type == _PD_TYPE_TEXT;
2887 }
2888
2889 void lb_set_period(struct livebox *handler, double period)
2890 {
2891         handler->lb.period = period;
2892 }
2893
2894 struct livebox *lb_ref(struct livebox *handler)
2895 {
2896         if (!handler)
2897                 return NULL;
2898
2899         handler->refcnt++;
2900         return handler;
2901 }
2902
2903 struct livebox *lb_unref(struct livebox *handler)
2904 {
2905         if (!handler)
2906                 return NULL;
2907
2908         handler->refcnt--;
2909         if (handler->refcnt > 0)
2910                 return handler;
2911
2912         if (handler->created_cb) {
2913                 DbgPrint("Clear created event callback\n");
2914                 handler->created_cb(handler, LB_STATUS_ERROR_FAULT, handler->created_cbdata);
2915                 handler->created_cb = NULL;
2916                 handler->created_cbdata = NULL;
2917         }
2918
2919         if (handler->deleted_cb) {
2920                 DbgPrint("Clear deleted event callback\n");
2921                 handler->deleted_cb(handler, LB_STATUS_ERROR_FAULT, handler->deleted_cbdata);
2922                 handler->deleted_cb = NULL;
2923                 handler->deleted_cbdata = NULL;
2924         }
2925
2926         if (handler->pinup_cb) {
2927                 DbgPrint("Clear pinup event callback\n");
2928                 handler->pinup_cb(handler, LB_STATUS_ERROR_FAULT, handler->pinup_cbdata);
2929                 handler->pinup_cb = NULL;
2930                 handler->pinup_cbdata = NULL;
2931         }
2932
2933         if (handler->group_changed_cb) {
2934                 DbgPrint("Clear group changed event callback\n");
2935                 handler->group_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->group_cbdata);
2936                 handler->group_changed_cb = NULL;
2937                 handler->group_cbdata = NULL;
2938         }
2939
2940         if (handler->period_changed_cb) {
2941                 DbgPrint("Clear period changed event callback\n");
2942                 handler->period_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->period_cbdata);
2943                 handler->period_changed_cb = NULL;
2944                 handler->period_cbdata = NULL;
2945         }
2946
2947         if (handler->size_changed_cb) {
2948                 DbgPrint("Clear size changed event callback\n");
2949                 handler->size_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->size_cbdata);
2950                 handler->size_changed_cb = NULL;
2951                 handler->size_cbdata = NULL;
2952         }
2953
2954         if (handler->pd_created_cb) {
2955                 DbgPrint("Clear pd created event callback\n");
2956                 handler->pd_created_cb(handler, LB_STATUS_ERROR_FAULT, handler->pd_created_cbdata);
2957                 handler->pd_created_cb = NULL;
2958                 handler->pd_created_cbdata = NULL;
2959         }
2960
2961         if (handler->pd_destroyed_cb) {
2962                 DbgPrint("Clear pd destroyed event callback\n");
2963                 handler->pd_destroyed_cb(handler, LB_STATUS_ERROR_FAULT, handler->pd_destroyed_cbdata);
2964                 handler->pd_destroyed_cb = NULL;
2965                 handler->pd_destroyed_cbdata = NULL;
2966         }
2967
2968         if (handler->update_mode_cb) {
2969                 DbgPrint("Clear update mode callback\n");
2970                 handler->update_mode_cb(handler, LB_STATUS_ERROR_FAULT, handler->update_mode_cbdata);
2971                 handler->update_mode_cb = NULL;
2972                 handler->update_mode_cbdata = NULL;
2973         }
2974
2975         if (handler->access_event_cb) {
2976                 DbgPrint("Clear access status callback\n");
2977                 handler->access_event_cb(handler, LB_STATUS_ERROR_FAULT, handler->access_event_cbdata);
2978                 handler->access_event_cb = NULL;
2979                 handler->access_event_cbdata = NULL;
2980         }
2981
2982         if (handler->filename)
2983                 util_unlink(handler->filename);
2984
2985         dlist_remove_data(s_info.livebox_list, handler);
2986
2987         handler->state = DESTROYED;
2988         free(handler->cluster);
2989         free(handler->category);
2990         free(handler->id);
2991         free(handler->pkgname);
2992         free(handler->filename);
2993         free(handler->lb.auto_launch);
2994
2995         if (handler->lb.data.fb) {
2996                 fb_destroy(handler->lb.data.fb);
2997                 handler->lb.data.fb = NULL;
2998         }
2999
3000         if (handler->pd.data.fb) {
3001                 fb_destroy(handler->pd.data.fb);
3002                 handler->pd.data.fb = NULL;
3003         }
3004
3005         free(handler);
3006         return NULL;
3007 }
3008
3009 int lb_send_delete(struct livebox *handler, ret_cb_t cb, void *data)
3010 {
3011         struct packet *packet;
3012         struct cb_info *cbinfo;
3013         int ret;
3014
3015         if (!cb && !!data) {
3016                 ErrPrint("Invalid argument\n");
3017                 return LB_STATUS_ERROR_INVALID;
3018         }
3019
3020         if (handler->deleted_cb) {
3021                 ErrPrint("Already in-progress\n");
3022                 return LB_STATUS_ERROR_BUSY;
3023         }
3024
3025         packet = packet_create("delete", "ss", handler->pkgname, handler->id);
3026         if (!packet) {
3027                 ErrPrint("Failed to build a param\n");
3028                 if (cb)
3029                         cb(handler, LB_STATUS_ERROR_FAULT, data);
3030
3031                 return LB_STATUS_ERROR_FAULT;
3032         }
3033
3034         if (!cb)
3035                 cb = default_delete_cb;
3036
3037         cbinfo = create_cb_info(cb, data);
3038         if (!cbinfo) {
3039                 packet_destroy(packet);
3040                 return LB_STATUS_ERROR_FAULT;
3041         }
3042
3043         ret = master_rpc_async_request(handler, packet, 0, del_ret_cb, cbinfo);
3044         if (ret < 0)
3045                 destroy_cb_info(cbinfo);
3046
3047         return ret;
3048 }
3049
3050 EAPI int livebox_client_paused(void)
3051 {
3052         struct packet *packet;
3053
3054         packet = packet_create_noack("client_paused", "d", util_timestamp());
3055         if (!packet) {
3056                 ErrPrint("Failed to create a pause packet\n");
3057                 return LB_STATUS_ERROR_FAULT;
3058         }
3059
3060         return master_rpc_request_only(NULL, packet);
3061 }
3062
3063 EAPI int livebox_client_resumed(void)
3064 {
3065         struct packet *packet;
3066
3067         packet = packet_create_noack("client_resumed", "d", util_timestamp());
3068         if (!packet) {
3069                 ErrPrint("Failed to create a resume packet\n");
3070                 return LB_STATUS_ERROR_FAULT;
3071         }
3072
3073         return master_rpc_request_only(NULL, packet);
3074 }
3075
3076 /* End of a file */