lock-mgr/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 #include <vconf.h>
  18 #include <vconf-keys.h>
  19
  20 #include <aul.h>
  21
  22 #include "lockd-debug.h"
  23 #include "lockd-process-mgr.h"
  24 #include "starter-vconf.h"
  25
  26 #define LOCKD_DEFAULT_PKG_NAME "org.tizen.draglock"
  27 #define LOCKD_DEFAULT_LOCKSCREEN "org.tizen.draglock"
  28 #define RETRY_MAXCOUNT 30
  29 #define RELAUNCH_INTERVAL 100*1000
  30
  31 static char *_lockd_process_mgr_get_pkgname(void)
  32 {
  33         char *pkgname = NULL;
  34
  35         pkgname = vconf_get_str(VCONF_PRIVATE_LOCKSCREEN_PKGNAME);
  36
  37         LOCKD_DBG("pkg name is %s", pkgname);
  38
  39         if (pkgname == NULL) {
  40                 return LOCKD_DEFAULT_PKG_NAME;
  41         }
  42
  43         return pkgname;
  44 }
  45
  46 int lockd_process_mgr_restart_lock(void)
  47 {
  48         char *lock_app_path = NULL;
  49         int pid;
  50         bundle *b = NULL;
  51
  52         lock_app_path = _lockd_process_mgr_get_pkgname();
  53
  54         b = bundle_create();
  55
  56         bundle_add(b, "mode", "normal");
  57
  58         pid = aul_launch_app(lock_app_path, b);
  59
  60         LOCKD_DBG("Reset : aul_launch_app(%s, NULL), pid = %d", lock_app_path,
  61                   pid);
  62
  63         if (b)
  64                 bundle_free(b);
  65
  66         return pid;
  67 }
  68
  69 int
  70 lockd_process_mgr_start_lock(void *data, int (*dead_cb) (int, void *))
  71 {
  72         char *lock_app_path = NULL;
  73         int pid;
  74         bundle *b = NULL;
  75
  76         lock_app_path = _lockd_process_mgr_get_pkgname();
  77
  78         b = bundle_create();
  79
  80         bundle_add(b, "mode", "normal");
  81
  82         int i;
  83         for (i=0; i<RETRY_MAXCOUNT; i++)
  84         {
  85                 pid = aul_launch_app(lock_app_path, b);
  86
  87                 LOCKD_DBG("aul_launch_app(%s, NULL), pid = %d", lock_app_path, pid);
  88
  89                 if (pid == AUL_R_ECOMM) {
  90                         LOCKD_DBG("Relaunch lock application [%d]times", i);
  91                         usleep(RELAUNCH_INTERVAL);
  92                 } else if (pid == AUL_R_ERROR) {
  93                         LOCKD_DBG("launch[%s] is failed, launch default lock screen", lock_app_path);
  94                         pid = aul_launch_app(LOCKD_DEFAULT_LOCKSCREEN, b);
  95                         if (pid >0) {
  96                                 aul_listen_app_dead_signal(dead_cb, data);
  97                                 if (b)
  98                                         bundle_free(b);
  99                                 return pid;
 100                         }
 101                 } else {
 102                         /* set listen and dead signal */
 103                         aul_listen_app_dead_signal(dead_cb, data);
 104                         if (b)
 105                                 bundle_free(b);
 106                         return pid;
 107                 }
 108         }
 109         LOCKD_DBG("Relaunch lock application failed..!!");
 110         return pid;
 111 }
 112
 113 void
 114 lockd_process_mgr_terminate_lock_app(int lock_app_pid, int state)
 115 {
 116         LOCKD_DBG
 117             ("lockd_process_mgr_terminate_lock_app,  state:%d\n",
 118              state);
 119
 120         if (state == 1) {
 121                 if (lock_app_pid != 0) {
 122                         LOCKD_DBG("Terminate Lock app(pid : %d)", lock_app_pid);
 123                         aul_terminate_pid(lock_app_pid);
 124                 }
 125         }
 126 }
 127
 128 int lockd_process_mgr_check_lock(int pid)
 129 {
 130         char buf[128];
 131         LOCKD_DBG("%s, %d", __func__, __LINE__);
 132
 133         if (aul_app_get_pkgname_bypid(pid, buf, sizeof(buf)) < 0) {
 134                 LOCKD_DBG("no such pkg by pid %d\n", pid);
 135         } else {
 136                 LOCKD_DBG("app pkgname = %s, pid = %d\n", buf, pid);
 137                 if (aul_app_is_running(buf) == TRUE) {
 138                         LOCKD_DBG("%s [pid = %d] is running\n", buf, pid);
 139                         return TRUE;
 140                 } else {
 141                         LOCKD_DBG("[pid = %d] is exist but %s is not running\n",
 142                                   pid, buf);
 143                 }
 144         }
 145         return FALSE;
 146 }