From 348873fac4207f76094cf0fff07310cd906e71a9 Mon Sep 17 00:00:00 2001 From: Jaeho Lee Date: Fri, 10 Feb 2012 16:59:35 +0900 Subject: [PATCH] merged with private --- include/appcore-common.h | 40 ++++++++ src/appcore-X.c | 34 ++++--- src/appcore-efl.c | 3 +- src/appcore-rotation.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++ src/appcore.c | 26 ++++- 5 files changed, 345 insertions(+), 15 deletions(-) diff --git a/include/appcore-common.h b/include/appcore-common.h index b006821..cd61e01 100755 --- a/include/appcore-common.h +++ b/include/appcore-common.h @@ -666,6 +666,46 @@ void appcore_exit(void); */ int appcore_flush_memory(void); +/** + * @par Description: + * Set a open callback + * Only when application is running, if aul_open api is called, then this callback function is called. + * If your open_cb function return -1, then appcore doesn't raise window. + * + * @param[in] cb callback function + * @param[in] data callback function data + * + * @return 0 on success, -1 on error (errno set) + * + * @pre None + * @post None. + * @remarks None. + * + * @par Sample code: + * @code +#include + +... + +static int _open_cb(enum appcore_rm, void *); + +... +{ + int r; + + r = appcore_set_open_cb(_open_cb, data); + if (r == -1) { + // add exception handling + } + + ... +} + * @endcode + * + */ +int appcore_set_open_cb(int (*cb) (void *), void *data); + + #ifdef __cplusplus } #endif diff --git a/src/appcore-X.c b/src/appcore-X.c index f1148d5..2a2e6fb 100755 --- a/src/appcore-X.c +++ b/src/appcore-X.c @@ -32,6 +32,7 @@ #include "appcore-internal.h" static Atom a_pid; +static Atom a_active_win; static pid_t __get_win_pid(Display *d, Window win) { @@ -97,19 +98,26 @@ static int __find_win(Display *d, Window *win, pid_t pid) static int __raise_win(Display *d, Window win) { - XWindowAttributes attr; - - XMapRaised(d, win); - XGetWindowAttributes(d, win, &attr); - _retv_if(attr.map_state != IsViewable, -1); - - /* - * Window Manger sets the Input Focus. - * Appcore does not need to enforce this anymore. - * - * XSetInputFocus(d, win, RevertToPointerRoot, CurrentTime); - * - */ + XEvent xev; + Window root; + + if (!a_active_win) + a_active_win = XInternAtom(d, "_NET_ACTIVE_WINDOW", False); + + root = XDefaultRootWindow(d); + + xev.xclient.type = ClientMessage; + xev.xclient.display = d; + xev.xclient.window = win; + xev.xclient.message_type = a_active_win; + xev.xclient.format = 32; + xev.xclient.data.l[0] = 1; + xev.xclient.data.l[1] = CurrentTime; + xev.xclient.data.l[2] = 0; + xev.xclient.data.l[3] = 0; + xev.xclient.data.l[4] = 0; + XSendEvent(d, root, False, + SubstructureRedirectMask | SubstructureNotifyMask, &xev); return 0; } diff --git a/src/appcore-efl.c b/src/appcore-efl.c index 92defb4..3498553 100755 --- a/src/appcore-efl.c +++ b/src/appcore-efl.c @@ -187,7 +187,8 @@ static void __do_app(enum app_event event, void *data, bundle * b) if (ui->ops->pause) r = ui->ops->pause(ui->ops->data); ui->state = AS_PAUSED; - __appcore_timer_add(ui); + if(r >= 0) + __appcore_timer_add(ui); } /* TODO : rotation stop */ r = appcore_pause_rotation_cb(); diff --git a/src/appcore-rotation.c b/src/appcore-rotation.c index 1417fa8..32ec0e9 100755 --- a/src/appcore-rotation.c +++ b/src/appcore-rotation.c @@ -66,29 +66,286 @@ static struct rot_evt re_to_rm[] = { }, }; +static enum appcore_rm __get_mode(int event_data) +{ + int i; + enum appcore_rm m; + + m = APPCORE_RM_UNKNOWN; + + for (i = 0; i < sizeof(re_to_rm) / sizeof(re_to_rm[0]); i++) { + if (re_to_rm[i].re == event_data) { + m = re_to_rm[i].rm; + break; + } + } + + return m; +} + +static void __changed_cb(unsigned int event_type, sensor_event_data_t *event, + void *data) +{ + int *cb_event_data; + enum appcore_rm m; + + if (rot.lock) + return; + + if (event_type != ACCELEROMETER_EVENT_ROTATION_CHECK) { + errno = EINVAL; + return; + } + + cb_event_data = (int *)(event->event_data); + + m = __get_mode(*cb_event_data); + + _DBG("[APP %d] Rotation: %d -> %d", getpid(), rot.mode, m); + + if (rot.callback) { + if (rot.cb_set && rot.mode != m) { + rot.callback(m, data); + rot.mode = m; + } + } +} + +static void __lock_cb(keynode_t *node, void *data) +{ + int r; + enum appcore_rm m; + + rot.lock = vconf_keynode_get_bool(node); + + if (rot.lock) { + _DBG("[APP %d] Rotation locked", getpid()); + return; + } + + _DBG("[APP %d] Rotation unlocked", getpid()); + if (rot.callback) { + if (rot.cb_set) { + r = appcore_get_rotation_state(&m); + _DBG("[APP %d] Rotmode prev %d -> curr %d", getpid(), + rot.mode, m); + if (!r && rot.mode != m) { + rot.callback(m, data); + rot.mode = m; + } + } + } +} + +static void __add_rotlock(void *data) +{ + int r; + int lock; + + lock = 0; + r = vconf_get_bool(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &lock); + if (r) { + _DBG("[APP %d] Rotation vconf get bool failed", getpid()); + } + + rot.lock = lock; + + vconf_notify_key_changed(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, __lock_cb, + data); +} + +static void __del_rotlock(void) +{ + vconf_ignore_key_changed(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, __lock_cb); + rot.lock = 0; +} EXPORT_API int appcore_set_rotation_cb(int (*cb) (enum appcore_rm, void *), void *data) { + int r; + int handle; + + if (cb == NULL) { + errno = EINVAL; + return -1; + } + + if (rot.callback != NULL) { + errno = EALREADY; + return -1; + } + + handle = sf_connect(ACCELEROMETER_SENSOR); + if (handle < 0) { + _ERR("sf_connect failed: %d", handle); + return -1; + } + + r = sf_register_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK, + NULL, __changed_cb, data); + if (r < 0) { + _ERR("sf_register_event failed: %d", r); + sf_disconnect(handle); + return -1; + } + + rot.cb_set = 1; + rot.callback = cb; + rot.cbdata = data; + + r = sf_start(handle, 0); + if (r < 0) { + _ERR("sf_start failed: %d", r); + sf_unregister_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK); + rot.callback = NULL; + rot.cbdata = NULL; + rot.cb_set = 0; + rot.sf_started = 0; + sf_disconnect(handle); + return -1; + } + rot.sf_started = 1; + + rot.handle = handle; + __add_rotlock(data); + return 0; } EXPORT_API int appcore_unset_rotation_cb(void) { + int r; + + _retv_if(rot.callback == NULL, 0); + + __del_rotlock(); + + if (rot.cb_set) { + r = sf_unregister_event(rot.handle, + ACCELEROMETER_EVENT_ROTATION_CHECK); + if (r < 0) { + _ERR("sf_unregister_event failed: %d", r); + return -1; + } + rot.cb_set = 0; + } + rot.callback = NULL; + rot.cbdata = NULL; + + if (rot.sf_started == 1) { + r = sf_stop(rot.handle); + if (r < 0) { + _ERR("sf_stop failed: %d", r); + return -1; + } + rot.sf_started = 0; + } + + r = sf_disconnect(rot.handle); + if (r < 0) { + _ERR("sf_disconnect failed: %d", r); + return -1; + } + rot.handle = -1; + return 0; } EXPORT_API int appcore_get_rotation_state(enum appcore_rm *curr) { + int r; + unsigned long event; + + if (curr == NULL) { + errno = EINVAL; + return -1; + } + + r = sf_check_rotation(&event); + if (r < 0) { + _ERR("sf_check_rotation failed: %d", r); + *curr = APPCORE_RM_UNKNOWN; + return -1; + } + + *curr = __get_mode(event); + return 0; } EXPORT_API int appcore_pause_rotation_cb(void) { + int r; + + _retv_if(rot.callback == NULL, 0); + _DBG("[APP %d] appcore_pause_rotation_cb is called", getpid()); + + __del_rotlock(); + + if (rot.cb_set) { + r = sf_unregister_event(rot.handle, + ACCELEROMETER_EVENT_ROTATION_CHECK); + if (r < 0) { + _ERR("sf_unregister_event in appcore_internal_sf_stop failed: %d", r); + return -1; + } + rot.cb_set = 0; + } + + if (rot.sf_started == 1) { + r = sf_stop(rot.handle); + if (r < 0) { + _ERR("sf_stop in appcore_internal_sf_stop failed: %d", + r); + return -1; + } + rot.sf_started = 0; + } + return 0; } EXPORT_API int appcore_resume_rotation_cb(void) { + int r; + enum appcore_rm m; + + _retv_if(rot.callback == NULL, 0); + _DBG("[APP %d] appcore_resume_rotation_cb is called", getpid()); + + if (rot.cb_set == 0) { + r = sf_register_event(rot.handle, + ACCELEROMETER_EVENT_ROTATION_CHECK, NULL, + __changed_cb, rot.cbdata); + if (r < 0) { + _ERR("sf_register_event in appcore_internal_sf_start failed: %d", r); + return -1; + } + rot.cb_set = 1; + } + + if (rot.sf_started == 0) { + r = sf_start(rot.handle, 0); + if (r < 0) { + _ERR("sf_start in appcore_internal_sf_start failed: %d", + r); + sf_unregister_event(rot.handle, + ACCELEROMETER_EVENT_ROTATION_CHECK); + rot.cb_set = 0; + return -1; + } + rot.sf_started = 1; + } + + __add_rotlock(rot.cbdata); + + r = appcore_get_rotation_state(&m); + _DBG("[APP %d] Rotmode prev %d -> curr %d", getpid(), rot.mode, m); + if (!r && rot.mode != m && rot.lock == 0) { + rot.callback(m, rot.cbdata); + rot.mode = m; + } + return 0; } diff --git a/src/appcore.c b/src/appcore.c index 41a1060..13cbc31 100755 --- a/src/appcore.c +++ b/src/appcore.c @@ -81,6 +81,13 @@ struct evt_ops { int (*vcb_post) (void *, void *); }; +struct open_s { + int (*callback) (void *); + void *cbdata; +}; + +static struct open_s open; + static int __app_terminate(void *data); static int __app_resume(void *data); static int __app_reset(void *data, bundle *k); @@ -419,6 +426,8 @@ static int __del_vconf(void) static int __aul_handler(aul_type type, bundle *b, void *data) { + int ret; + switch (type) { case AUL_START: _DBG("[APP %d] AUL event: AUL_START", _pid); @@ -426,7 +435,13 @@ static int __aul_handler(aul_type type, bundle *b, void *data) break; case AUL_RESUME: _DBG("[APP %d] AUL event: AUL_RESUME", _pid); - __app_resume(data); + if(open.callback) { + ret = open.callback(open.cbdata); + if (ret == 0) + __app_resume(data); + } else { + __app_resume(data); + } break; case AUL_TERMINATE: _DBG("[APP %d] AUL event: AUL_TERMINATE", _pid); @@ -447,6 +462,15 @@ static void __clear(struct appcore *ac) memset(ac, 0, sizeof(struct appcore)); } +EXPORT_API int appcore_set_open_cb(int (*cb) (void *), + void *data) +{ + open.callback = cb; + open.cbdata = data; + + return 0; +} + EXPORT_API int appcore_set_event_callback(enum appcore_event event, int (*cb) (void *), void *data) { -- 2.7.4