src/lockd-window-mgr.c

   1  /*
   2   * Copyright 2012  Samsung Electronics Co., Ltd
   3   *
   4   * Licensed under the Flora License, Version 1.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7   *
   8   *     http://www.tizenopensource.org/license
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16
  17
  18
  19 #include <Elementary.h>
  20 #include <Ecore_X.h>
  21 #include <utilX.h>
  22 #include <ui-gadget.h>
  23 #include <vconf.h>
  24 #include <bundle.h>
  25 #include <appcore-efl.h>
  26 #include <app.h>
  27
  28 #include "lockd-debug.h"
  29 #include "lockd-window-mgr.h"
  30
  31 #define PACKAGE                         "starter"
  32 #define SOS_KEY_COUNT           3
  33 #define SOS_KEY_INTERVAL        0.5
  34
  35 struct _lockw_data {
  36         Evas_Object *main_win;
  37         Evas_Object *main_layout;
  38
  39         Ecore_X_Window lock_x_window;
  40
  41         Ecore_Event_Handler *h_keydown;
  42         Ecore_Event_Handler *h_wincreate;
  43         Ecore_Event_Handler *h_winshow;
  44
  45         Ecore_Timer *pTimerId;
  46         int volume_key_cnt;
  47
  48         int phone_lock_state;
  49         int phone_lock_app_pid;
  50 };
  51
  52 static Eina_Bool _lockd_window_key_down_cb(void *data, int type, void *event)
  53 {
  54         Ecore_Event_Key *ev = event;
  55
  56         LOCKD_DBG("Key Down CB : %s", ev->keyname);
  57
  58         return ECORE_CALLBACK_PASS_ON;
  59 }
  60
  61 static int
  62 _lockd_window_check_validate_rect(Ecore_X_Display * dpy, Ecore_X_Window window)
  63 {
  64         Ecore_X_Window root;
  65         Ecore_X_Window child;
  66
  67         int rel_x = 0;
  68         int rel_y = 0;
  69         int abs_x = 0;
  70         int abs_y = 0;
  71
  72         unsigned int width = 0;
  73         unsigned int height = 0;
  74         unsigned int border = 0;
  75         unsigned int depth = 0;
  76
  77         Eina_Bool ret = FALSE;
  78
  79         root = ecore_x_window_root_first_get();
  80
  81         if (XGetGeometry
  82             (dpy, window, &root, &rel_x, &rel_y, &width, &height, &border,
  83              &depth)) {
  84                 if (XTranslateCoordinates
  85                     (dpy, window, root, 0, 0, &abs_x, &abs_y, &child)) {
  86                         if ((abs_x - border) >= 480 || (abs_y - border) >= 800
  87                             || (width + abs_x) <= 0 || (height + abs_y) <= 0) {
  88                                 ret = FALSE;
  89                         } else {
  90                                 ret = TRUE;
  91                         }
  92                 }
  93         }
  94
  95         return ret;
  96 }
  97
  98 static Window get_user_created_window(Window win)
  99 {
 100         Atom type_ret = 0;
 101         int ret, size_ret = 0;
 102         unsigned long num_ret = 0, bytes = 0;
 103         unsigned char *prop_ret = NULL;
 104         unsigned int xid;
 105         Atom prop_user_created_win;
 106
 107         prop_user_created_win =
 108             XInternAtom(ecore_x_display_get(), "_E_USER_CREATED_WINDOW", False);
 109
 110         ret =
 111             XGetWindowProperty(ecore_x_display_get(), win,
 112                                prop_user_created_win, 0L, 1L, False, 0,
 113                                &type_ret, &size_ret, &num_ret, &bytes,
 114                                &prop_ret);
 115
 116         if (ret != Success) {
 117                 if (prop_ret)
 118                         XFree((void *)prop_ret);
 119                 return win;
 120         } else if (!prop_ret) {
 121                 return win;
 122         }
 123
 124         memcpy(&xid, prop_ret, sizeof(unsigned int));
 125         XFree((void *)prop_ret);
 126
 127         return xid;
 128
 129 }
 130
 131 Eina_Bool
 132 lockd_window_set_window_property(lockw_data * data, int lock_app_pid,
 133                                  void *event)
 134 {
 135         Ecore_X_Event_Window_Create *e = event;
 136         Ecore_X_Window user_window = 0;
 137         lockw_data *lockw = (lockw_data *) data;
 138         int pid = 0;
 139
 140         if (!lockw) {
 141                 return EINA_FALSE;
 142         }
 143         LOCKD_DBG("%s, %d", __func__, __LINE__);
 144
 145         user_window = get_user_created_window((Window) (e->win));
 146
 147         int ret = ecore_x_netwm_pid_get(user_window, &pid);
 148         if(ret != 1) {
 149                 return EINA_FALSE;
 150         }
 151
 152         LOCKD_DBG("Check PID(%d) window. (lock_app_pid : %d)\n", pid,
 153                   lock_app_pid);
 154
 155         if (lock_app_pid == pid) {
 156                 if (_lockd_window_check_validate_rect
 157                     (ecore_x_display_get(), user_window) == TRUE) {
 158                         lockw->lock_x_window = user_window;
 159                         LOCKD_DBG
 160                             ("This is lock application. Set window property. win id : %x",
 161                              user_window);
 162
 163                         ecore_x_icccm_name_class_set(user_window, "LOCK_SCREEN",
 164                                                      "LOCK_SCREEN");
 165                         ecore_x_netwm_window_type_set(user_window,
 166                                                       ECORE_X_WINDOW_TYPE_NOTIFICATION);
 167                         utilx_set_system_notification_level(ecore_x_display_get
 168                                                             (), user_window,
 169                                                             UTILX_NOTIFICATION_LEVEL_NORMAL);
 170                         utilx_set_window_opaque_state(ecore_x_display_get(),
 171                                                       user_window,
 172                                                       UTILX_OPAQUE_STATE_ON);
 173                         return EINA_TRUE;
 174                 }
 175         }
 176         return EINA_FALSE;
 177 }
 178
 179 Eina_Bool
 180 lockd_window_set_window_effect(lockw_data * data, int lock_app_pid, void *event)
 181 {
 182         Ecore_X_Event_Window_Create *e = event;
 183         Ecore_X_Window user_window = 0;
 184         int pid = 0;
 185
 186         user_window = get_user_created_window((Window) (e->win));
 187         int ret = ecore_x_netwm_pid_get(user_window, &pid);
 188         if(ret != 1) {
 189                 return;
 190         }
 191
 192         LOCKD_DBG("%s, %d", __func__, __LINE__);
 193
 194         LOCKD_DBG("PID(%d) window created. (lock_app_pid : %d)\n", pid,
 195                   lock_app_pid);
 196
 197         if (lock_app_pid == pid) {
 198                 if (_lockd_window_check_validate_rect
 199                     (ecore_x_display_get(), user_window) == TRUE) {
 200                         LOCKD_DBG
 201                             ("This is lock application. Disable window effect. win id : %x\n",
 202                              user_window);
 203
 204                         utilx_set_window_effect_state(ecore_x_display_get(),
 205                                                       user_window, 0);
 206                         return EINA_TRUE;
 207                 }
 208         }
 209         return EINA_FALSE;
 210 }
 211
 212 void lockd_window_set_phonelock_pid(lockw_data * data, int phone_lock_pid)
 213 {
 214         lockw_data *lockw = (lockw_data *) data;
 215
 216         if (!lockw) {
 217                 return;
 218         }
 219         LOCKD_DBG("%s, %d", __func__, __LINE__);
 220         lockw->phone_lock_app_pid = phone_lock_pid;
 221         LOCKD_DBG("%s, %d, lockw->phone_lock_app_pid = %d", __func__, __LINE__,
 222                   lockw->phone_lock_app_pid);
 223 }
 224
 225 void
 226 lockd_window_mgr_ready_lock(void *data, lockw_data * lockw,
 227                             Eina_Bool(*create_cb) (void *, int, void *),
 228                             Eina_Bool(*show_cb) (void *, int, void *))
 229 {
 230         if (lockw == NULL) {
 231                 LOCKD_ERR("lockw is NULL.");
 232                 return;
 233         }
 234         lockw->h_wincreate =
 235             ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CREATE, create_cb,
 236                                     data);
 237         lockw->h_winshow =
 238             ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW, show_cb, data);
 239
 240         lockw->volume_key_cnt = 0;
 241
 242         lockw->h_keydown =
 243             ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
 244                                     _lockd_window_key_down_cb, lockw);
 245 }
 246
 247 void lockd_window_mgr_finish_lock(lockw_data * lockw)
 248 {
 249         Ecore_X_Window xwin;
 250
 251         if (lockw == NULL) {
 252                 LOCKD_ERR("lockw is NULL.");
 253                 return;
 254         }
 255         if (lockw->h_wincreate != NULL) {
 256                 ecore_event_handler_del(lockw->h_wincreate);
 257                 lockw->h_wincreate = NULL;
 258         }
 259         if (lockw->h_winshow != NULL) {
 260                 ecore_event_handler_del(lockw->h_winshow);
 261                 lockw->h_winshow = NULL;
 262         }
 263
 264         ecore_x_pointer_ungrab();
 265
 266         if (lockw->h_keydown != NULL) {
 267                 ecore_event_handler_del(lockw->h_keydown);
 268                 lockw->h_keydown = NULL;
 269         }
 270 }
 271
 272 lockw_data *lockd_window_init(void)
 273 {
 274         lockw_data *lockw = NULL;
 275         long pid;
 276
 277         lockw = (lockw_data *) malloc(sizeof(lockw_data));
 278         memset(lockw, 0x0, sizeof(lockw_data));
 279
 280         pid = getpid();
 281
 282         return lockw;
 283 }