merged with private

diff --git a/include/appcore-common.h b/include/appcore-common.h
index b006821..cd61e01 100755 (executable)
--- 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 (<I>errno</I> set)
+ *
+ * @pre None
+ * @post None.
+ * @remarks None.
+ *
+ * @par Sample code:
+ * @code
+#include <appcore-common.h>
+
+...
+
+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 (executable)
--- 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 (executable)
--- 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 (executable)
--- 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 (executable)
--- 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)
 {