static void __rsp_resource_id_cb(void *data, struct tizen_remote_surface_provider *provider, uint32_t res_id)
{
- LOGE("add app screen : %d", res_id);
- aul_screen_connector_add_app_screen(res_id);
+ struct screen_connector_provider_s *remote = (struct screen_connector_provider_s *)data;
+
+ if (remote == NULL) {
+ LOGE("null remote");
+ return;
+ }
+
+ LOGD("add app screen : %s, %d", remote->id, res_id);
+ aul_screen_connector_add_app_screen(remote->id, res_id);
}
static void __rsp_visibility_cb(void *data, struct tizen_remote_surface_provider *provider, uint32_t visibility)
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __SCREEN_CONNECTOR_TOOLKIT_H__
+#define __SCREEN_CONNECTOR_TOOLKIT_H__
+
+#include <wayland-client.h>
+#include <wayland-tbm-client.h>
+#include <aul_screen_connector.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_UP_DOWN,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_X,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_Y,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_X_Y,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_WHEEL = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_WHEEL_ALL,
+ SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_UP_DOWN = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_UP_DOWN,
+ SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_X = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_X,
+ SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_Y,
+ SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_X_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_X_Y,
+ SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_CANCEL = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_CANCEL_ALL,
+ SCREEN_CONNECTOR_INPUT_TYPE_KEY = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_KEY_ALL,
+} screen_connector_input_type_e;
+
+typedef enum {
+ SCREEN_CONNECTOR_SCREEEN_TYPE_WIDGET = AUL_SCREEN_TYPE_WIDGET,
+ SCREEN_CONNECTOR_SCREEEN_TYPE_WATCH = AUL_SCREEN_TYPE_WATCH,
+ SCREEN_CONNECTOR_SCREEEN_TYPE_UI = AUL_SCREEN_TYPE_UI,
+ SCREEN_CONNECTOR_SCREEEN_TYPE_ALL = AUL_SCREEN_TYPE_ALL,
+} screen_connector_screen_type_e;
+
+typedef void (*screen_connector_toolkit_added_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_toolkit_removed_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_toolkit_update_cb)(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys,
+ const char *appid, const char *instance_id, const int pid, void *data);
+
+typedef struct _screen_connector_toolkit_ops {
+ screen_connector_toolkit_added_cb added_cb;
+ screen_connector_toolkit_removed_cb removed_cb;
+ screen_connector_toolkit_update_cb updated_cb;
+} screen_connector_toolkit_ops;
+
+typedef struct _screen_connector_toolkit_h *screen_connector_toolkit_h;
+typedef struct _screen_connector_type_h *screen_connector_type_h;
+
+int screen_connector_toolkit_init(screen_connector_screen_type_e type);
+int screen_connector_toolkit_fini(screen_connector_screen_type_e type);
+screen_connector_toolkit_h screen_connector_toolkit_add(screen_connector_toolkit_ops *ops, char *id,
+ screen_connector_screen_type_e type, void *data);
+int screen_connector_toolkit_remove(screen_connector_toolkit_h h);
+int screen_connector_toolkit_update(const char *appid, const char *instance_id);
+const char *screen_connector_toolkit_get_appid(screen_connector_toolkit_h h);
+const char *screen_connector_toolkit_get_instance_id(screen_connector_toolkit_h h);
+int screen_connector_toolkit_get_pid(screen_connector_toolkit_h h);
+int screen_connector_toolkit_get_surface_id(screen_connector_toolkit_h h);
+void *screen_connector_toolkit_get_user_data(screen_connector_toolkit_h h);
+
+unsigned int screen_connector_toolkit_get_event_filter(screen_connector_toolkit_h h);
+int screen_connector_toolkit_check_input_disabled(screen_connector_toolkit_h h, screen_connector_input_type_e input);
+screen_connector_toolkit_h screen_connector_toolkit_create_handle(char *id, int surface_id,
+ screen_connector_toolkit_ops *ops, void *data);
+struct tizen_remote_surface *screen_connector_toolkit_get_trs(screen_connector_toolkit_h h);
+int screen_connector_toolkit_redirect_surface(screen_connector_toolkit_h info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __SCREEN_CONNECTOR_WATCHER_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __SCREEN_CONNECTOR_TRS_H__
+#define __SCREEN_CONNECTOR_TRS_H__
+
+#include <wayland-client.h>
+#include <wayland-tbm-client.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int screen_connector_trs_init(void);
+int screen_connector_trs_fini(void);
+struct wl_tbm *screen_connector_get_tbm();
+struct tizen_remote_surface_manager *screen_connector_get_rsm();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __SCREEN_CONNECTOR_WATCHER_H__ */
extern "C" {
#endif
-typedef enum {
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_UP_DOWN,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_X,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_Y,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_MOVE_X_Y,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_WHEEL = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_WHEEL_ALL,
- SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_UP_DOWN = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_UP_DOWN,
- SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_X = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_X,
- SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_Y,
- SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_MOVE_X_Y = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_MOVE_X_Y,
- SCREEN_CONNECTOR_INPUT_TYPE_TOUCH_CANCEL = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_CANCEL_ALL,
- SCREEN_CONNECTOR_INPUT_TYPE_KEY = TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_KEY_ALL,
-} screen_connector_input_type_e;
-
-typedef void (*screen_connector_watcher_update_cb)(struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time, void *data);
-typedef void (*screen_connector_watcher_missing_cb)(struct tizen_remote_surface *trs, void *data);
-typedef void (*screen_connector_watcher_change_cb)(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
- int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, void *data);
+typedef void (*screen_connector_watcher_added_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_watcher_removed_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_watcher_update_cb)(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys,
+ const char *appid, const char *instance_id, const int pid,void *data);
typedef struct _screen_connector_watcher_ops {
- screen_connector_watcher_update_cb update_cb;
- screen_connector_watcher_missing_cb missing_cb;
- screen_connector_watcher_change_cb change_cb;
+ screen_connector_watcher_added_cb added_cb;
+ screen_connector_watcher_removed_cb removed_cb;
+ screen_connector_watcher_update_cb updated_cb;
} screen_connector_watcher_ops;
typedef struct _screen_connector_watcher_h *screen_connector_watcher_h;
+typedef struct _screen_connector_info_h *screen_connector_info_h;
int screen_connector_watcher_init(void);
int screen_connector_watcher_fini(void);
-screen_connector_watcher_h screen_connector_watcher_add(screen_connector_watcher_ops *ops, char *id, void *data);
+screen_connector_watcher_h screen_connector_watcher_add(screen_connector_watcher_ops *ops, void *data);
int screen_connector_watcher_remove(screen_connector_watcher_h h);
-int screen_connector_watcher_update(const char *appid);
-char *screen_connector_watcher_get_appid(screen_connector_watcher_h h);
-int screen_connector_watcher_get_pid(screen_connector_watcher_h h);
-int screen_connector_watcher_get_resource_id(screen_connector_watcher_h h);
+int screen_connector_watcher_update(screen_connector_watcher_h h, const char *instance_id);
+char *screen_connector_watcher_get_appid(screen_connector_info_h h);
+char *screen_connector_watcher_get_instance_id(screen_connector_info_h h);
+int screen_connector_watcher_get_pid(screen_connector_info_h h);
+int screen_connector_watcher_get_surface_id(screen_connector_info_h h);
+void *screen_connector_watcher_get_user_data(screen_connector_info_h h);
+
int screen_connector_watcher_set_resource_id(screen_connector_watcher_h h, int rid);
-unsigned int screen_connector_watcher_get_event_filter(screen_connector_watcher_h h);
-int screen_connector_watcher_check_input_disabled(screen_connector_watcher_h h, screen_connector_input_type_e input);
struct tizen_remote_surface *screen_connector_watcher_get_trs(screen_connector_watcher_h h);
screen_connector_watcher_h screen_connector_watcher_create_handle(char *id, int pid, screen_connector_watcher_ops *ops, void *data);
-void screen_connector_watcher_redirect_surface(screen_connector_watcher_h watcher_h);
+int screen_connector_watcher_redirect_surface(screen_connector_info_h info);
#ifdef __cplusplus
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <glib.h>
+#include <dlog.h>
+#include <wayland-client.h>
+#include <Ecore_Wayland.h>
+#include <Elementary.h>
+#include <wayland-extension/tizen-extension-client-protocol.h>
+#include <tizen-remote-surface-client-protocol.h>
+
+#include "screen_connector_trs.h"
+#include "screen_connector_toolkit.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "SC_WATCHER"
+
+struct _screen_connector_type_h {
+ GHashTable *toolkit_table;
+ aul_screen_viewer_h aul_handle;
+};
+
+struct _screen_connector_toolkit_h {
+ void (*update_cb)(struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time, void *data);
+ void (*missing_cb)(struct tizen_remote_surface *trs, void *data);
+ void (*change_cb)(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, void *data);
+ screen_connector_toolkit_ops *ops;
+ unsigned int event_filter;
+ char *appid;
+ char *instance_id;
+ int pid;
+ int surface_id;
+ struct tizen_remote_surface *surface;
+ struct _screen_connector_type_h *type_h;
+ void *data;
+};
+
+static GHashTable *__type_table;
+static void __buffer_updated(void *data, struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time)
+{
+}
+
+static void __buffer_missing(void *data, struct tizen_remote_surface *trs)
+{
+ screen_connector_toolkit_h toolkit_h = (screen_connector_toolkit_h)data;
+
+ if (toolkit_h)
+ toolkit_h->ops->removed_cb(toolkit_h->appid, toolkit_h->instance_id, toolkit_h->pid, toolkit_h->data);
+}
+
+static void __buffer_changed(void *data, struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys)
+{
+ screen_connector_toolkit_h toolkit_h = (screen_connector_toolkit_h)data;
+
+ if (toolkit_h && toolkit_h->ops)
+ toolkit_h->ops->updated_cb(trs, type, tbm, img_file_fd, img_file_size, time, keys, toolkit_h->appid,
+ toolkit_h->instance_id, toolkit_h->pid, toolkit_h->data);
+}
+
+static void __input_event_filter(void *data, struct tizen_remote_surface *trs, uint32_t event_filter)
+{
+ screen_connector_toolkit_h toolkit_h = (screen_connector_toolkit_h)data;
+
+ if (toolkit_h)
+ toolkit_h->event_filter = event_filter;
+
+ LOGD("event filter updated:%d", event_filter);
+}
+
+static const struct tizen_remote_surface_listener __rs_listener = {
+ __buffer_updated,
+ __buffer_missing,
+ __buffer_changed,
+ __input_event_filter,
+};
+
+EXPORT_API int screen_connector_toolkit_redirect_surface(screen_connector_toolkit_h toolkit_h)
+{
+
+ struct wl_tbm *tbm = screen_connector_get_tbm();
+ struct tizen_remote_surface_manager *rsm = screen_connector_get_rsm();
+ if (toolkit_h == NULL || rsm == NULL || tbm == NULL)
+ return -1;
+
+ toolkit_h->surface = tizen_remote_surface_manager_create_surface(rsm, (uint32_t)toolkit_h->surface_id, tbm);
+ if (toolkit_h->surface == NULL)
+ return -1;
+
+ LOGD("resource_id : %d, (%p), %s", toolkit_h->surface_id, toolkit_h->surface, toolkit_h->instance_id);
+ tizen_remote_surface_add_listener(toolkit_h->surface, &__rs_listener, toolkit_h);
+ tizen_remote_surface_redirect(toolkit_h->surface);
+
+ return 0;
+}
+
+static void __destroy_toolkit_h(gpointer data)
+{
+ screen_connector_toolkit_h toolkit_h = (screen_connector_toolkit_h)data;
+ if (!toolkit_h)
+ return;
+
+ LOGD("__destroy_toolkit_h appid: %s surface_id %d", toolkit_h->appid, toolkit_h->surface_id);
+
+ if (toolkit_h->appid) {
+ free(toolkit_h->appid);
+ toolkit_h->appid = NULL;
+ }
+
+ if (toolkit_h->instance_id) {
+ free(toolkit_h->instance_id);
+ toolkit_h->instance_id = NULL;
+ }
+
+ if (toolkit_h->surface) {
+ tizen_remote_surface_set_user_data(toolkit_h->surface, NULL);
+ tizen_remote_surface_unredirect(toolkit_h->surface);
+ tizen_remote_surface_destroy(toolkit_h->surface);
+ toolkit_h->surface = NULL;
+ }
+
+ if (toolkit_h->ops) {
+ free(toolkit_h->ops);
+ toolkit_h->ops = NULL;
+ }
+
+ free(toolkit_h);
+}
+
+static void __destroy_type_h(gpointer data)
+{
+ screen_connector_type_h type_h = (screen_connector_type_h)data;
+ if (!type_h)
+ return;
+
+ if (type_h->aul_handle)
+ aul_screen_connector_remove_screen_viewer(type_h->aul_handle);
+ if (type_h->toolkit_table)
+ g_hash_table_destroy(type_h->toolkit_table);
+ free(type_h);
+}
+
+static void __aul_screen_viewer_cb(const char *appid, const char *instance_id,
+ const int pid, const unsigned int surface_id,
+ aul_screen_connector_event_type_e event_type, void *data)
+{
+ screen_connector_toolkit_h toolkit_h;
+ screen_connector_type_h type_h = (screen_connector_type_h)data;
+
+ LOGD("__aul_screen_viewer_cb pid: %d, surface_id: %d, appid: %s instance_id: %s type %d",
+ pid, surface_id, appid, instance_id, event_type);
+
+ if (type_h == NULL || type_h->toolkit_table == NULL) {
+ LOGE("NULL type info");
+ return;
+ }
+
+ toolkit_h = (screen_connector_toolkit_h)g_hash_table_lookup(type_h->toolkit_table, instance_id);
+ if (toolkit_h == NULL) {
+ LOGD("It's not my instance_id, maybe alread removed %s ", instance_id);
+ return;
+ }
+
+ toolkit_h->appid = strdup(appid);
+ toolkit_h->pid = pid;
+ toolkit_h->surface_id = surface_id;
+ if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_ADD) {
+
+ toolkit_h->ops->added_cb(appid, instance_id, pid, toolkit_h->data);
+ screen_connector_toolkit_redirect_surface(toolkit_h);
+
+ } else if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_UPDATE) {
+
+ } else if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_REMOVE) {
+
+ if (toolkit_h->ops)
+ toolkit_h->ops->removed_cb(appid, instance_id, pid, toolkit_h->data);
+
+ g_hash_table_remove(type_h->toolkit_table, instance_id);
+ }
+}
+
+EXPORT_API int screen_connector_toolkit_init(screen_connector_screen_type_e type)
+{
+ int ret = 0;
+ int *key;
+ screen_connector_type_h type_h;
+
+ ret = screen_connector_trs_init();
+ if (__type_table == NULL)
+ __type_table = g_hash_table_new_full(g_int_hash, g_int_equal, free, __destroy_type_h);
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h == NULL) {
+ key = (int *)calloc(1, sizeof(int));
+ *key = type;
+
+ type_h = (screen_connector_type_h)calloc(1, sizeof(struct _screen_connector_type_h));
+ g_hash_table_insert(__type_table, key, type_h);
+ }
+
+ return ret;
+}
+
+EXPORT_API int screen_connector_toolkit_fini(screen_connector_screen_type_e type)
+{
+ int ret = 0;
+ screen_connector_type_h type_h;
+
+ if (__type_table == NULL) {
+ LOGI("__type_table is NULL");
+ return 0;
+ }
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h)
+ g_hash_table_remove(__type_table, &type);
+
+ if (g_hash_table_size(__type_table) == 0) {
+ ret = screen_connector_trs_fini();
+ g_hash_table_destroy(__type_table);
+ __type_table = NULL;
+ }
+
+ return ret;
+}
+
+EXPORT_API screen_connector_toolkit_h screen_connector_toolkit_create_handle(char *id, int surface_id,
+ screen_connector_toolkit_ops *ops, void *data)
+{
+ screen_connector_toolkit_h toolkit_h = NULL;
+
+ toolkit_h = (screen_connector_toolkit_h)calloc(1, sizeof(struct _screen_connector_toolkit_h));
+ if (toolkit_h == NULL) {
+ LOGE("toolkit_h calloc fail");
+ return NULL;
+ }
+ toolkit_h->surface_id = surface_id;
+ toolkit_h->appid = strdup(id);
+ toolkit_h->instance_id = strdup(id);
+ toolkit_h->data = data;
+ toolkit_h->ops = ops;
+
+ return toolkit_h;
+}
+
+EXPORT_API screen_connector_toolkit_h screen_connector_toolkit_add(screen_connector_toolkit_ops *ops, char *id,
+ screen_connector_screen_type_e type, void *data)
+{
+ screen_connector_toolkit_h toolkit_h = NULL;
+ screen_connector_type_h type_h = NULL;
+
+ if (id == NULL || ops == NULL) {
+ LOGE("Invalid param");
+ return NULL;
+ }
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h == NULL) {
+ LOGE("type %d is not initialized !!", type);
+ return NULL;
+ }
+
+ toolkit_h = (screen_connector_toolkit_h)calloc(1, sizeof(struct _screen_connector_toolkit_h));
+ if (toolkit_h == NULL) {
+ LOGE("toolkit_h calloc fail");
+ return NULL;
+ }
+ toolkit_h->instance_id = strdup(id);
+ toolkit_h->data = data;
+ toolkit_h->ops = ops;
+ toolkit_h->type_h = type_h;
+
+ if (type_h->toolkit_table == NULL)
+ type_h->toolkit_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, free, __destroy_toolkit_h);
+
+ g_hash_table_insert(type_h->toolkit_table, strdup(id), toolkit_h);
+
+ if (type_h->aul_handle == NULL)
+ aul_screen_connector_add_screen_viewer(__aul_screen_viewer_cb, type, true, type_h, &type_h->aul_handle);
+
+ return toolkit_h;
+}
+
+EXPORT_API int screen_connector_toolkit_remove(screen_connector_toolkit_h h)
+{
+ if (h == NULL) {
+ LOGE("screen_connector_toolkit_h is NULL");
+ return -1;
+ }
+
+ if (h->type_h == NULL) {
+ LOGE("screen_connector_toolkit_h type_h is NULL");
+ return -1;
+ }
+
+ if (h->type_h->toolkit_table == NULL) {
+ LOGE("screen_connector_toolkit_h type_h toolkit_table is NULL");
+ return -1;
+ }
+
+ g_hash_table_remove(h->type_h->toolkit_table, h->instance_id);
+
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_update(const char *appid, const char *instance_id)
+{
+ return aul_screen_connector_send_update_request(appid, instance_id);
+}
+
+EXPORT_API const char *screen_connector_toolkit_get_appid(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return NULL;
+
+ return h->appid;
+}
+
+EXPORT_API const char *screen_connector_toolkit_get_instance_id(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return NULL;
+
+ return h->instance_id;
+}
+
+EXPORT_API int screen_connector_toolkit_get_pid(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return -1;
+
+ return h->pid;
+}
+
+EXPORT_API int screen_connector_toolkit_get_surface_id(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return -1;
+
+ return h->surface_id;
+}
+
+EXPORT_API void *screen_connector_toolkit_get_user_data(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return NULL;
+
+ return h->data;
+}
+
+EXPORT_API unsigned int screen_connector_toolkit_get_event_filter(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return 0;
+
+ return h->event_filter;
+}
+
+EXPORT_API int screen_connector_toolkit_check_input_disabled(screen_connector_toolkit_h h,
+ screen_connector_input_type_e input)
+{
+ if (h == NULL) {
+ LOGE("inavlid argument");
+ return -1;
+ }
+
+ return ((h->event_filter & input) > 0);
+}
+
+EXPORT_API struct tizen_remote_surface *screen_connector_toolkit_get_trs(screen_connector_toolkit_h h)
+{
+ if (h == NULL)
+ return 0;
+
+ return h->surface;
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <glib.h>
+#include <dlog.h>
+#include <wayland-client.h>
+#include <Ecore_Wayland.h>
+#include <Elementary.h>
+#include <wayland-extension/tizen-extension-client-protocol.h>
+#include <tizen-remote-surface-client-protocol.h>
+
+#include "screen_connector_watcher.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "SC_WATCHER"
+
+static struct tizen_remote_surface_manager *__rsm = NULL;
+static struct wayland_tbm_client *__tbm_client;
+static struct wl_tbm *__tbm = NULL;
+static bool __is_init;
+
+struct wl_tbm *screen_connector_get_tbm()
+{
+ return __tbm;
+}
+
+struct tizen_remote_surface_manager *screen_connector_get_rsm()
+{
+ return __rsm;
+}
+
+int screen_connector_trs_init(void)
+{
+ int ret = 0;
+ struct wl_registry *registry;
+ Ecore_Wl_Global *global;
+ Eina_Inlist *globals;
+
+ if (__is_init)
+ return 0;
+
+ ecore_wl_init(NULL);
+
+ registry = ecore_wl_registry_get();
+ globals = ecore_wl_globals_get();
+
+ if (!registry || !globals) {
+ LOGE("could not get registry(%p) or global list(%p)", registry,
+ globals);
+ return -1;
+ }
+
+ EINA_INLIST_FOREACH(globals, global) {
+ if (!strcmp(global->interface, "tizen_remote_surface_manager")) {
+ __rsm = wl_registry_bind(registry, global->id,
+ &tizen_remote_surface_manager_interface,
+ global->version < 4 ? global->version : 4);
+ }
+ }
+
+ if (!__rsm) {
+ LOGE("could not get remote surface manager");
+ return -1;
+ }
+
+ __tbm_client = (struct wayland_tbm_client *)wayland_tbm_client_init(ecore_wl_display_get());
+ if (!__tbm_client) {
+ LOGE("could not get tbm client");
+ return -1;
+ }
+
+ __tbm = (struct wl_tbm *)wayland_tbm_client_get_wl_tbm(__tbm_client);
+ if (!__tbm) {
+ LOGE("could not get tbm");
+ return -1;
+ }
+
+ __is_init = true;
+
+ return ret;
+}
+
+int screen_connector_trs_fini(void)
+{
+ if (!__is_init)
+ return 0;
+
+ if (__tbm_client)
+ wayland_tbm_client_deinit(__tbm_client);
+
+ if (__rsm)
+ tizen_remote_surface_manager_destroy(__rsm);
+
+ ecore_wl_shutdown();
+
+ __is_init = false;
+ return 0;
+}
+
#include <tizen-remote-surface-client-protocol.h>
#include <aul_screen_connector.h>
+#include "screen_connector_trs.h"
#include "screen_connector_watcher.h"
#ifdef LOG_TAG
#define LOG_TAG "SC_WATCHER"
struct _screen_connector_watcher_h {
- char *appid;
- int pid;
void (*update_cb)(struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time, void *data);
void (*missing_cb)(struct tizen_remote_surface *trs, void *data);
void (*change_cb)(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, void *data);
+ screen_connector_watcher_ops *ops;
void *data;
- struct tizen_remote_surface *surface;
- unsigned int event_filter;
- int resource_id;
+ GHashTable *info_table;
+ aul_screen_viewer_h aul_handle;
};
-typedef struct _screen_connector_watcher_h *screen_connector_watcher_h;
-
-static struct tizen_remote_surface_manager *__rsm;
-static struct wayland_tbm_client *__tbm_client;
-static struct wl_tbm *__tbm;
-static bool __is_init;
-static GList *__watcher_list;
-static GList *__pending_watcher_list;
-static aul_screen_viewer_handler __aul_cbs;
+struct _screen_connector_info_h {
+ char *appid;
+ char *instance_id;
+ int pid;
+ int surface_id;
+ screen_connector_watcher_ops *ops;
+ struct tizen_remote_surface *surface;
+ bool renderable;
+ void *data;
+};
static void __buffer_updated(void *data, struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time)
{
- screen_connector_watcher_h watcher_h = (screen_connector_watcher_h)data;
-
- if (watcher_h)
- watcher_h->update_cb(trs, buffer, time, watcher_h->data);
}
static void __buffer_missing(void *data, struct tizen_remote_surface *trs)
{
- screen_connector_watcher_h watcher_h = (screen_connector_watcher_h)data;
+ screen_connector_info_h info = (screen_connector_info_h)data;
- if (watcher_h)
- watcher_h->missing_cb(trs, watcher_h->data);
+ if (info)
+ info->ops->removed_cb(info->appid, info->instance_id, info->pid, info->data);
}
static void __buffer_changed(void *data, struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys)
{
- screen_connector_watcher_h watcher_h = (screen_connector_watcher_h)data;
-
- if (watcher_h)
- watcher_h->change_cb(trs, type, tbm, img_file_fd, img_file_size, time, keys, watcher_h->data);
-}
+ screen_connector_info_h info = (screen_connector_info_h)data;
-static void __input_event_filter(void *data, struct tizen_remote_surface *trs, uint32_t event_filter)
-{
- screen_connector_watcher_h watcher_h = (screen_connector_watcher_h)data;
+ if (info && info->ops) {
- if (watcher_h)
- watcher_h->event_filter = event_filter;
+ if (info->renderable) {
+ info->renderable = false;
+ tizen_remote_surface_set_remote_render(info->surface, 0);
+ }
- LOGD("event filter updated:%d", event_filter);
+ info->ops->updated_cb(trs, type, tbm, img_file_fd, img_file_size, time, keys, info->appid,
+ info->instance_id, info->pid, info->data);
+ }
}
static const struct tizen_remote_surface_listener __rs_listener = {
__buffer_updated,
__buffer_missing,
__buffer_changed,
- __input_event_filter,
};
-static void __app_removed(const char *appid, const int pid, void *data)
+EXPORT_API int screen_connector_watcher_redirect_surface(screen_connector_info_h info)
{
-}
-EXPORT_API void screen_connector_watcher_redirect_surface(screen_connector_watcher_h watcher_h)
-{
- if (watcher_h == NULL)
- return;
+ struct wl_tbm *tbm = screen_connector_get_tbm();
+ struct tizen_remote_surface_manager *rsm = screen_connector_get_rsm();
+ if (info == NULL || rsm == NULL || tbm == NULL)
+ return -1;
- watcher_h->surface = tizen_remote_surface_manager_create_surface(__rsm, (uint32_t)watcher_h->resource_id, __tbm);
- if (watcher_h->surface == NULL)
- return;
+ info->surface = tizen_remote_surface_manager_create_surface(rsm, (uint32_t)info->surface_id, tbm);
+ if (info->surface == NULL)
+ return -1;
- LOGD("resource_id : %d, (%p)", watcher_h->resource_id, watcher_h->surface);
- tizen_remote_surface_add_listener(watcher_h->surface, &__rs_listener, watcher_h);
- tizen_remote_surface_redirect(watcher_h->surface);
+ LOGD("resource_id : %d, (%p)", info->surface_id, info->surface);
+ tizen_remote_surface_add_listener(info->surface, &__rs_listener, info);
+ tizen_remote_surface_redirect(info->surface);
+
+ return 0;
}
-static screen_connector_watcher_h __create_watcher_handle_info(char *appid)
+static void __destroy_screen_info(gpointer data)
{
- screen_connector_watcher_h watcher_h;
+ screen_connector_info_h info = (screen_connector_info_h)data;
- watcher_h = (screen_connector_watcher_h)calloc(1, sizeof(struct _screen_connector_watcher_h));
- if (watcher_h == NULL) {
- LOGE("watcher_h calloc fail");
- return NULL;
- }
+ if (info == NULL)
+ return;
- watcher_h->appid = strdup(appid);
- if (watcher_h->appid == NULL) {
- LOGE("out of memory");
- free(watcher_h);
- return NULL;
- }
+ LOGD("__destroy_screen_info appid: %s surface_id %d", info->appid, info->surface_id);
- return watcher_h;
-}
+ if (info->appid) {
+ free(info->appid);
+ info->appid = NULL;
+ }
-static void __app_added(const char *appid, const int pid, const unsigned int resource_id, void *data)
-{
- screen_connector_watcher_h watcher_h = NULL;
- screen_connector_watcher_h cur_h;
- GList *watcher_list = __watcher_list;
-
- LOGD("__app_added pid: %d, resource_id: %d, appid: %s", pid, resource_id, appid);
- for (; watcher_list != NULL; watcher_list = watcher_list->next) {
- cur_h = (screen_connector_watcher_h)watcher_list->data;
- if (strcmp(cur_h->appid, appid) == 0) {
- watcher_h = cur_h;
- __watcher_list = g_list_remove(__watcher_list, cur_h);
- break;
- }
+ if (info->instance_id) {
+ free(info->instance_id);
+ info->instance_id = NULL;
}
- if (watcher_h == NULL) {
- watcher_h = __create_watcher_handle_info((char *)appid);
- watcher_h->pid = pid;
- watcher_h->resource_id = resource_id;
- __pending_watcher_list = g_list_append(__pending_watcher_list, watcher_h);
+ if (info->surface) {
+ if (info->renderable)
+ tizen_remote_surface_set_remote_render(info->surface, 0);
- LOGD("add pending list: %d, resource_id: %d, appid: %s", pid, resource_id, appid);
- return;
+ tizen_remote_surface_set_user_data(info->surface, NULL);
+ tizen_remote_surface_unredirect(info->surface);
+ tizen_remote_surface_destroy(info->surface);
+ info->surface = NULL;
}
- watcher_h->resource_id = resource_id;
- watcher_h->pid = pid;
- if (resource_id > 0)
- screen_connector_watcher_redirect_surface(watcher_h);
- else
- LOGE("bad tbm message received. missing arguments");
+ free(info);
}
-EXPORT_API int screen_connector_watcher_init(void)
+static void __aul_screen_viewer_cb(const char *appid, const char *instance_id,
+ const int pid, const unsigned int surface_id,
+ aul_screen_connector_event_type_e event_type, void *data)
{
- int ret = 0;
- struct wl_registry *registry;
- Ecore_Wl_Global *global;
- Eina_Inlist *globals;
+ screen_connector_watcher_h watcher_h = (screen_connector_watcher_h)data;
+ screen_connector_info_h info = (screen_connector_info_h)calloc(1, sizeof(struct _screen_connector_info_h));
+ screen_connector_info_h cur_info;
- if (__is_init)
- return 0;
+ LOGD("__aul_screen_viewer_cb pid: %d, surface_id: %d, appid: %s type %d", pid, surface_id, appid, event_type);
+ info->appid = strdup(appid);
+ info->instance_id = strdup(instance_id);
+ info->pid = pid;
+ info->surface_id = surface_id;
+ info->ops = watcher_h->ops;
+ info->data = watcher_h->data;
+ info->renderable = false;
- ecore_wl_init(NULL);
+ if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_ADD) {
- registry = ecore_wl_registry_get();
- globals = ecore_wl_globals_get();
+ g_hash_table_insert(watcher_h->info_table,
+ strdup(instance_id), info);
- if (!registry || !globals) {
- LOGE("could not get registry(%p) or global list(%p)", registry,
- globals);
- return -1;
- }
+ info->ops->added_cb(appid, instance_id, pid, info->data);
+ screen_connector_watcher_redirect_surface(info);
+
+ } else if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_UPDATE) {
- EINA_INLIST_FOREACH(globals, global) {
- if (!strcmp(global->interface, "tizen_remote_surface_manager")) {
- __rsm = wl_registry_bind(registry, global->id,
- &tizen_remote_surface_manager_interface,
- global->version < 4 ? global->version : 4);
+ cur_info = g_hash_table_lookup(watcher_h->info_table, instance_id);
+ if (cur_info && cur_info->surface_id != surface_id) {
+ cur_info->ops->removed_cb(appid, instance_id, pid, cur_info->data);
+ g_hash_table_remove(watcher_h->info_table, instance_id);
}
- }
- if (!__rsm) {
- LOGE("could not get remote surface manager");
- return -1;
- }
+ g_hash_table_insert(watcher_h->info_table, strdup(instance_id), info);
- __tbm_client = (struct wayland_tbm_client *)wayland_tbm_client_init(ecore_wl_display_get());
- if (!__tbm_client) {
- LOGE("could not get tbm client");
- return -1;
- }
+ info->ops->added_cb(appid, instance_id, pid, info->data);
+ screen_connector_watcher_redirect_surface(info);
+ } else if (event_type == AUL_SCREEN_CONNECTOR_EVENT_TYPE_REMOVE) {
- __tbm = (struct wl_tbm *)wayland_tbm_client_get_wl_tbm(__tbm_client);
- if (!__tbm) {
- LOGE("could not get tbm");
- return -1;
+ info->ops->removed_cb(appid, instance_id, pid, info->data);
+ g_hash_table_remove(watcher_h->info_table, instance_id);
+ __destroy_screen_info(info);
}
+}
- __aul_cbs.app_added = __app_added;
- __aul_cbs.app_removed = __app_removed;
- aul_screen_connector_add_screen_viewer(&__aul_cbs, NULL);
-
- __is_init = true;
-
+EXPORT_API int screen_connector_watcher_init(void)
+{
+ int ret = 0;
+ ret = screen_connector_trs_init();
return ret;
}
EXPORT_API int screen_connector_watcher_fini(void)
{
- if (!__is_init)
- return 0;
-
- if (aul_screen_connector_remove_app_screen() != 0)
- return -1;
-
- if (__tbm_client)
- wayland_tbm_client_deinit(__tbm_client);
-
- if (__rsm)
- tizen_remote_surface_manager_destroy(__rsm);
-
- ecore_wl_shutdown();
-
- __is_init = false;
- return 0;
+ int ret = 0;
+ ret = screen_connector_trs_fini();
+ return ret;
}
static void __destroy_watcher_h(screen_connector_watcher_h handle)
if (!handle)
return;
- if (handle->surface) {
- tizen_remote_surface_set_user_data(handle->surface, NULL);
- tizen_remote_surface_unredirect(handle->surface);
- tizen_remote_surface_destroy(handle->surface);
- handle->surface = NULL;
- }
+ if (handle->aul_handle)
+ aul_screen_connector_remove_screen_viewer(handle->aul_handle);
- if (__pending_watcher_list)
- __pending_watcher_list = g_list_remove(__pending_watcher_list, handle);
-
- if (__watcher_list)
- __watcher_list = g_list_remove(__watcher_list, handle);
-
- if (handle->appid) {
- free(handle->appid);
- handle->appid = NULL;
- }
+ if (handle->info_table)
+ g_hash_table_destroy(handle->info_table);
free(handle);
}
-EXPORT_API screen_connector_watcher_h screen_connector_watcher_create_handle(char *id, int pid, screen_connector_watcher_ops *ops, void *data)
+EXPORT_API screen_connector_watcher_h screen_connector_watcher_add(screen_connector_watcher_ops *ops, void *data)
{
screen_connector_watcher_h watcher_h = NULL;
+ aul_screen_viewer_h handle = NULL;
- watcher_h = __create_watcher_handle_info(id);
- if (watcher_h == NULL)
+ watcher_h = (screen_connector_watcher_h)calloc(1, sizeof(struct _screen_connector_watcher_h));
+ if (watcher_h == NULL) {
+ LOGE("watcher_h calloc fail");
return NULL;
-
- watcher_h->update_cb = ops->update_cb;
- watcher_h->change_cb = ops->change_cb;
- watcher_h->missing_cb = ops->missing_cb;
- watcher_h->pid = pid;
- watcher_h->data = data;
-
- return watcher_h;
-}
-
-EXPORT_API screen_connector_watcher_h screen_connector_watcher_add(screen_connector_watcher_ops *ops, char *id, void *data)
-{
- screen_connector_watcher_h watcher_h = NULL;
- screen_connector_watcher_h cur_h;
- GList *watcher_list = __pending_watcher_list;
-
- for (; watcher_list != NULL; watcher_list = watcher_list->next) {
- cur_h = (screen_connector_watcher_h)watcher_list->data;
- if (strcmp(cur_h->appid, id) == 0) {
- watcher_h = cur_h;
- __pending_watcher_list = g_list_remove(__pending_watcher_list, cur_h);
- break;
- }
- }
-
- if (watcher_h != NULL) {
- watcher_h->update_cb = ops->update_cb;
- watcher_h->change_cb = ops->change_cb;
- watcher_h->missing_cb = ops->missing_cb;
- watcher_h->data = data;
- screen_connector_watcher_redirect_surface(watcher_h);
- } else {
- watcher_h = __create_watcher_handle_info(id);
- watcher_h->update_cb = ops->update_cb;
- watcher_h->change_cb = ops->change_cb;
- watcher_h->missing_cb = ops->missing_cb;
- watcher_h->data = data;
- __watcher_list = g_list_append(__watcher_list, watcher_h);
}
+ watcher_h->data = data;
+ watcher_h->ops = ops;
+ watcher_h->info_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, free, __destroy_screen_info);
+ aul_screen_connector_add_screen_viewer(__aul_screen_viewer_cb, AUL_SCREEN_TYPE_UI, false, watcher_h, &handle);
+ watcher_h->aul_handle = handle;
return watcher_h;
}
return 0;
}
-EXPORT_API int screen_connector_watcher_update(const char *appid)
+EXPORT_API int screen_connector_watcher_update(screen_connector_watcher_h h, const char *instance_id)
{
- return aul_screen_connector_update_app_screen(appid);
-}
+ screen_connector_info_h info;
-EXPORT_API char *screen_connector_watcher_get_appid(screen_connector_watcher_h h)
-{
- if (h == NULL)
- return NULL;
+ if (h == NULL) {
+ LOGE("toolkit_h is NULL");
+ return -1;
+ }
- return h->appid;
-}
+ if (h->info_table == NULL) {
+ LOGE("info_table is NULL");
+ return -1;
+ }
-EXPORT_API int screen_connector_watcher_get_pid(screen_connector_watcher_h h)
-{
- if (h == NULL)
+ info = (screen_connector_info_h)g_hash_table_lookup(h->info_table, instance_id);
+ if (info == NULL) {
+ LOGE("invalid instance_id %s", instance_id);
return -1;
+ }
- return h->pid;
+ LOGI("send update request to %s", instance_id);
+ tizen_remote_surface_set_remote_render(info->surface, 1);
+ /* flag will be cleared when buffer changed event received */
+ info->renderable = true;
+
+ return aul_screen_connector_send_update_request(info->appid, info->instance_id);
}
-EXPORT_API int screen_connector_watcher_get_resource_id(screen_connector_watcher_h h)
+EXPORT_API char *screen_connector_watcher_get_appid(screen_connector_info_h h)
{
- if (h == NULL)
- return -1;
-
- return h->resource_id;
+ return h->appid;
}
-EXPORT_API int screen_connector_watcher_set_resource_id(screen_connector_watcher_h h, int rid)
+EXPORT_API char *screen_connector_watcher_get_instance_id(screen_connector_info_h h)
{
- if (h == NULL)
- return -1;
-
- h->resource_id = rid;
- return 0;
+ return h->instance_id;
}
-EXPORT_API struct tizen_remote_surface *screen_connector_watcher_get_trs(screen_connector_watcher_h h)
+EXPORT_API int screen_connector_watcher_get_pid(screen_connector_info_h h)
{
- if (h == NULL)
- return NULL;
-
- return h->surface;
+ return h->pid;
}
-EXPORT_API unsigned int screen_connector_watcher_get_event_filter(screen_connector_watcher_h h)
+EXPORT_API int screen_connector_watcher_get_surface_id(screen_connector_info_h h)
{
- if (h == NULL)
- return 0;
-
- return h->event_filter;
+ return h->surface_id;
}
-EXPORT_API int screen_connector_watcher_check_input_disabled(screen_connector_watcher_h h,
- screen_connector_input_type_e input)
+EXPORT_API void *screen_connector_watcher_get_user_data(screen_connector_info_h h)
{
- if (h == NULL) {
- LOGE("inavlid argument");
- return -1;
- }
-
- return ((h->event_filter & input) > 0);
+ return h->data;
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __SCREEN_CONNECTOR_TOOLKIT_EVAS_H__
+#define __SCREEN_CONNECTOR_TOOLKIT_EVAS_H__
+
+#include <Evas.h>
+#include <tizen.h>
+#include <tizen_type.h>
+#include <wayland-client.h>
+#include <wayland-tbm-client.h>
+#include <screen_connector_toolkit.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file screen_connector_toolkit_evas.h
+ * @brief This file declares API of libscreen_connector library
+ * @since_tizen 3.0
+ */
+
+/**
+ * @addtogroup CAPI_SCREEN_CONNECTOR_WATCHER_EVAS_MODULE
+ * @{
+ */
+
+typedef enum {
+ VISIBILITY_TYPE_UNOBSCURED,
+ VISIBILITY_TYPE_PARTIALLY_OBSCURED,
+ VISIBILITY_TYPE_FULLY_OBSCURED,
+} visibility_type;
+
+typedef void (*screen_connector_toolkit_evas_added_cb)(const char *appid, const char *instance_id, const int pid,
+ Evas_Object *image, void *data);
+typedef void (*screen_connector_toolkit_evas_removed_cb)(const char *appid, const char *instance_id, const int pid,
+ Evas_Object *image, void *data);
+typedef void (*screen_connector_toolkit_evas_updated_cb)(const char *appid, const char *instance_id, const int pid,
+ Evas_Object *image, void *data);
+
+typedef struct _screen_connector_toolkit_evas_ops {
+ screen_connector_toolkit_evas_added_cb added_cb;
+ screen_connector_toolkit_evas_removed_cb removed_cb;
+ screen_connector_toolkit_evas_updated_cb updated_cb;
+} screen_connector_toolkit_evas_ops;
+
+typedef struct _screen_connector_toolkit_evas_h *screen_connector_toolkit_evas_h;
+typedef struct _screen_connector_type_evas_h *screen_connector_type_evas_h;
+
+int screen_connector_toolkit_evas_init(Evas_Object *win, screen_connector_screen_type_e type);
+int screen_connector_toolkit_evas_fini(screen_connector_screen_type_e type);
+screen_connector_toolkit_evas_h screen_connector_toolkit_evas_add(screen_connector_toolkit_evas_ops *ops, char *id,
+ screen_connector_screen_type_e type, void *data);
+int screen_connector_toolkit_evas_remove(screen_connector_toolkit_evas_h handle);
+int screen_connector_toolkit_evas_update(const char *appid, const char *instance_id);
+int screen_connector_toolkit_evas_start_visibility_notify(void);
+int screen_connector_toolkit_evas_stop_visibility_notify(void);
+int screen_connector_toolkit_evas_freeze_visibility(Evas_Object *obj, visibility_type type);
+int screen_connector_toolkit_evas_thaw_visibility(Evas_Object *obj);
+int screen_connector_toolkit_evas_send_mouse_up(Evas_Object *obj);
+int screen_connector_toolkit_evas_send_touch_cancel(Evas_Object *obj);
+
+/**
+ * @brief Add screen connector toolkit by rid.
+ * @details Using this API, viewer can watch screen which already watched by other viewer.\n
+ * @since_tizen 3.0
+ * @param[in] obj screen image object
+ * @param[out] pid screen provider pid
+ * @return 0 if success, negative value(<0) if fail
+ *
+ * @remark
+ * This API is only for main viewer. \n
+ * Sub viewer can not get provider's information like provider's pid by screen image object.
+ * @see screen_connector_toolkit_evas_add_by_rid()
+*/
+int screen_connector_toolkit_evas_get_pid(Evas_Object *obj, int *pid);
+
+/**
+ * @brief Add screen connector toolkit by rid.
+ * @details Using this API, viewer can watch screen which already watched by other viewer.\n
+ * @since_tizen 3.0
+ * @param[in] ops screen toolkit evas callback handler function
+ * @param[in] res_id screen provider rid
+ * @param[in] data user-supplied data for toolkit handler
+ * @return @c Not null on success
+ *
+ * @remark
+ * This API is only for sub viewer. \n
+ * Sub viewer can not get provider's information like provider's pid by screen image object.
+*/
+screen_connector_toolkit_evas_h screen_connector_toolkit_evas_add_by_rid(screen_connector_toolkit_evas_ops *ops, int res_id,
+ screen_connector_screen_type_e type, void *data);
+int screen_connector_toolkit_evas_get_rid(Evas_Object *obj, int *resource_id);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __SCREEN_CONNECTOR_WATCHER_EVAS_H__ */
#include <Evas.h>
#include <tizen.h>
#include <tizen_type.h>
+#include <wayland-extension/tizen-extension-client-protocol.h>
+#include <tizen-remote-surface-client-protocol.h>
#ifdef __cplusplus
extern "C" {
#endif
-
/**
* @file screen_connector_watcher_evas.h
* @brief This file declares API of libscreen_connector library
* @{
*/
-typedef enum {
- VISIBILITY_TYPE_UNOBSCURED,
- VISIBILITY_TYPE_PARTIALLY_OBSCURED,
- VISIBILITY_TYPE_FULLY_OBSCURED,
-} visibility_type;
-
-typedef void (*screen_connector_watcher_evas_added_cb)(const char *appid, Evas_Object *image, void *data);
-typedef void (*screen_connector_watcher_evas_removed_cb)(const char *appid, Evas_Object *image, void *data);
-typedef void (*screen_connector_watcher_evas_updated_cb)(const char *appid, Evas_Object *image, void *data);
+typedef void (*screen_connector_watcher_evas_added_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_watcher_evas_removed_cb)(const char *appid, const char *instance_id, const int pid, void *data);
+typedef void (*screen_connector_watcher_evas_updated_cb)(const char *appid, const char *instance_id, const int pid,
+ Evas_Object *image, void *data);
typedef struct _screen_connector_watcher_evas_ops {
- screen_connector_watcher_evas_added_cb added;
- screen_connector_watcher_evas_removed_cb removed;
- screen_connector_watcher_evas_updated_cb updated;
+ screen_connector_watcher_evas_added_cb added_cb;
+ screen_connector_watcher_evas_removed_cb removed_cb;
+ screen_connector_watcher_evas_updated_cb updated_cb;
} screen_connector_watcher_evas_ops;
typedef struct _screen_connector_watcher_evas_h *screen_connector_watcher_evas_h;
int screen_connector_watcher_evas_init(Evas_Object *win);
int screen_connector_watcher_evas_fini(void);
-screen_connector_watcher_evas_h screen_connector_watcher_evas_add(screen_connector_watcher_evas_ops *ops, char *id, void *data);
-int screen_connector_watcher_evas_remove(screen_connector_watcher_evas_h handle);
-int screen_connector_watcher_evas_update(const char *appid);
-int screen_connector_watcher_evas_start_visibility_notify(void);
-int screen_connector_watcher_evas_stop_visibility_notify(void);
-int screen_connector_watcher_evas_freeze_visibility(Evas_Object *obj, visibility_type type);
-int screen_connector_watcher_evas_thaw_visibility(Evas_Object *obj);
-int screen_connector_watcher_evas_send_mouse_up(Evas_Object *obj);
-int screen_connector_watcher_evas_send_touch_cancel(Evas_Object *obj);
-
-/**
- * @brief Add screen connector watcher by rid.
- * @details Using this API, viewer can watch screen which already watched by other viewer.\n
- * @since_tizen 3.0
- * @param[in] obj screen image object
- * @param[out] pid screen provider pid
- * @return 0 if success, negative value(<0) if fail
- *
- * @remark
- * This API is only for main viewer. \n
- * Sub viewer can not get provider's information like provider's pid by screen image object.
- * @see screen_connector_watcher_evas_add_by_rid()
-*/
-int screen_connector_watcher_evas_get_pid(Evas_Object *obj, int *pid);
-
-/**
- * @brief Add screen connector watcher by rid.
- * @details Using this API, viewer can watch screen which already watched by other viewer.\n
- * @since_tizen 3.0
- * @param[in] ops screen watcher evas callback handler function
- * @param[in] res_id screen provider rid
- * @param[in] data user-supplied data for watcher handler
- * @return @c Not null on success
- *
- * @remark
- * This API is only for sub viewer. \n
- * Sub viewer can not get provider's information like provider's pid by screen image object.
-*/
-screen_connector_watcher_evas_h screen_connector_watcher_evas_add_by_rid(screen_connector_watcher_evas_ops *ops, int res_id, void *data);
-int screen_connector_watcher_evas_get_rid(Evas_Object *obj, int *resource_id);
+screen_connector_watcher_evas_h screen_connector_watcher_evas_add(screen_connector_watcher_evas_ops *ops, void *data);
+int screen_connector_watcher_evas_remove(screen_connector_watcher_evas_h h);
+int screen_connector_watcher_evas_update(screen_connector_watcher_evas_h watcher_evas_h, const char *instance_id);
/**
* @}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <glib.h>
+#include <sys/mman.h>
+#include <dlog.h>
+#include <Elementary.h>
+#include <Ecore_Wayland.h>
+#include <wayland-extension/tizen-extension-client-protocol.h>
+#include <tizen-remote-surface-client-protocol.h>
+
+#include "screen_connector_toolkit.h"
+#include "screen_connector_toolkit_evas.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "SC_WATCHER_EVAS"
+
+struct _screen_connector_type_evas_h {
+ GHashTable *toolkit_table;
+ Evas_Object *viewer_win;
+};
+
+struct _screen_connector_toolkit_evas_h {
+ screen_connector_toolkit_evas_ops *ops;
+ screen_connector_toolkit_h toolkit_h;
+ int freeze;
+ bool is_init;
+ bool cancel_touch;
+ Evas_Object *img_tbm;
+ Evas_Object *img_file;
+ uint32_t img_type;
+ struct wl_buffer *pre_buffer;
+ struct _screen_connector_type_evas_h *type_h;
+ void *data;
+};
+
+static GHashTable *__type_table = NULL;
+static Ecore_Event_Handler *__visibility_listener;
+
+static void __destroy_type_h(gpointer data)
+{
+ screen_connector_type_evas_h type_h = (screen_connector_type_evas_h)data;
+ if (!type_h)
+ return;
+
+ if (type_h->toolkit_table)
+ g_hash_table_destroy(type_h->toolkit_table);
+ free(type_h);
+}
+
+EXPORT_API int screen_connector_toolkit_evas_init(Evas_Object *win, screen_connector_screen_type_e type)
+{
+ screen_connector_type_evas_h type_h;
+ int *key;
+
+ if (__type_table == NULL)
+ __type_table = g_hash_table_new_full(g_int_hash, g_int_equal, free, __destroy_type_h);
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h == NULL) {
+ key = (int *)calloc(1, sizeof(int));
+ *key = type;
+
+ type_h = (screen_connector_type_evas_h)calloc(1, sizeof(struct _screen_connector_type_evas_h));
+ g_hash_table_insert(__type_table, key, type_h);
+
+ type_h->toolkit_table = g_hash_table_new(g_direct_hash, g_direct_equal);
+ if (!type_h->toolkit_table) {
+ LOGE("failed to create table");
+ return -1;
+ }
+ }
+
+ type_h->viewer_win = win;
+ return screen_connector_toolkit_init(type);
+}
+
+EXPORT_API int screen_connector_toolkit_evas_fini(screen_connector_screen_type_e type)
+{
+ screen_connector_type_evas_h type_h;
+
+ if (__type_table == NULL) {
+ LOGI("__type_table is NULL");
+ return 0;
+ }
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h) {
+ if (type_h->toolkit_table)
+ g_hash_table_destroy(type_h->toolkit_table);
+ g_hash_table_remove(__type_table, &type);
+ }
+
+ if (g_hash_table_size(__type_table) == 0) {
+ g_hash_table_destroy(__type_table);
+ __type_table = NULL;
+ }
+
+ return screen_connector_toolkit_fini(type);
+}
+
+static bool __obj_is_visible(Evas_Object *obj, screen_connector_toolkit_evas_h toolkit_evas_h)
+{
+ int x, y, w, h;
+ Ecore_Wl_Window *window = NULL;
+ int window_x, window_y, window_w, window_h;
+ int rotation;
+
+ if (toolkit_evas_h->type_h == NULL || toolkit_evas_h->type_h->viewer_win == NULL) {
+ LOGE("type_h is NULL");
+ return false;
+ }
+
+ window = elm_win_wl_window_get(toolkit_evas_h->type_h->viewer_win);
+ ecore_wl_window_geometry_get(window, &window_x, &window_y, &window_w, &window_h);
+ evas_object_geometry_get(obj, &x, &y, &w, &h);
+ rotation = ecore_wl_window_rotation_get(window);
+
+ if (x >= 0 && x < window_w &&
+ y >= 0 && y < window_h &&
+ (rotation == 0 || rotation == 180)) {
+ LOGD("x %d, y %d w %d h %d, window_w %d window_h %d rotation %d",
+ x, y, w, h, window_w, window_h, rotation);
+ return true;
+ } else if (x >= 0 && x < window_h &&
+ y >= 0 && y < window_w &&
+ (rotation == 90 || rotation == 270)) {
+ LOGD("x %d, y %d w %d h %d, window_w %d window_h %d rotation %d",
+ x, y, w, h, window_w, window_h, rotation);
+ return true;
+ }
+
+ return false;
+}
+
+static int __set_visibility(screen_connector_toolkit_evas_h toolkit_evas_h, visibility_type type)
+{
+ int obscured;
+ struct tizen_remote_surface *surface;
+
+ if (!toolkit_evas_h) {
+ LOGE("obj not found");
+ return -1;
+ }
+
+ switch (type) {
+ case VISIBILITY_TYPE_UNOBSCURED:
+ case VISIBILITY_TYPE_PARTIALLY_OBSCURED:
+ obscured = TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE;
+ break;
+ case VISIBILITY_TYPE_FULLY_OBSCURED:
+ obscured = TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_INVISIBLE;
+ break;
+ default:
+ return -1;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface)
+ tizen_remote_surface_transfer_visibility(surface, obscured);
+
+ return 0;
+}
+
+static void __obj_update_visibility(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+
+ if (!toolkit_evas_h->is_init) {
+ toolkit_evas_h->is_init = true;
+ return;
+ }
+
+ if (__obj_is_visible(obj, toolkit_evas_h))
+ __set_visibility(toolkit_evas_h, VISIBILITY_TYPE_UNOBSCURED);
+ else
+ __set_visibility(toolkit_evas_h, VISIBILITY_TYPE_FULLY_OBSCURED);
+}
+
+static void __rs_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ Evas_Event_Mouse_Down *ev = event_info;
+ const char *desc = evas_device_description_get(ev->dev);
+ int x;
+ int y;
+ int w;
+ int h;
+ struct tizen_remote_surface *surface;
+
+ evas_object_geometry_get(obj, &x, &y, &w, &h);
+
+ LOGD("mouse down: %d %d", ev->canvas.x - x, ev->canvas.y - y);
+
+ if (desc == NULL)
+ desc = "";
+
+ if (screen_connector_toolkit_check_input_disabled(toolkit_evas_h->toolkit_h,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN)) {
+ LOGD("mouse down disabled");
+ return;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return;
+ }
+
+ tizen_remote_surface_transfer_mouse_event(surface,
+ TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_DOWN,
+ 0,
+ ev->button,
+ ev->canvas.x - x,
+ ev->canvas.y - y,
+ wl_fixed_from_double(ev->radius_x),
+ wl_fixed_from_double(ev->radius_y),
+ wl_fixed_from_double(ev->pressure),
+ wl_fixed_from_double(ev->angle),
+ evas_device_class_get(ev->dev),
+ evas_device_subclass_get(ev->dev),
+ desc,
+ ev->timestamp);
+}
+
+static void __rs_cb_mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ Evas_Event_Mouse_Up *ev = event_info;
+ const char *desc = evas_device_description_get(ev->dev);
+ int x;
+ int y;
+ int w;
+ int h;
+ struct tizen_remote_surface *surface;
+
+ evas_object_geometry_get(obj, &x, &y, &w, &h);
+
+ LOGD("mouse up: %d %d", ev->canvas.x - x, ev->canvas.y - y);
+
+ if (desc == NULL)
+ desc = "";
+
+ if (screen_connector_toolkit_check_input_disabled(toolkit_evas_h->toolkit_h,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN)) {
+ LOGD("mouse up disabled");
+ return;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return;
+ }
+
+ tizen_remote_surface_transfer_mouse_event(surface,
+ TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP,
+ 0,
+ ev->button,
+ ev->canvas.x - x,
+ ev->canvas.y - y,
+ wl_fixed_from_double(ev->radius_x),
+ wl_fixed_from_double(ev->radius_y),
+ wl_fixed_from_double(ev->pressure),
+ wl_fixed_from_double(ev->angle),
+ evas_device_class_get(ev->dev),
+ evas_device_subclass_get(ev->dev),
+ desc,
+ ev->timestamp);
+}
+
+static void __rs_cb_mouse_move(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ Evas_Event_Mouse_Move *ev = event_info;
+ const char *desc = evas_device_description_get(ev->dev);
+ int x;
+ int y;
+ int w;
+ int h;
+ struct tizen_remote_surface *surface;
+
+ evas_object_geometry_get(obj, &x, &y, &w, &h);
+
+ LOGD("mouse move: %d %d", ev->cur.canvas.x - x, ev->cur.canvas.y - y);
+
+ if (desc == NULL)
+ desc = "";
+
+ if (screen_connector_toolkit_check_input_disabled(toolkit_evas_h->toolkit_h,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X_Y)) {
+ LOGD("mouse move disabled");
+ return;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return;
+ }
+
+ tizen_remote_surface_transfer_mouse_event(surface,
+ TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE,
+ 0,
+ 0,
+ ev->cur.canvas.x - x,
+ ev->cur.canvas.y - y,
+ wl_fixed_from_double(ev->radius_x),
+ wl_fixed_from_double(ev->radius_y),
+ wl_fixed_from_double(ev->pressure),
+ wl_fixed_from_double(ev->angle),
+ evas_device_class_get(ev->dev),
+ evas_device_subclass_get(ev->dev),
+ desc,
+ ev->timestamp);
+}
+
+static void __rs_cb_mouse_wheel(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ Evas_Event_Mouse_Wheel *ev = event_info;
+ const char *desc = evas_device_description_get(ev->dev);
+ struct tizen_remote_surface *surface;
+
+ LOGD("mouse wheel");
+
+ if (desc == NULL)
+ desc = "";
+
+ if (screen_connector_toolkit_check_input_disabled(toolkit_evas_h->toolkit_h,
+ SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_WHEEL)) {
+ LOGD("mouse wheel disabled");
+ return;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return;
+ }
+
+ tizen_remote_surface_transfer_mouse_wheel(surface,
+ ev->direction,
+ ev->z,
+ evas_device_class_get(ev->dev),
+ evas_device_subclass_get(ev->dev),
+ desc,
+ ev->timestamp);
+}
+
+static void __rs_cb_show(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ LOGD("show");
+ __obj_update_visibility(data, e, obj, event_info);
+}
+
+static void __rs_cb_hide(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ LOGD("hide");
+}
+
+static void __rs_cb_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+ LOGD("resize");
+ __obj_update_visibility(data, e, obj, event_info);
+}
+
+static void __clear_img_tbm(screen_connector_toolkit_evas_h toolkit_evas_h)
+{
+ if (toolkit_evas_h->img_tbm == NULL)
+ return;
+
+ g_hash_table_remove(toolkit_evas_h->type_h->toolkit_table, toolkit_evas_h->img_tbm);
+ evas_object_del(toolkit_evas_h->img_tbm);
+ toolkit_evas_h->img_tbm = NULL;
+}
+
+static void __clear_img_file(screen_connector_toolkit_evas_h toolkit_evas_h)
+{
+ if (toolkit_evas_h->img_file == NULL)
+ return;
+
+ evas_object_del(toolkit_evas_h->img_file);
+ toolkit_evas_h->img_file = NULL;
+}
+
+static void __toolkit_update_cb(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys,
+ const char *appid, const char *instance_id, const int pid, void *data)
+{
+ bool is_added = false;
+ Evas_Native_Surface ns;
+ tbm_surface_h tbm_surface;
+ int width, height;
+ char *map;
+ char format[] = "png";
+ char plug_id[256];
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+
+ toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ if (toolkit_evas_h->img_tbm == NULL) {
+ LOGD("first added !!!! %d, %d %s", (toolkit_evas_h->img_tbm == NULL), type, appid);
+ toolkit_evas_h->img_tbm = evas_object_image_filled_add(
+ evas_object_evas_get(toolkit_evas_h->type_h->viewer_win));
+
+ /* Image alpha set */
+ evas_object_image_alpha_set(toolkit_evas_h->img_tbm, 1);
+
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_MOUSE_DOWN,
+ __rs_cb_mouse_down, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_MOUSE_UP,
+ __rs_cb_mouse_up, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_MOUSE_MOVE,
+ __rs_cb_mouse_move, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_MOUSE_WHEEL,
+ __rs_cb_mouse_wheel, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_SHOW,
+ __rs_cb_show, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_HIDE,
+ __rs_cb_hide, toolkit_evas_h);
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_RESIZE,
+ __rs_cb_resize, toolkit_evas_h);
+
+ /* Store toolkit_evas_h */
+ g_hash_table_insert(toolkit_evas_h->type_h->toolkit_table, toolkit_evas_h->img_tbm, toolkit_evas_h);
+
+ /* Set data to use in accessibility */
+ snprintf(plug_id, sizeof(plug_id), "%s:%d", appid, pid);
+ evas_object_data_set(toolkit_evas_h->img_tbm, "___PLUGID", strdup(plug_id));
+ evas_object_event_callback_add(toolkit_evas_h->img_tbm,
+ EVAS_CALLBACK_MOVE, __obj_update_visibility, toolkit_evas_h);
+ }
+
+ if (toolkit_evas_h->img_type != type)
+ is_added = true;
+ toolkit_evas_h->img_type = type;
+
+ /* check type of given buffer */
+ if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM) {
+ /* get tbm surface from buffer */
+ tbm_surface = wl_buffer_get_user_data(tbm);
+ width = tbm_surface_get_width(tbm_surface);
+ height = tbm_surface_get_height(tbm_surface);
+
+ memset(&ns, 0, sizeof(Evas_Native_Surface));
+ ns.version = EVAS_NATIVE_SURFACE_VERSION;
+ ns.type = EVAS_NATIVE_SURFACE_TBM;
+ ns.data.tbm.buffer = tbm_surface;
+
+ evas_object_resize(toolkit_evas_h->img_tbm, width, height);
+ evas_object_image_size_set(toolkit_evas_h->img_tbm, width, height);
+ evas_object_image_native_surface_set(toolkit_evas_h->img_tbm, &ns); /* set native surface */
+ evas_object_image_pixels_dirty_set(toolkit_evas_h->img_tbm, EINA_TRUE); /* set dirty for image updating */
+ } else if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
+ if (!toolkit_evas_h->img_file)
+ toolkit_evas_h->img_file = evas_object_image_filled_add(evas_object_evas_get(toolkit_evas_h->type_h->viewer_win));
+
+ map = mmap(NULL, img_file_size, PROT_READ, MAP_SHARED, img_file_fd, 0);
+ evas_object_image_memfile_set(toolkit_evas_h->img_file, map, img_file_size, format, NULL);
+ evas_object_image_size_get(toolkit_evas_h->img_tbm, &width, &height);
+ evas_object_image_fill_set(toolkit_evas_h->img_file, 0, 0, width, height);
+ evas_object_resize(toolkit_evas_h->img_file, width, height);
+ munmap(map, img_file_size);
+
+ evas_object_image_native_surface_set(toolkit_evas_h->img_tbm, NULL); /* set null to previous object for the tbm type */
+ }
+
+ if (toolkit_evas_h->pre_buffer) {
+ if (tizen_remote_surface_get_version(trs) >= TIZEN_REMOTE_SURFACE_RELEASE_SINCE_VERSION)
+ tizen_remote_surface_release(trs, toolkit_evas_h->pre_buffer);
+ }
+ toolkit_evas_h->pre_buffer = tbm;
+
+ if (is_added) {
+ LOGD("call added !!!! %s, type %d", appid, type);
+ if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
+ toolkit_evas_h->ops->added_cb(appid, instance_id, pid, toolkit_evas_h->img_file,
+ toolkit_evas_h->data);
+ __clear_img_tbm(toolkit_evas_h);
+ } else {
+ toolkit_evas_h->ops->added_cb(appid, instance_id, pid, toolkit_evas_h->img_tbm,
+ toolkit_evas_h->data);
+ __clear_img_file(toolkit_evas_h);
+ }
+ } else {
+ LOGD("call updated !!!! %s, type %d", appid, type);
+ if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
+ toolkit_evas_h->ops->updated_cb(appid, instance_id, pid, toolkit_evas_h->img_file,
+ toolkit_evas_h->data);
+ __clear_img_tbm(toolkit_evas_h);
+ } else {
+ toolkit_evas_h->ops->updated_cb(appid, instance_id, pid, toolkit_evas_h->img_tbm,
+ toolkit_evas_h->data);
+ __clear_img_file(toolkit_evas_h);
+ }
+ }
+ close(img_file_fd); /* close passed fd */
+}
+
+static void __toolkit_added_cb(const char *appid, const char *instance_id, const int pid, void *data)
+{
+}
+
+static void __free_toolkit_evas_h(screen_connector_toolkit_evas_h toolkit_evas_h)
+{
+ if (!toolkit_evas_h)
+ return;
+
+ if (toolkit_evas_h->toolkit_h)
+ screen_connector_toolkit_remove(toolkit_evas_h->toolkit_h);
+
+ __clear_img_file(toolkit_evas_h);
+ __clear_img_tbm(toolkit_evas_h);
+
+ if (toolkit_evas_h->ops) {
+ free(toolkit_evas_h->ops);
+ toolkit_evas_h->ops = NULL;
+ }
+
+ free(toolkit_evas_h);
+}
+
+static void __toolkit_removed_cb(const char *appid, const char *instance_id, const int pid, void *data)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+ char *plug_id;
+
+ LOGD("missing %s %s", appid, instance_id);
+ toolkit_evas_h = (screen_connector_toolkit_evas_h)data;
+ if (!toolkit_evas_h) {
+ LOGE("Null toolkit_evas_h");
+ return;
+ }
+
+ if (toolkit_evas_h->type_h->toolkit_table != NULL && toolkit_evas_h->img_tbm != NULL) {
+ g_hash_table_remove(toolkit_evas_h->type_h->toolkit_table, toolkit_evas_h->img_tbm);
+
+ /* Remove data used in accessibility */
+ plug_id = evas_object_data_del(toolkit_evas_h->img_tbm, "___PLUGID");
+ free(plug_id);
+ }
+
+ if (toolkit_evas_h->img_tbm != NULL)
+ toolkit_evas_h->ops->removed_cb(appid, instance_id, pid, toolkit_evas_h->img_tbm, toolkit_evas_h->data);
+ else if (toolkit_evas_h->img_file != NULL)
+ toolkit_evas_h->ops->removed_cb(appid, instance_id, pid, toolkit_evas_h->img_file, toolkit_evas_h->data);
+
+ __free_toolkit_evas_h(toolkit_evas_h);
+}
+
+EXPORT_API screen_connector_toolkit_evas_h screen_connector_toolkit_evas_add(screen_connector_toolkit_evas_ops *ops, char *id,
+ screen_connector_screen_type_e type, void *data)
+{
+ screen_connector_toolkit_evas_h handle;
+ screen_connector_toolkit_evas_ops *evas_ops;
+ screen_connector_toolkit_ops *toolkit_ops;
+ screen_connector_type_evas_h type_h;
+ int int_type = type;
+
+ type_h = g_hash_table_lookup(__type_table, &int_type);
+ if (type_h == NULL) {
+ LOGE("type %d is not initialized !!", type);
+ return NULL;
+ }
+
+ toolkit_ops = (screen_connector_toolkit_ops *)calloc(1, sizeof(screen_connector_toolkit_ops));
+ toolkit_ops->added_cb = __toolkit_added_cb;
+ toolkit_ops->updated_cb = __toolkit_update_cb;
+ toolkit_ops->removed_cb = __toolkit_removed_cb;
+
+ evas_ops = (screen_connector_toolkit_evas_ops *)calloc(1, sizeof(screen_connector_toolkit_evas_ops));
+ if (evas_ops == NULL) {
+ LOGE("evas_ops calloc fail");
+ return NULL;
+ }
+
+ memcpy(evas_ops, ops, sizeof(screen_connector_toolkit_evas_ops));
+ handle = (screen_connector_toolkit_evas_h)calloc(1, sizeof(struct _screen_connector_toolkit_evas_h));
+ if (handle == NULL) {
+ LOGE("handle calloc fail");
+ free(evas_ops);
+ return NULL;
+ }
+ handle->img_type = -1;
+ handle->ops = evas_ops;
+ handle->data = data;
+ handle->type_h = type_h;
+ handle->toolkit_h = screen_connector_toolkit_add(toolkit_ops, id, type, handle);
+
+ return handle;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_remove(screen_connector_toolkit_evas_h handle)
+{
+ if (handle == NULL)
+ return -1;
+
+ __free_toolkit_evas_h(handle);
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_update(const char *appid, const char *instance_id)
+{
+ return screen_connector_toolkit_update(appid, instance_id);
+}
+
+static void __send_visibility(gpointer key, gpointer value, gpointer user_data)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h = (screen_connector_toolkit_evas_h)value;
+ Evas_Object *evas_obj = (Evas_Object *)key;
+ unsigned int event = GPOINTER_TO_INT(user_data);
+ int ret;
+ visibility_type type;
+
+ if (toolkit_evas_h->freeze)
+ return;
+
+ if (!__obj_is_visible(evas_obj, toolkit_evas_h))
+ return;
+
+ if (event)
+ type = VISIBILITY_TYPE_FULLY_OBSCURED;
+ else
+ type = VISIBILITY_TYPE_UNOBSCURED;
+
+ ret = __set_visibility(toolkit_evas_h, type);
+ if (ret == -1)
+ LOGE("failed to set object visibility set %p to %d", evas_obj, type);
+}
+
+static Eina_Bool __visibility_cb(void *data, int type, void *event)
+{
+ Ecore_Wl_Event_Window_Visibility_Change *ev = event;
+ GHashTableIter iter;
+ gpointer key, value;
+ screen_connector_type_evas_h cur_type;
+
+ LOGD("visibility change: %d %d", (unsigned int)ev->win,
+ (unsigned int)ev->fully_obscured);
+
+ if (!__type_table)
+ return ECORE_CALLBACK_RENEW;
+
+ g_hash_table_iter_init(&iter, __type_table);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ cur_type = (screen_connector_type_evas_h)value;
+ if (cur_type->toolkit_table)
+ g_hash_table_foreach(cur_type->toolkit_table, __send_visibility,
+ GINT_TO_POINTER(ev->fully_obscured));
+ }
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_start_visibility_notify(void)
+{
+ if (__visibility_listener)
+ return 0;
+
+ __visibility_listener = ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, __visibility_cb, NULL);
+
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_stop_visibility_notify(void)
+{
+ if (!__visibility_listener)
+ return 0;
+
+ ecore_event_handler_del(__visibility_listener);
+ __visibility_listener = NULL;
+
+ return 0;
+}
+
+screen_connector_toolkit_evas_h __find_toolkit_evas_h(Evas_Object *obj)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+ GHashTableIter iter;
+ gpointer key, value;
+ screen_connector_type_evas_h cur_type;
+
+ g_hash_table_iter_init(&iter, __type_table);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ cur_type = (screen_connector_type_evas_h)value;
+ if (cur_type->toolkit_table) {
+ toolkit_evas_h = g_hash_table_lookup(cur_type->toolkit_table, obj);
+ if (toolkit_evas_h != NULL)
+ return toolkit_evas_h;
+ }
+ }
+
+ return NULL;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_freeze_visibility(Evas_Object *obj, visibility_type type)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("obj not found");
+ return -1;
+ }
+ toolkit_evas_h->freeze = 1;
+
+ return __set_visibility(toolkit_evas_h, type);
+}
+
+EXPORT_API int screen_connector_toolkit_evas_thaw_visibility(Evas_Object *obj)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("obj not found");
+ return -1;
+ }
+ toolkit_evas_h->freeze = 0;
+
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_send_mouse_up(Evas_Object *obj)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+ int x;
+ int y;
+ int w;
+ int h;
+ unsigned int timestamp;
+ struct tizen_remote_surface *surface;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("unknown object. not widget object.");
+ return -1;
+ }
+
+ if (!toolkit_evas_h->img_tbm) {
+ LOGE("surface not yet initialized.");
+ return -1;
+ }
+
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return -1;
+ }
+
+ evas_object_geometry_get(obj, &x, &y, &w, &h);
+ timestamp = (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff);
+ tizen_remote_surface_transfer_mouse_event(surface,
+ TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP,
+ 0,
+ 1,
+ w / 2,
+ h / 2,
+ 0,
+ 0,
+ 0,
+ 0,
+ TIZEN_INPUT_DEVICE_CLAS_MOUSE,
+ TIZEN_INPUT_DEVICE_SUBCLAS_NONE,
+ "",
+ timestamp);
+
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_send_touch_cancel(Evas_Object *obj)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+ struct tizen_remote_surface *surface;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("unknown object. not widget object.");
+ return -1;
+ }
+
+ if (toolkit_evas_h->img_tbm) {
+ surface = screen_connector_toolkit_get_trs(toolkit_evas_h->toolkit_h);
+ if (surface == NULL) {
+ LOGE("surface is NULL");
+ return -1;
+ }
+
+ tizen_remote_surface_transfer_touch_cancel(surface);
+ toolkit_evas_h->cancel_touch = true;
+ } else {
+ LOGE("surface not yet initialized.");
+ return -1;
+ }
+
+ return 0;
+}
+
+EXPORT_API screen_connector_toolkit_evas_h screen_connector_toolkit_evas_add_by_rid(screen_connector_toolkit_evas_ops *ops,
+ int res_id, screen_connector_screen_type_e type, void *data)
+{
+ screen_connector_toolkit_evas_h handle;
+ screen_connector_toolkit_evas_ops *evas_ops;
+ screen_connector_toolkit_ops *toolkit_ops;
+ screen_connector_type_evas_h type_h;
+ char rid_str[32];
+
+ type_h = g_hash_table_lookup(__type_table, &type);
+ if (type_h == NULL) {
+ LOGE("type %d is not initialized !!", type);
+ return NULL;
+ }
+
+ toolkit_ops = (screen_connector_toolkit_ops *)calloc(1, sizeof(screen_connector_toolkit_ops));
+ toolkit_ops->added_cb = __toolkit_added_cb;
+ toolkit_ops->updated_cb = __toolkit_update_cb;
+ toolkit_ops->removed_cb = __toolkit_removed_cb;
+
+ evas_ops = (screen_connector_toolkit_evas_ops *)calloc(1, sizeof(screen_connector_toolkit_evas_ops));
+ if (evas_ops == NULL) {
+ LOGE("evas_ops calloc fail");
+ return NULL;
+ }
+
+ memcpy(evas_ops, ops, sizeof(screen_connector_toolkit_evas_ops));
+ handle = (screen_connector_toolkit_evas_h)calloc(1, sizeof(struct _screen_connector_toolkit_evas_h));
+ if (handle == NULL) {
+ LOGE("handle calloc fail");
+ free(evas_ops);
+ return NULL;
+ }
+ handle->img_type = -1;
+ handle->ops = evas_ops;
+ handle->data = data;
+ handle->type_h = type_h;
+
+ snprintf(rid_str, sizeof(rid_str), "%d", res_id);
+ handle->toolkit_h = screen_connector_toolkit_create_handle(rid_str, res_id, toolkit_ops, handle);
+ screen_connector_toolkit_redirect_surface(handle->toolkit_h);
+
+ return handle;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_get_rid(Evas_Object *obj, int *resource_id)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("unknown object.");
+ return -1;
+ }
+ *resource_id = screen_connector_toolkit_get_surface_id(toolkit_evas_h->toolkit_h);
+
+ return 0;
+}
+
+EXPORT_API int screen_connector_toolkit_evas_get_pid(Evas_Object *obj, int *pid)
+{
+ screen_connector_toolkit_evas_h toolkit_evas_h;
+ int toolkit_pid = 0;
+
+ toolkit_evas_h = __find_toolkit_evas_h(obj);
+ if (!toolkit_evas_h) {
+ LOGE("unknown object.");
+ return -1;
+ }
+
+ toolkit_pid = screen_connector_toolkit_get_pid(toolkit_evas_h->toolkit_h);
+ if (toolkit_pid == 0) {
+ LOGE("Invalid object");
+ return -1;
+ }
+
+ *pid = toolkit_pid;
+
+ return 0;
+}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
#include <stdio.h>
#include <errno.h>
#include <glib.h>
#define LOG_TAG "SC_WATCHER_EVAS"
+static Evas_Object *__viewer_win;
+
struct _screen_connector_watcher_evas_h {
screen_connector_watcher_evas_ops *ops;
screen_connector_watcher_h watcher_h;
- int freeze;
- bool is_init;
- bool cancel_touch;
+ void *data;
+};
+
+struct _img_info_h {
Evas_Object *img_tbm;
Evas_Object *img_file;
- uint32_t img_type;
struct wl_buffer *pre_buffer;
- void *data;
+ char *appid;
+ char *instance_id;
+ int pid;
};
-static Evas_Object *__viewer_win;
-static Ecore_Event_Handler *__visibility_listener;
-static GHashTable *__watcher_tbl;
-
-EXPORT_API int screen_connector_watcher_evas_init(Evas_Object *win)
-{
- __viewer_win = win;
-
- __watcher_tbl = g_hash_table_new(g_direct_hash, g_direct_equal);
- if (!__watcher_tbl) {
- LOGE("failed to create table");
- return -1;
- }
-
- return screen_connector_watcher_init();
-}
-
-EXPORT_API int screen_connector_watcher_evas_fini(void)
-{
- if (__watcher_tbl)
- g_hash_table_destroy(__watcher_tbl);
-
- __watcher_tbl = NULL;
- return screen_connector_watcher_fini();
-}
-
-static bool __obj_is_visible(Evas_Object *obj)
-{
- int x, y, w, h;
- Ecore_Wl_Window *window = NULL;
- int window_x, window_y, window_w, window_h;
- int rotation;
-
- window = elm_win_wl_window_get(__viewer_win);
- ecore_wl_window_geometry_get(window, &window_x, &window_y, &window_w, &window_h);
- evas_object_geometry_get(obj, &x, &y, &w, &h);
- rotation = ecore_wl_window_rotation_get(window);
-
- if (x >= 0 && x < window_w &&
- y >= 0 && y < window_h &&
- (rotation == 0 || rotation == 180)) {
- LOGD("x %d, y %d w %d h %d, window_w %d window_h %d rotation %d",
- x, y, w, h, window_w, window_h, rotation);
- return true;
- } else if (x >= 0 && x < window_h &&
- y >= 0 && y < window_w &&
- (rotation == 90 || rotation == 270)) {
- LOGD("x %d, y %d w %d h %d, window_w %d window_h %d rotation %d",
- x, y, w, h, window_w, window_h, rotation);
- return true;
- }
-
- return false;
-}
-
-static int __set_visibility(screen_connector_watcher_evas_h watcher_evas_h, visibility_type type)
-{
- int obscured;
- struct tizen_remote_surface *surface;
-
- if (!watcher_evas_h) {
- LOGE("obj not found");
- return -1;
- }
-
- switch (type) {
- case VISIBILITY_TYPE_UNOBSCURED:
- case VISIBILITY_TYPE_PARTIALLY_OBSCURED:
- obscured = TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE;
- break;
- case VISIBILITY_TYPE_FULLY_OBSCURED:
- obscured = TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_INVISIBLE;
- break;
- default:
- return -1;
- }
+typedef struct _img_info_h *img_info_h;
+static GHashTable *__img_info_table = NULL;
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface)
- tizen_remote_surface_transfer_visibility(surface, obscured);
-
- return 0;
-}
-
-static void __obj_update_visibility(void *data, Evas *e, Evas_Object *obj, void *event_info)
+static void __clear_img_tbm(img_info_h info)
{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
-
- if (!watcher_evas_h->is_init) {
- watcher_evas_h->is_init = true;
+ if (info->img_tbm == NULL)
return;
- }
- if (__obj_is_visible(obj))
- __set_visibility(watcher_evas_h, VISIBILITY_TYPE_UNOBSCURED);
- else
- __set_visibility(watcher_evas_h, VISIBILITY_TYPE_FULLY_OBSCURED);
+ evas_object_del(info->img_tbm);
+ info->img_tbm = NULL;
}
-static void __rs_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
+static void __clear_img_file(img_info_h info)
{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
- Evas_Event_Mouse_Down *ev = event_info;
- const char *desc = evas_device_description_get(ev->dev);
- int x;
- int y;
- int w;
- int h;
- struct tizen_remote_surface *surface;
-
- evas_object_geometry_get(obj, &x, &y, &w, &h);
-
- LOGD("mouse down: %d %d", ev->canvas.x - x, ev->canvas.y - y);
-
- if (desc == NULL)
- desc = "";
-
- if (screen_connector_watcher_check_input_disabled(watcher_evas_h->watcher_h,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN)) {
- LOGD("mouse down disabled");
+ if (info->img_file == NULL)
return;
- }
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return;
- }
-
- tizen_remote_surface_transfer_mouse_event(surface,
- TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_DOWN,
- 0,
- ev->button,
- ev->canvas.x - x,
- ev->canvas.y - y,
- wl_fixed_from_double(ev->radius_x),
- wl_fixed_from_double(ev->radius_y),
- wl_fixed_from_double(ev->pressure),
- wl_fixed_from_double(ev->angle),
- evas_device_class_get(ev->dev),
- evas_device_subclass_get(ev->dev),
- desc,
- ev->timestamp);
+ evas_object_del(info->img_file);
+ info->img_file = NULL;
}
-static void __rs_cb_mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
-{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
- Evas_Event_Mouse_Up *ev = event_info;
- const char *desc = evas_device_description_get(ev->dev);
- int x;
- int y;
- int w;
- int h;
- struct tizen_remote_surface *surface;
-
- evas_object_geometry_get(obj, &x, &y, &w, &h);
-
- LOGD("mouse up: %d %d", ev->canvas.x - x, ev->canvas.y - y);
-
- if (desc == NULL)
- desc = "";
-
- if (screen_connector_watcher_check_input_disabled(watcher_evas_h->watcher_h,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_UP_DOWN)) {
- LOGD("mouse up disabled");
- return;
- }
-
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return;
- }
-
- tizen_remote_surface_transfer_mouse_event(surface,
- TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP,
- 0,
- ev->button,
- ev->canvas.x - x,
- ev->canvas.y - y,
- wl_fixed_from_double(ev->radius_x),
- wl_fixed_from_double(ev->radius_y),
- wl_fixed_from_double(ev->pressure),
- wl_fixed_from_double(ev->angle),
- evas_device_class_get(ev->dev),
- evas_device_subclass_get(ev->dev),
- desc,
- ev->timestamp);
-}
-static void __rs_cb_mouse_move(void *data, Evas *e, Evas_Object *obj, void *event_info)
+static img_info_h __create_img_info(const char *appid, const char *instance_id, int pid)
{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
- Evas_Event_Mouse_Move *ev = event_info;
- const char *desc = evas_device_description_get(ev->dev);
- int x;
- int y;
- int w;
- int h;
- struct tizen_remote_surface *surface;
-
- evas_object_geometry_get(obj, &x, &y, &w, &h);
-
- LOGD("mouse move: %d %d", ev->cur.canvas.x - x, ev->cur.canvas.y - y);
-
- if (desc == NULL)
- desc = "";
-
- if (screen_connector_watcher_check_input_disabled(watcher_evas_h->watcher_h,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_MOVE_X_Y)) {
- LOGD("mouse move disabled");
- return;
- }
-
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return;
- }
-
- tizen_remote_surface_transfer_mouse_event(surface,
- TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_MOVE,
- 0,
- 0,
- ev->cur.canvas.x - x,
- ev->cur.canvas.y - y,
- wl_fixed_from_double(ev->radius_x),
- wl_fixed_from_double(ev->radius_y),
- wl_fixed_from_double(ev->pressure),
- wl_fixed_from_double(ev->angle),
- evas_device_class_get(ev->dev),
- evas_device_subclass_get(ev->dev),
- desc,
- ev->timestamp);
+ img_info_h info = (img_info_h)calloc(1, sizeof(struct _img_info_h));
+ info->appid = strdup(appid);
+ info->instance_id = strdup(instance_id);
+ info->pid = pid;
+ return info;
}
-static void __rs_cb_mouse_wheel(void *data, Evas *e, Evas_Object *obj, void *event_info)
+static void __destroy_img_info(gpointer data)
{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
- Evas_Event_Mouse_Wheel *ev = event_info;
- const char *desc = evas_device_description_get(ev->dev);
- struct tizen_remote_surface *surface;
-
- LOGD("mouse wheel");
-
- if (desc == NULL)
- desc = "";
-
- if (screen_connector_watcher_check_input_disabled(watcher_evas_h->watcher_h,
- SCREEN_CONNECTOR_INPUT_TYPE_MOUSE_WHEEL)) {
- LOGD("mouse wheel disabled");
+ img_info_h info = (img_info_h)data;
+ if (info == NULL)
return;
+ if (info->appid) {
+ free(info->appid);
+ info->appid = NULL;
}
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return;
+ if (info->instance_id) {
+ free(info->instance_id);
+ info->instance_id = NULL;
}
+ __clear_img_file(info);
+ __clear_img_tbm(info);
- tizen_remote_surface_transfer_mouse_wheel(surface,
- ev->direction,
- ev->z,
- evas_device_class_get(ev->dev),
- evas_device_subclass_get(ev->dev),
- desc,
- ev->timestamp);
+ free(info);
}
-static void __rs_cb_show(void *data, Evas *e, Evas_Object *obj, void *event_info)
-{
- LOGD("show");
- __obj_update_visibility(data, e, obj, event_info);
-}
-static void __rs_cb_hide(void *data, Evas *e, Evas_Object *obj, void *event_info)
+EXPORT_API int screen_connector_watcher_evas_init(Evas_Object *win)
{
- LOGD("hide");
+ __viewer_win = win;
+ __img_info_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, free, __destroy_img_info);
+ return screen_connector_watcher_init();
}
-static void __rs_cb_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
+EXPORT_API int screen_connector_watcher_evas_fini(void)
{
- LOGD("resize");
- __obj_update_visibility(data, e, obj, event_info);
+ g_hash_table_destroy(__img_info_table);
+ return screen_connector_watcher_fini();
}
-static void __clear_img_tbm(screen_connector_watcher_evas_h watcher_evas_h)
+static void __watcher_added_cb(const char *appid, const char *instance_id, const int pid, void *data)
{
- if (watcher_evas_h->img_tbm == NULL)
- return;
+ LOGE("__watcher_added_cb %s %s %d", appid, instance_id, pid);
+ screen_connector_watcher_evas_h handle = (screen_connector_watcher_evas_h)data;
- g_hash_table_remove(__watcher_tbl, watcher_evas_h->img_tbm);
- evas_object_del(watcher_evas_h->img_tbm);
- watcher_evas_h->img_tbm = NULL;
+ if (handle)
+ handle->ops->added_cb(appid, instance_id, pid, handle->data);
}
-static void __clear_img_file(screen_connector_watcher_evas_h watcher_evas_h)
+static void __watcher_removed_cb(const char *appid, const char *instance_id, const int pid, void *data)
{
- if (watcher_evas_h->img_file == NULL)
- return;
+ screen_connector_watcher_evas_h handle = (screen_connector_watcher_evas_h)data;
+ img_info_h cur_info;
- evas_object_del(watcher_evas_h->img_file);
- watcher_evas_h->img_file = NULL;
+ if (handle)
+ handle->ops->removed_cb(appid, instance_id, pid, handle->data);
+
+ cur_info = g_hash_table_lookup(__img_info_table, instance_id);
+ if (cur_info)
+ g_hash_table_remove(__img_info_table, instance_id);
}
-static void __watcher_change_cb(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
- int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, void *data)
+static void __watcher_update_cb(struct tizen_remote_surface *trs, uint32_t type, struct wl_buffer *tbm,
+ int32_t img_file_fd, uint32_t img_file_size, uint32_t time, struct wl_array *keys, const char *appid,
+ const char *instance_id, int pid, void *data)
{
- bool is_added = false;
Evas_Native_Surface ns;
tbm_surface_h tbm_surface;
int width, height;
char *map;
char format[] = "png";
- char plug_id[256];
- screen_connector_watcher_evas_h watcher_evas_h;
- char *appid;
- char pid;
-
- watcher_evas_h = (screen_connector_watcher_evas_h)data;
- appid = screen_connector_watcher_get_appid(watcher_evas_h->watcher_h);
- pid = screen_connector_watcher_get_pid(watcher_evas_h->watcher_h);
-
- if (watcher_evas_h->img_tbm == NULL) {
- LOGD("first added !!!! %d, %d %s", (watcher_evas_h->img_tbm == NULL), type, appid);
- watcher_evas_h->img_tbm = evas_object_image_filled_add(
- evas_object_evas_get(__viewer_win));
-
- /* Image alpha set */
- evas_object_image_alpha_set(watcher_evas_h->img_tbm, 1);
-
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_MOUSE_DOWN,
- __rs_cb_mouse_down, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_MOUSE_UP,
- __rs_cb_mouse_up, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_MOUSE_MOVE,
- __rs_cb_mouse_move, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_MOUSE_WHEEL,
- __rs_cb_mouse_wheel, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_SHOW,
- __rs_cb_show, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_HIDE,
- __rs_cb_hide, watcher_evas_h);
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_RESIZE,
- __rs_cb_resize, watcher_evas_h);
-
- /* Store watcher_evas_h */
- g_hash_table_insert(__watcher_tbl, watcher_evas_h->img_tbm, watcher_evas_h);
-
- /* Set data to use in accessibility */
- snprintf(plug_id, sizeof(plug_id), "%s:%d", appid, pid);
- evas_object_data_set(watcher_evas_h->img_tbm, "___PLUGID", strdup(plug_id));
- evas_object_event_callback_add(watcher_evas_h->img_tbm,
- EVAS_CALLBACK_MOVE, __obj_update_visibility, watcher_evas_h);
+ screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)data;
+ img_info_h info;
+
+ if (tbm == NULL && type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM) {
+ LOGE("TBM is null !! %d, %s, %s", TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM, appid, instance_id);
+ return;
}
- if (watcher_evas_h->img_type != type)
- is_added = true;
- watcher_evas_h->img_type = type;
+ info = g_hash_table_lookup(__img_info_table, instance_id);
+ if (info == NULL) {
+ info = __create_img_info(appid, instance_id, pid);
+ g_hash_table_insert(__img_info_table, strdup(instance_id), info);
+ }
/* check type of given buffer */
if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM) {
+
+ if (info->img_tbm == NULL) {
+ LOGD("first added tbm type !!!! %d, %d %s", (info->img_tbm == NULL), type, appid);
+ if (info->img_file) {
+ watcher_evas_h->ops->removed_cb(appid, instance_id, pid, watcher_evas_h->data);
+ __clear_img_file(info);
+ }
+ info->img_tbm = evas_object_image_filled_add(
+ evas_object_evas_get(__viewer_win));
+ watcher_evas_h->ops->added_cb(appid, instance_id, pid, watcher_evas_h->data);
+ }
+
/* get tbm surface from buffer */
tbm_surface = wl_buffer_get_user_data(tbm);
width = tbm_surface_get_width(tbm_surface);
ns.type = EVAS_NATIVE_SURFACE_TBM;
ns.data.tbm.buffer = tbm_surface;
- evas_object_resize(watcher_evas_h->img_tbm, width, height);
- evas_object_image_size_set(watcher_evas_h->img_tbm, width, height);
- evas_object_image_native_surface_set(watcher_evas_h->img_tbm, &ns); /* set native surface */
- evas_object_image_pixels_dirty_set(watcher_evas_h->img_tbm, EINA_TRUE); /* set dirty for image updating */
+ evas_object_resize(info->img_tbm, width, height);
+ evas_object_image_size_set(info->img_tbm, width, height);
+ evas_object_image_native_surface_set(info->img_tbm, &ns); /* set native surface */
+ evas_object_image_pixels_dirty_set(info->img_tbm, EINA_TRUE); /* set dirty for image updating */
+ watcher_evas_h->ops->updated_cb(appid, instance_id, pid, info->img_tbm, watcher_evas_h->data);
+
} else if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
- if (!watcher_evas_h->img_file)
- watcher_evas_h->img_file = evas_object_image_filled_add(evas_object_evas_get(__viewer_win));
+
+ if (info->img_file == NULL) {
+ LOGD("first added file type !!!! %d %s", type, appid);
+ if (info->img_tbm) {
+ watcher_evas_h->ops->removed_cb(appid, instance_id, pid, watcher_evas_h->data);
+ __clear_img_tbm(info);
+ }
+ info->img_file = evas_object_image_filled_add(
+ evas_object_evas_get(__viewer_win));
+ watcher_evas_h->ops->added_cb(appid, instance_id, pid, watcher_evas_h->data);
+ }
map = mmap(NULL, img_file_size, PROT_READ, MAP_SHARED, img_file_fd, 0);
- evas_object_image_memfile_set(watcher_evas_h->img_file, map, img_file_size, format, NULL);
- evas_object_image_size_get(watcher_evas_h->img_tbm, &width, &height);
- evas_object_image_fill_set(watcher_evas_h->img_file, 0, 0, width, height);
- evas_object_resize(watcher_evas_h->img_file, width, height);
+ evas_object_image_memfile_set(info->img_file, map, img_file_size, format, NULL);
+ evas_object_image_size_get(info->img_tbm, &width, &height);
+ evas_object_image_fill_set(info->img_file, 0, 0, width, height);
+ evas_object_resize(info->img_file, width, height);
munmap(map, img_file_size);
- evas_object_image_native_surface_set(watcher_evas_h->img_tbm, NULL); /* set null to previous object for the tbm type */
+ evas_object_image_native_surface_set(info->img_tbm, NULL); /* set null to previous object for the tbm type */
+ watcher_evas_h->ops->updated_cb(appid, instance_id, pid, info->img_file, watcher_evas_h->data);
}
- if (watcher_evas_h->pre_buffer) {
+ if (info->pre_buffer) {
if (tizen_remote_surface_get_version(trs) >= TIZEN_REMOTE_SURFACE_RELEASE_SINCE_VERSION)
- tizen_remote_surface_release(trs, watcher_evas_h->pre_buffer);
- }
- watcher_evas_h->pre_buffer = tbm;
-
- if (is_added) {
- LOGD("call added !!!! %s, type %d", appid, type);
- if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
- watcher_evas_h->ops->added(appid, watcher_evas_h->img_file,
- watcher_evas_h->data);
- __clear_img_tbm(watcher_evas_h);
- } else {
- watcher_evas_h->ops->added(appid, watcher_evas_h->img_tbm,
- watcher_evas_h->data);
- __clear_img_file(watcher_evas_h);
- }
- } else {
- LOGD("call updated !!!! %s, type %d", appid, type);
- if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_IMAGE_FILE) {
- watcher_evas_h->ops->updated(appid, watcher_evas_h->img_file,
- watcher_evas_h->data);
- __clear_img_tbm(watcher_evas_h);
- } else {
- watcher_evas_h->ops->updated(appid, watcher_evas_h->img_tbm,
- watcher_evas_h->data);
- __clear_img_file(watcher_evas_h);
- }
+ tizen_remote_surface_release(trs, info->pre_buffer);
}
+ info->pre_buffer = tbm;
close(img_file_fd); /* close passed fd */
}
-static void __watcher_update_cb(struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time, void *data)
-{
- __watcher_change_cb(trs, TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM, buffer, 0, 0, 0, NULL, data);
-}
-
-static void __free_watcher_evas_h(screen_connector_watcher_evas_h watcher_evas_h)
+EXPORT_API screen_connector_watcher_evas_h screen_connector_watcher_evas_add(screen_connector_watcher_evas_ops *ops, void *data)
{
- if (!watcher_evas_h)
- return;
-
- if (watcher_evas_h->watcher_h)
- screen_connector_watcher_remove(watcher_evas_h->watcher_h);
-
- if (watcher_evas_h->img_tbm) {
- evas_object_del(watcher_evas_h->img_tbm);
- watcher_evas_h->img_tbm = NULL;
- }
-
- if (watcher_evas_h->ops) {
- free(watcher_evas_h->ops);
- watcher_evas_h->ops = NULL;
- }
- free(watcher_evas_h);
-}
-
-static void __watcher_missing_cb(struct tizen_remote_surface *trs, void *data)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
- char *plug_id;
- char *appid;
-
- LOGD("missing");
- watcher_evas_h = (screen_connector_watcher_evas_h)data;
- if (!watcher_evas_h) {
- LOGE("Null watcher_evas_h");
- return;
- }
-
- if (__watcher_tbl != NULL && watcher_evas_h->img_tbm != NULL) {
- g_hash_table_remove(__watcher_tbl, watcher_evas_h->img_tbm);
-
- /* Remove data used in accessibility */
- plug_id = evas_object_data_del(watcher_evas_h->img_tbm, "___PLUGID");
- free(plug_id);
- }
-
- appid = screen_connector_watcher_get_appid(watcher_evas_h->watcher_h);
- if (watcher_evas_h->img_tbm != NULL)
- watcher_evas_h->ops->removed(appid, watcher_evas_h->img_tbm, watcher_evas_h->data);
- else
- watcher_evas_h->ops->removed(appid, watcher_evas_h->img_file, watcher_evas_h->data);
-
- __free_watcher_evas_h(watcher_evas_h);
-}
-
-EXPORT_API screen_connector_watcher_evas_h screen_connector_watcher_evas_add(screen_connector_watcher_evas_ops *ops, char *id, void *data)
-{
screen_connector_watcher_evas_h handle;
screen_connector_watcher_evas_ops *evas_ops;
- screen_connector_watcher_ops watcher_ops;
+ screen_connector_watcher_ops *watcher_ops;
- watcher_ops.change_cb = __watcher_change_cb;
- watcher_ops.missing_cb = __watcher_missing_cb;
- watcher_ops.update_cb = __watcher_update_cb;
+ watcher_ops = (screen_connector_watcher_ops *)calloc(1, sizeof(screen_connector_watcher_ops));
+ watcher_ops->added_cb = __watcher_added_cb;
+ watcher_ops->updated_cb = __watcher_update_cb;
+ watcher_ops->removed_cb = __watcher_removed_cb;
evas_ops = (screen_connector_watcher_evas_ops *)calloc(1, sizeof(screen_connector_watcher_evas_ops));
if (evas_ops == NULL) {
free(evas_ops);
return NULL;
}
- handle->img_type = -1;
handle->ops = evas_ops;
handle->data = data;
- handle->watcher_h = screen_connector_watcher_add(&watcher_ops, id, handle);
+ handle->watcher_h = screen_connector_watcher_add(watcher_ops, handle);
return handle;
-}
-
-EXPORT_API int screen_connector_watcher_evas_remove(screen_connector_watcher_evas_h handle)
-{
- if (handle == NULL)
- return -1;
- __free_watcher_evas_h(handle);
- return 0;
}
-EXPORT_API int screen_connector_watcher_evas_update(const char *appid)
+static void __destroy_watcher_evas_handle(screen_connector_watcher_evas_h watcher_evas_h)
{
- return screen_connector_watcher_update(appid);
-}
-
-static void __send_visibility(gpointer key, gpointer value, gpointer user_data)
-{
- screen_connector_watcher_evas_h watcher_evas_h = (screen_connector_watcher_evas_h)value;
- Evas_Object *evas_obj = (Evas_Object *)key;
- unsigned int event = GPOINTER_TO_INT(user_data);
- int ret;
- visibility_type type;
-
- if (watcher_evas_h->freeze)
- return;
-
- if (!__obj_is_visible(evas_obj))
+ if (!watcher_evas_h)
return;
- if (event)
- type = VISIBILITY_TYPE_FULLY_OBSCURED;
- else
- type = VISIBILITY_TYPE_UNOBSCURED;
-
- ret = __set_visibility(watcher_evas_h, type);
- if (ret == -1)
- LOGE("failed to set object visibility set %p to %d", evas_obj, type);
-}
-
-static Eina_Bool __visibility_cb(void *data, int type, void *event)
-{
- Ecore_Wl_Event_Window_Visibility_Change *ev = event;
-
- LOGD("visibility change: %d %d", (unsigned int)ev->win,
- (unsigned int)ev->fully_obscured);
-
- if (!__watcher_tbl)
- return ECORE_CALLBACK_RENEW;
-
- g_hash_table_foreach(__watcher_tbl, __send_visibility,
- GINT_TO_POINTER(ev->fully_obscured));
-
- return ECORE_CALLBACK_RENEW;
-}
-
-EXPORT_API int screen_connector_watcher_evas_start_visibility_notify(void)
-{
- if (__visibility_listener)
- return 0;
-
- __visibility_listener = ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, __visibility_cb, NULL);
-
- return 0;
-}
-
-EXPORT_API int screen_connector_watcher_evas_stop_visibility_notify(void)
-{
- if (!__visibility_listener)
- return 0;
-
- ecore_event_handler_del(__visibility_listener);
- __visibility_listener = NULL;
-
- return 0;
-}
-
-EXPORT_API int screen_connector_watcher_evas_freeze_visibility(Evas_Object *obj, visibility_type type)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
-
- watcher_evas_h = (screen_connector_watcher_evas_h)g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("obj not found");
- return -1;
- }
- watcher_evas_h->freeze = 1;
-
- return __set_visibility(watcher_evas_h, type);
-}
-
-EXPORT_API int screen_connector_watcher_evas_thaw_visibility(Evas_Object *obj)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
-
- watcher_evas_h = (screen_connector_watcher_evas_h)g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("obj not found");
- return -1;
- }
- watcher_evas_h->freeze = 0;
-
- return 0;
-}
-
-EXPORT_API int screen_connector_watcher_evas_send_mouse_up(Evas_Object *obj)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
- int x;
- int y;
- int w;
- int h;
- unsigned int timestamp;
- struct tizen_remote_surface *surface;
-
- watcher_evas_h = g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("unknown object. not widget object.");
- return -1;
- }
-
- if (!watcher_evas_h->img_tbm) {
- LOGE("surface not yet initialized.");
- return -1;
- }
-
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return -1;
- }
+ if (watcher_evas_h->watcher_h)
+ screen_connector_watcher_remove(watcher_evas_h->watcher_h);
- evas_object_geometry_get(obj, &x, &y, &w, &h);
- timestamp = (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff);
- tizen_remote_surface_transfer_mouse_event(surface,
- TIZEN_REMOTE_SURFACE_EVENT_TYPE_MOUSE_UP,
- 0,
- 1,
- w / 2,
- h / 2,
- 0,
- 0,
- 0,
- 0,
- TIZEN_INPUT_DEVICE_CLAS_MOUSE,
- TIZEN_INPUT_DEVICE_SUBCLAS_NONE,
- "",
- timestamp);
+ if (watcher_evas_h->ops)
+ free(watcher_evas_h->ops);
- return 0;
+ free(watcher_evas_h);
}
-EXPORT_API int screen_connector_watcher_evas_send_touch_cancel(Evas_Object *obj)
+EXPORT_API int screen_connector_watcher_evas_remove(screen_connector_watcher_evas_h handle)
{
- screen_connector_watcher_evas_h watcher_evas_h;
- struct tizen_remote_surface *surface;
-
- watcher_evas_h = g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("unknown object. not widget object.");
- return -1;
- }
-
- if (watcher_evas_h->img_tbm) {
- surface = screen_connector_watcher_get_trs(watcher_evas_h->watcher_h);
- if (surface == NULL) {
- LOGE("surface is NULL");
- return -1;
- }
-
- tizen_remote_surface_transfer_touch_cancel(surface);
- watcher_evas_h->cancel_touch = true;
- } else {
- LOGE("surface not yet initialized.");
- return -1;
- }
-
+ __destroy_watcher_evas_handle(handle);
return 0;
}
-EXPORT_API screen_connector_watcher_evas_h screen_connector_watcher_evas_add_by_rid(screen_connector_watcher_evas_ops *ops,
- int res_id, void *data)
+EXPORT_API int screen_connector_watcher_evas_update(screen_connector_watcher_evas_h watcher_evas_h,
+ const char *instance_id)
{
- screen_connector_watcher_evas_h watcher_evas_h;
- screen_connector_watcher_evas_ops *evas_ops;
- char rid_str[32];
- int pid = 0;
- screen_connector_watcher_ops watcher_ops;
-
- watcher_ops.change_cb = __watcher_change_cb;
- watcher_ops.missing_cb = __watcher_missing_cb;
- watcher_ops.update_cb = __watcher_update_cb;
-
- evas_ops = (screen_connector_watcher_evas_ops *)calloc(1, sizeof(screen_connector_watcher_evas_ops));
- if (evas_ops == NULL) {
- LOGE("evas_ops calloc fail");
- return NULL;
- }
-
- snprintf(rid_str, sizeof(rid_str), "%d", res_id);
- memcpy(evas_ops, ops, sizeof(screen_connector_watcher_evas_ops));
- watcher_evas_h = (screen_connector_watcher_evas_h)calloc(1, sizeof(struct _screen_connector_watcher_evas_h));
if (watcher_evas_h == NULL) {
- LOGE("handle calloc fail");
- free(evas_ops);
- return NULL;
- }
- watcher_evas_h->img_type = -1;
- watcher_evas_h->ops = evas_ops;
- watcher_evas_h->data = data;
- watcher_evas_h->watcher_h = screen_connector_watcher_create_handle(rid_str, pid, &watcher_ops, watcher_evas_h);
- screen_connector_watcher_set_resource_id(watcher_evas_h->watcher_h, res_id);
- screen_connector_watcher_redirect_surface(watcher_evas_h->watcher_h);
-
- return watcher_evas_h;
-}
-
-EXPORT_API int screen_connector_watcher_evas_get_rid(Evas_Object *obj, int *resource_id)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
-
- watcher_evas_h = (screen_connector_watcher_evas_h)g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("unknown object.");
- return -1;
- }
- *resource_id = screen_connector_watcher_get_resource_id(watcher_evas_h->watcher_h);
-
- return 0;
-}
-
-EXPORT_API int screen_connector_watcher_evas_get_pid(Evas_Object *obj, int *pid)
-{
- screen_connector_watcher_evas_h watcher_evas_h;
- int watcher_pid;
-
- watcher_evas_h = (screen_connector_watcher_evas_h)g_hash_table_lookup(__watcher_tbl, obj);
- if (!watcher_evas_h) {
- LOGE("unknown object.");
+ LOGE("watcher_evas_h is NULL");
return -1;
}
- watcher_pid = screen_connector_watcher_get_pid(watcher_evas_h->watcher_h);
- if (watcher_pid == 0) {
- LOGE("Invalid object");
+ if (watcher_evas_h->watcher_h == NULL) {
+ LOGE("watcher_h is NULL");
return -1;
}
- *pid = watcher_pid;
-
- return 0;
+ return screen_connector_watcher_update(watcher_evas_h->watcher_h, instance_id);
}
+