src/lockd-process-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 <vconf.h>
  20 #include <vconf-keys.h>
  21
  22 #include <aul.h>
  23
  24 #include "lockd-debug.h"
  25 #include "lockd-process-mgr.h"
  26 #include "starter-vconf.h"
  27
  28 #define LOCKD_DEFAULT_PKG_NAME "org.tizen.livebox-lock"
  29 #define LOCKD_DEFAULT_LOCKSCREEN "org.tizen.draglock"
  30 #define LOCKD_PHONE_LOCK_PKG_NAME "org.tizen.phone-lock"
  31 #define RETRY_MAXCOUNT 30
  32 #define RELAUNCH_INTERVAL 100*1000
  33
  34 static char *_lockd_process_mgr_get_pkgname(void)
  35 {
  36         char *pkgname = NULL;
  37
  38         pkgname = vconf_get_str(VCONF_PRIVATE_LOCKSCREEN_PKGNAME);
  39
  40         LOCKD_DBG("pkg name is %s", pkgname);
  41
  42         if (pkgname == NULL) {
  43                 return LOCKD_DEFAULT_PKG_NAME;
  44         }
  45
  46         return pkgname;
  47 }
  48
  49 int lockd_process_mgr_restart_lock(int phone_lock_state)
  50 {
  51         char *lock_app_path = NULL;
  52         int pid;
  53         bundle *b = NULL;
  54
  55         lock_app_path = _lockd_process_mgr_get_pkgname();
  56
  57         b = bundle_create();
  58
  59         if (phone_lock_state == 1)
  60                 bundle_add(b, "mode", "lock");
  61         else
  62                 bundle_add(b, "mode", "normal");
  63
  64         pid = aul_launch_app(lock_app_path, b);
  65
  66         LOCKD_DBG("Reset : aul_launch_app(%s, NULL), pid = %d", lock_app_path,
  67                   pid);
  68
  69         if (b)
  70                 bundle_free(b);
  71
  72         return pid;
  73 }
  74
  75 int
  76 lockd_process_mgr_start_lock(void *data, int (*dead_cb) (int, void *),
  77                              int phone_lock_state)
  78 {
  79         char *lock_app_path = NULL;
  80         int pid;
  81         bundle *b = NULL;
  82
  83         lock_app_path = _lockd_process_mgr_get_pkgname();
  84
  85         b = bundle_create();
  86
  87         if (phone_lock_state == 1)
  88                 bundle_add(b, "mode", "lock");
  89         else
  90                 bundle_add(b, "mode", "normal");
  91
  92         int i;
  93         for (i=0; i<RETRY_MAXCOUNT; i++)
  94         {
  95                 pid = aul_launch_app(lock_app_path, b);
  96
  97                 LOCKD_DBG("aul_launch_app(%s), pid = %d", lock_app_path, pid);
  98
  99                 if (pid == AUL_R_ECOMM) {
 100                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 101                         usleep(RELAUNCH_INTERVAL);
 102                 } else if (pid == AUL_R_ERROR) {
 103                         LOCKD_DBG("launch[%s] is failed, launch default lock screen", lock_app_path);
 104                         pid = aul_launch_app(LOCKD_DEFAULT_LOCKSCREEN, b);
 105                         if (pid >0) {
 106                                 if (b)
 107                                         bundle_free(b);
 108                                 return pid;
 109                         }
 110                 } else {
 111                         if (b)
 112                                 bundle_free(b);
 113                         return pid;
 114                 }
 115         }
 116         LOCKD_DBG("Relaunch lock application failed..!!");
 117         return pid;
 118 }
 119
 120 int lockd_process_mgr_start_normal_lock(void *data, int (*dead_cb) (int, void *))
 121 {
 122         int pid = 0;
 123
 124         int i;
 125         for (i=0; i<RETRY_MAXCOUNT; i++)
 126         {
 127                 pid = aul_launch_app(LOCKD_DEFAULT_PKG_NAME, NULL);
 128
 129                 LOCKD_DBG("aul_launch_app(%s), pid = %d", LOCKD_DEFAULT_PKG_NAME, pid);
 130
 131                 if (pid == AUL_R_ECOMM) {
 132                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 133                         usleep(RELAUNCH_INTERVAL);
 134                 } else if (pid == AUL_R_ERROR) {
 135                         LOCKD_DBG("launch[%s] is failed, launch default lock screen", LOCKD_DEFAULT_PKG_NAME);
 136                         pid = aul_launch_app(LOCKD_DEFAULT_LOCKSCREEN, NULL);
 137                         if (pid >0) {
 138                                 return pid;
 139                         }
 140                 } else {
 141                         return pid;
 142                 }
 143         }
 144         LOCKD_DBG("Relaunch lock application failed..!!");
 145         return pid;
 146 }
 147
 148 int lockd_process_mgr_start_phone_lock(void)
 149 {
 150         int pid = 0;
 151         bundle *b = NULL;
 152
 153         b = bundle_create();
 154
 155 #if 1
 156         bundle_add(b, "pwlock_type", "running_lock");
 157         bundle_add(b, "window_type", "alpha");
 158
 159         pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 160         LOCKD_DBG("aul_launch_app(%s, b), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME,
 161                   pid);
 162 #else
 163         bundle_add(b, "mode", "lock");
 164
 165         pid = aul_launch_app(LOCKD_DEFAULT_PKG_NAME, b);
 166
 167         LOCKD_DBG("aul_launch_app(%s, NULL), pid = %d", LOCKD_DEFAULT_PKG_NAME,
 168                   pid);
 169 #endif
 170         if (b)
 171                 bundle_free(b);
 172
 173         return pid;
 174 }
 175
 176 int lockd_process_mgr_start_recovery_lock(void)
 177 {
 178         int pid = 0;
 179         bundle *b = NULL;
 180
 181         b = bundle_create();
 182
 183         bundle_add(b, "pwlock_type", "recovery_lock");
 184         bundle_add(b, "window_type", "alpha");
 185
 186         pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 187         LOCKD_DBG("aul_launch_app(%s, b), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME,
 188                   pid);
 189         if (b)
 190                 bundle_free(b);
 191
 192         return pid;
 193 }
 194
 195 void
 196 lockd_process_mgr_terminate_lock_app(int lock_app_pid, int state)
 197 {
 198         LOCKD_DBG
 199             ("lockd_process_mgr_terminate_lock_app,  state:%d\n",
 200              state);
 201
 202         if (state == 1) {
 203                 if (lock_app_pid != 0) {
 204                         LOCKD_DBG("Terminate Lock app(pid : %d)", lock_app_pid);
 205                         aul_terminate_pid(lock_app_pid);
 206                 }
 207         }
 208 }
 209
 210 void lockd_process_mgr_terminate_phone_lock(int phone_lock_pid)
 211 {
 212         LOCKD_DBG("Terminate Phone Lock(pid : %d)", phone_lock_pid);
 213         aul_terminate_pid(phone_lock_pid);
 214 }
 215
 216 int lockd_process_mgr_check_lock(int pid)
 217 {
 218         char buf[128];
 219         LOCKD_DBG("%s, %d", __func__, __LINE__);
 220         /* Check pid is invalid. */
 221         if (aul_app_get_pkgname_bypid(pid, buf, sizeof(buf)) < 0) {
 222                 LOCKD_DBG("no such pkg by pid %d\n", pid);
 223         } else {
 224                 LOCKD_DBG("app pkgname = %s, pid = %d\n", buf, pid);
 225                 if (aul_app_is_running(buf) == TRUE) {
 226                         LOCKD_DBG("%s [pid = %d] is running\n", buf, pid);
 227                         return TRUE;
 228                 } else {
 229                         LOCKD_DBG("[pid = %d] is exist but %s is not running\n",
 230                                   pid, buf);
 231                 }
 232         }
 233         return FALSE;
 234 }