#include <string.h> /* strdup */
#include <libgen.h>
#include <unistd.h> /* access */
+#define __USE_GNU
+#include <dlfcn.h>
#include <dlog.h>
#include <livebox-service.h>
/*!
* \brief This function is defined by the data-provider-slave
*/
-extern const char *livebox_find_pkgname(const char *filename);
-extern int livebox_request_update_by_id(const char *uri);
+static struct info {
+ const char *(*find_pkgname)(const char *filename);
+ int (*request_update_by_id)(const char *uri);
+ int (*trigger_update_monitor)(const char *id, int is_pd);
+} s_info = {
+ .find_pkgname = NULL,
+ .request_update_by_id = NULL,
+ .trigger_update_monitor = NULL,
+};
struct block {
unsigned int idx;
struct livebox_buffer_data {
int is_pd;
int accelerated;
+
+ /* for Buffer event wrapper */
+ int (*handler)(struct livebox_buffer *, enum buffer_event, double, double, double, void *);
+ void *cbdata;
};
PUBLIC const int DONE = 0x00;
struct dlist *n;
struct block *block;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
- DbgPrint("Close and flush\n");
dlist_foreach_safe(handle->block_list, l, n, block) {
handle->block_list = dlist_remove(handle->block_list, l);
- DbgPrint("{\n");
fprintf(handle->fp, "{\n");
if (block->type) {
fprintf(handle->fp, "type=%s\n", block->type);
- DbgPrint("type=%s\n", block->type);
}
if (block->part) {
fprintf(handle->fp, "part=%s\n", block->part);
- DbgPrint("part=%s\n", block->part);
}
if (block->data) {
fprintf(handle->fp, "data=%s\n", block->data);
- DbgPrint("data=%s\n", block->data);
}
if (block->option) {
fprintf(handle->fp, "option=%s\n", block->option);
- DbgPrint("option=%s\n", block->option);
}
if (block->id) {
fprintf(handle->fp, "id=%s\n", block->id);
- DbgPrint("id=%s\n", block->id);
}
if (block->target_id) {
fprintf(handle->fp, "target=%s\n", block->target_id);
- DbgPrint("target=%s\n", block->target_id);
}
-
fprintf(handle->fp, "}\n");
- DbgPrint("}\n");
free(block->type);
free(block->part);
free(block);
}
- fclose(handle->fp);
+ if (fclose(handle->fp) != 0) {
+ ErrPrint("fclose: %s\n", strerror(errno));
+ }
free(handle);
return LB_STATUS_SUCCESS;
}
{
struct block *block;
- if (!handle || !category)
+ if (!handle || !category) {
return LB_STATUS_ERROR_INVALID;
+ }
block = calloc(1, sizeof(*block));
- if (!block)
+ if (!block) {
return LB_STATUS_ERROR_MEMORY;
+ }
block->type = strdup(LB_DESC_TYPE_INFO);
if (!block->type) {
struct block *block;
char buffer[BUFSIZ];
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
block = calloc(1, sizeof(*block));
- if (!block)
+ if (!block) {
return LB_STATUS_ERROR_MEMORY;
+ }
block->type = strdup(LB_DESC_TYPE_INFO);
if (!block->type) {
char *ret;
char *ptr;
- if (!str)
+ if (!str) {
return NULL;
+ }
len = strlen(str);
- if (!len)
+ if (!len) {
return NULL;
+ }
ret = malloc(len + 1);
- if (!ret)
+ if (!ret) {
return NULL;
+ }
ptr = ret;
i = 0;
free(block->target_id);
block->target_id = NULL;
- if (!id || !strlen(id))
+ if (!id || !strlen(id)) {
return LB_STATUS_SUCCESS;
+ }
block->target_id = strdup(id);
if (!block->target_id) {
{
struct block *block;
- if (!handle || !type)
+ if (!handle || !type) {
return LB_STATUS_ERROR_INVALID;
+ }
- if (!part)
+ if (!part) {
part = "";
+ }
- if (!data)
+ if (!data) {
data = "";
+ }
block = calloc(1, sizeof(*block));
if (!block) {
return LB_STATUS_ERROR_NOT_EXIST;
}
+/*!
+ * \note
+ * The last "data" argument is same with "user_data" which is managed by "provider_set_user_data).
+ */
+static inline int event_handler_wrapper(struct livebox_buffer *buffer, enum buffer_event event, double timestamp, double x, double y, void *data)
+{
+ const char *pkgname;
+ const char *id;
+ struct livebox_buffer_data *cbdata = data;
+ int ret;
+
+ pkgname = provider_buffer_pkgname(buffer);
+ if (!pkgname) {
+ ErrPrint("pkgname is not valid\n");
+ return LB_STATUS_ERROR_INVALID;
+ }
+
+ id = provider_buffer_id(buffer);
+ if (!id) {
+ ErrPrint("id is not valid[%s]\n", pkgname);
+ return LB_STATUS_ERROR_INVALID;
+ }
+
+ ret = cbdata->handler(buffer, event, timestamp, x, y, cbdata->cbdata);
+
+ switch (event) {
+ case BUFFER_EVENT_HIGHLIGHT:
+ case BUFFER_EVENT_HIGHLIGHT_NEXT:
+ case BUFFER_EVENT_HIGHLIGHT_PREV:
+ case BUFFER_EVENT_ACTIVATE:
+ case BUFFER_EVENT_ACTION_UP:
+ case BUFFER_EVENT_ACTION_DOWN:
+ case BUFFER_EVENT_SCROLL_UP:
+ case BUFFER_EVENT_SCROLL_MOVE:
+ case BUFFER_EVENT_SCROLL_DOWN:
+ case BUFFER_EVENT_UNHIGHLIGHT:
+ DbgPrint("Accessibility event: %d\n", event);
+ if (ret < 0) {
+ (void)provider_send_access_status(pkgname, id, LB_ACCESS_STATUS_ERROR);
+ } else {
+ (void)provider_send_access_status(pkgname, id, ret);
+ }
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+
+static inline int default_event_handler(struct livebox_buffer *buffer, enum buffer_event event, double timestamp, double x, double y, void *data)
+{
+ /* NOP */
+ return 0;
+}
+
PUBLIC struct livebox_buffer *livebox_acquire_buffer(const char *filename, int is_pd, int width, int height, int (*handler)(struct livebox_buffer *, enum buffer_event, double, double, double, void *), void *data)
{
struct livebox_buffer_data *user_data;
}
user_data->is_pd = is_pd;
+ user_data->handler = handler ? handler : default_event_handler;
+ user_data->cbdata = data;
uri_len = strlen(filename) + strlen(FILE_SCHEMA) + 1;
uri = malloc(uri_len);
}
snprintf(uri, uri_len, FILE_SCHEMA "%s", filename);
- pkgname = livebox_find_pkgname(uri);
+ if (!s_info.find_pkgname) {
+ s_info.find_pkgname = dlsym(RTLD_DEFAULT, "livebox_find_pkgname");
+ if (!s_info.find_pkgname) {
+ ErrPrint("Failed to find a \"livebox_find_pkgname\"\n");
+ free(user_data);
+ free(uri);
+ return NULL;
+ }
+ }
+
+ pkgname = s_info.find_pkgname(uri);
if (!pkgname) {
ErrPrint("Invalid Request\n");
free(user_data);
return NULL;
}
- handle = provider_buffer_acquire((!!is_pd) ? TYPE_PD : TYPE_LB, pkgname, uri, width, height, sizeof(int), handler, data);
+ handle = provider_buffer_acquire((!!is_pd) ? TYPE_PD : TYPE_LB, pkgname, uri, width, height, sizeof(int), event_handler_wrapper, user_data);
DbgPrint("Acquire buffer for PD(%s), %s, %p\n", pkgname, uri, handle);
free(uri);
+ if (!handle) {
+ free(user_data);
+ return NULL;
+ }
(void)provider_buffer_set_user_data(handle, user_data);
return handle;
}
snprintf(uri, uri_len, FILE_SCHEMA "%s", filename);
- ret = livebox_request_update_by_id(uri);
+ if (!s_info.request_update_by_id) {
+ s_info.request_update_by_id = dlsym(RTLD_DEFAULT, "livebox_request_update_by_id");
+ if (!s_info.request_update_by_id) {
+ ErrPrint("\"livebox_request_update_by_id\" is not exists\n");
+ free(uri);
+ return LB_STATUS_ERROR_FAULT;
+ }
+ }
+ ret = s_info.request_update_by_id(uri);
free(uri);
return ret;
}
{
struct livebox_buffer_data *user_data;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
if (user_data) {
int w, h, size;
int ret;
- if (!handle)
+ if (!handle) {
return NULL;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data)
+ if (!user_data) {
return NULL;
+ }
if (user_data->accelerated) {
DbgPrint("H/W accelerated buffer is allocated\n");
PUBLIC int livebox_unref_buffer(void *buffer)
{
- if (!buffer)
+ if (!buffer) {
return LB_STATUS_ERROR_INVALID;
+ }
DbgPrint("Unref buffer\n");
return provider_buffer_unref(buffer);
const char *pkgname;
const char *id;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
if (!user_data) {
provider_buffer_sync(handle);
if (user_data->is_pd) {
- if (provider_send_desc_updated(pkgname, id, NULL) < 0)
+ if (provider_send_desc_updated(pkgname, id, NULL) < 0) {
ErrPrint("Failed to send PD updated (%s)\n", id);
+ }
} else {
int w;
int h;
int pixel_size;
- if (provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0)
+ if (provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
ErrPrint("Failed to get size (%s)\n", id);
+ }
- if (provider_send_updated(pkgname, id, w, h, -1.0f, NULL, NULL) < 0)
+ if (provider_send_updated(pkgname, id, w, h, -1.0f, NULL, NULL) < 0) {
ErrPrint("Failed to send updated (%s)\n", id);
+ }
}
return LB_STATUS_SUCCESS;
PUBLIC int livebox_support_hw_buffer(struct livebox_buffer *handle)
{
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
return provider_buffer_pixmap_is_support_hw(handle);
}
struct livebox_buffer_data *user_data;
int ret;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data)
+ if (!user_data) {
return LB_STATUS_ERROR_INVALID;
+ }
- if (user_data->accelerated)
- return -EALREADY;
+ if (user_data->accelerated) {
+ return LB_STATUS_ERROR_ALREADY;
+ }
ret = provider_buffer_pixmap_create_hw(handle);
user_data->accelerated = (ret == 0);
PUBLIC int livebox_destroy_hw_buffer(struct livebox_buffer *handle)
{
struct livebox_buffer_data *user_data;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data || !user_data->accelerated)
+ if (!user_data || !user_data->accelerated) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data->accelerated = 0;
{
struct livebox_buffer_data *user_data;
- if (!handle)
+ if (!handle) {
return NULL;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data || !user_data->accelerated)
+ if (!user_data || !user_data->accelerated) {
return NULL;
+ }
return provider_buffer_pixmap_hw_addr(handle);
}
{
struct livebox_buffer_data *user_data;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data)
+ if (!user_data) {
return LB_STATUS_ERROR_INVALID;
+ }
- if (!user_data->accelerated)
+ if (!user_data->accelerated) {
return LB_STATUS_SUCCESS;
+ }
/*!
* \note
const char *id;
struct livebox_buffer_data *user_data;
- if (!handle)
+ if (!handle) {
return LB_STATUS_ERROR_INVALID;
+ }
user_data = provider_buffer_user_data(handle);
- if (!user_data)
+ if (!user_data) {
return LB_STATUS_ERROR_INVALID;
+ }
- if (!user_data->accelerated)
+ if (!user_data->accelerated) {
return LB_STATUS_SUCCESS;
+ }
pkgname = provider_buffer_pkgname(handle);
if (!pkgname) {
}
if (user_data->is_pd == 1) {
- if (provider_send_desc_updated(pkgname, id, NULL) < 0)
+ if (provider_send_desc_updated(pkgname, id, NULL) < 0) {
ErrPrint("Failed to send PD updated (%s)\n", id);
+ }
} else {
int w;
int h;
int pixel_size;
- if (provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0)
+ if (provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
ErrPrint("Failed to get size (%s)\n", id);
+ }
- if (provider_send_updated(pkgname, id, w, h, -1.0f, NULL, NULL) < 0)
+ if (provider_send_updated(pkgname, id, w, h, -1.0f, NULL, NULL) < 0) {
ErrPrint("Failed to send updated (%s)\n", id);
+ }
}
return LB_STATUS_SUCCESS;
}
+PUBLIC int livebox_content_is_updated(const char *filename, int is_pd)
+{
+ if (!s_info.trigger_update_monitor) {
+ s_info.trigger_update_monitor = dlsym(RTLD_DEFAULT, "livebox_trigger_update_monitor");
+ if (!s_info.trigger_update_monitor) {
+ ErrPrint("Trigger update monitor function is not exists\n");
+ return LB_STATUS_ERROR_FAULT;
+ }
+ }
+
+ return s_info.trigger_update_monitor(filename, is_pd);
+}
+
/* End of a file */