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