diff options
Diffstat (limited to 'src/lock-daemon-lite.c')
-rwxr-xr-x | src/lock-daemon-lite.c | 2181 |
1 files changed, 2181 insertions, 0 deletions
diff --git a/src/lock-daemon-lite.c b/src/lock-daemon-lite.c new file mode 100755 index 0000000..b21abdd --- /dev/null +++ b/src/lock-daemon-lite.c @@ -0,0 +1,2181 @@ +/* + * Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <Elementary.h> + +#include <vconf.h> +#include <vconf-keys.h> + +#include <glib.h> +#include <poll.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <unistd.h> +#include <sys/param.h> +#include <errno.h> +//#include <sensors.h> +#include <feedback.h> +#include <alarm.h> +#include <time.h> +#include <dd-deviced.h> +#include <dd-display.h> +#include <E_DBus.h> +#include <aul.h> + +#ifndef FEATURE_LITE +#include <context_manager.h> +#endif + +#include "lockd-debug.h" +#include "lock-daemon-lite.h" +#include "lockd-process-mgr.h" +#include "lockd-window-mgr.h" +#include "starter-util.h" +#include "menu_daemon.h" +#include "hw_key.h" +#include "lockd-bt.h" +#include "dbus-util.h" + +static int phone_lock_pid; +static int auto_lock_pid; +static bool lock_state_available = TRUE; + +struct lockd_data { + int lock_app_pid; + int phone_lock_app_pid; + int lock_type; /* -1: None, 0:Normal, 1:Security, 2:Other */ + Eina_Bool is_sensor; /* EINA_TRUE : can use sensor EINA_FALSE : cannot use */ + Eina_Bool request_recovery; + Eina_Bool back_to_app; + Eina_Bool start_ready; + lockw_data *lockw; + GPollFD *gpollfd; + Eina_Bool is_alarm; /* EINA_TRUE : can use alarm EINA_FALSE : cannot use */ + alarm_id_t alarm_id; /* -1 : None, others : set alarm */ + Eina_Bool is_first_boot; /* EINA_TRUE : first boot */ + int hall_status; /* 0: cover is closed, 1:cover is opened */ + E_DBus_Connection *hall_conn; + E_DBus_Signal_Handler *hall_handler; + E_DBus_Connection *display_conn; + E_DBus_Signal_Handler *display_handler; + +}; + + + +/* Local features*/ +#define _FEATURE_LCD_OFF_DBUS 0 //Check to apply lcd off dbus by PM part +#define _FEATURE_SCOVER 0 //Scover view + +#define VCONFKEY_LOCKSCREEN_FESTIVAL_WALLPAPER_DISPLAYING "db/lockscreen/festival_wallpaper" + + +#define PHLOCK_SOCK_PREFIX "/tmp/phlock" +#define PHLOCK_SOCK_MAXBUFF 65535 + +#define VOLUNE_APP_CMDLINE "/usr/apps/org.volume.volume/bin/volume" // LOCK_EXIT_CMD +#define PHLOCK_APP_CMDLINE "/usr/apps/org.volume.lockscreen/bin/lockscreen" //PHLOCK_UNLOCK_CMD +#define MDM_APP_CMDLINE "/usr/bin/mdm-server" //PHLOCK_LAUNCH_CMD +#define VOICE_CALL_APP_CMDLINE "/usr/apps/com.samsung.call/bin/calls" //HOME_RAISE_CMD, LOCK_SHOW_CMD +#define VIDEO_CALL_APP_CMDLINE "/usr/apps/com.samsung.vtmain/bin/vtmain" //HOME_RAISE_CMD, LOCK_SHOW_CMD +#define OMA_DRM_AGENT_CMDLINE "/usr/bin/oma-dm-agent" //PHLOCK_UNLOCK_RESET_CMD + +#define PHLOCK_UNLOCK_CMD "unlock" +#define PHLOCK_LAUNCH_CMD "launch_phone_lock" +#define PHLOCK_UNLOCK_RESET_CMD "unlock_reset" +#define HOME_RAISE_CMD "raise_homescreen" +#define LOCK_SHOW_CMD "show_lockscreen" +#define LOCK_LAUNCH_CMD "launch_lockscreen" +#define LOCK_EXIT_CMD "exit_lockscreen" + +#define LAUNCH_INTERVAL 100*1000 + +#define HALL_COVERED_STATUS 0 +#define BUS_NAME "org.tizen.system.deviced" +#define OBJECT_PATH "/Org/Tizen/System/DeviceD" +#define INTERFACE_NAME BUS_NAME +#define DEVICED_PATH_HALL OBJECT_PATH"/Hall" +#define DEVICED_INTERFACE_HALL INTERFACE_NAME".hall" +#define SIGNAL_HALL_STATE "ChangeState" +#define METHOD_GET_STATUS "getstatus" +#define DBUS_REPLY_TIMEOUT (120 * 1000) +#define DEVICED_PATH_PMQOS OBJECT_PATH"/PmQos" +#define DEVICED_INTERFACE_PMQOS INTERFACE_NAME".PmQos" +#define METHOD_PMQOS_NAME "LockScreen" +#define REQUEST_PMQOS_DURATION (2 * 1000) + +#define DEVICED_PATH_LCD_OFF OBJECT_PATH"/Display" +#define DEVICED_INTERFACE_LCD_OFF INTERFACE_NAME".display" +#define METHOD_LCD_OFF_NAME "LCDOffByPowerkey" + +#define VOLUME_PKG_NAME "org.tizen.volume" +#define WALLPAPER_UI_SERVICE_PKG_NAME "com.samsung.wallpaper-ui-service" +#define SHOW_LOCK "show_lock" +#define ISTRUE "TRUE" +#define SMART_ALERT_INTERVAL 0.5 + +#define PASSWORD_LOCK_PROGRESS "/tmp/.passwordlock" +static int checkfd = 0; + +enum { + LOCK_TYPE_NONE = -1, + LOCK_TYPE_NORMAL = 0, + LOCK_TYPE_SECURITY, + LOCK_TYPE_AUTO_LOCK, + LOCK_TYPE_OTHER, + LOCK_TYPE_MAX +}; + +static int lockd_launch_app_lockscreen_lite(struct lockd_data *lockd); +static int lockd_launch_app_other_lockscreen(struct lockd_data *lockd); +static void lockd_unlock_other_lockscreen(struct lockd_data *lockd); +static void lockd_init_vconf(struct lockd_data *lockd); +static void lockd_fini_vconf(struct lockd_data *lockd); +static void _lockd_check_ongoing(bool ongoing); +#if 0 +static Eina_Bool lockd_start_sensor(void *data); +static void lockd_stop_sensor(void *data); +#endif + +static void _lockd_set_lock_state(int lock_state) +{ + LOCKD_DBG("%s, %d, %d", __func__, __LINE__, lock_state); + if(lock_state < VCONFKEY_IDLE_UNLOCK || lock_state > VCONFKEY_IDLE_LAUNCHING_LOCK) { + LOCKD_ERR("Can't set lock_state : %d out of range", lock_state); + } else { + vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, lock_state); + } +} + +static void _lockd_play_sound(bool unlock) +{ + int ret = -1, val = 0; + ret = vconf_get_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, &val); + + if(ret == 0 && val == 1) { + feedback_initialize(); + feedback_play_type(FEEDBACK_TYPE_SOUND, unlock ? FEEDBACK_PATTERN_UNLOCK : FEEDBACK_PATTERN_LOCK); + } +} + +int lockd_get_lock_type(void) +{ + int lock_type = 0; + int ret = 0; + + vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type); + + if (lock_type == SETTING_SCREEN_LOCK_TYPE_NONE) { + ret = LOCK_TYPE_NONE; + } else if (lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD || + lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || + lock_type == SETTING_SCREEN_LOCK_TYPE_FINGERPRINT || + lock_type == SETTING_SCREEN_LOCK_TYPE_FACE_AND_VOICE) { + ret = LOCK_TYPE_SECURITY; + } else if (lock_type == SETTING_SCREEN_LOCK_TYPE_SWIPE || + lock_type == SETTING_SCREEN_LOCK_TYPE_MOTION) { + ret = LOCK_TYPE_NORMAL; + } else if (lock_type == SETTING_SCREEN_LOCK_TYPE_AUTO_LOCK) { + ret = LOCK_TYPE_AUTO_LOCK; + } else { + ret = LOCK_TYPE_OTHER; + } + + LOCKD_DBG("lockd_get_lock_type ret(%d), lock_type (%d)", ret, lock_type); + + return ret; +} + +static int _lockd_append_variant(DBusMessageIter *iter, const char *sig, char *param[]) +{ + char *ch; + int i; + int int_type; + uint64_t int64_type; + + if (!sig || !param) + return 0; + + for (ch = (char*)sig, i = 0; *ch != '\0'; ++i, ++ch) { + switch (*ch) { + case 'i': + int_type = atoi(param[i]); + dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &int_type); + break; + case 'u': + int_type = atoi(param[i]); + dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &int_type); + break; + case 't': + int64_type = atoi(param[i]); + dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &int64_type); + break; + case 's': + dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, ¶m[i]); + break; + default: + return -EINVAL; + } + } + + return 0; +} + +DBusMessage *_lockd_invoke_dbus_method_async(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[]) +{ + DBusConnection *conn; + DBusMessage *msg; + DBusMessageIter iter; + DBusMessage *reply; + DBusError err; + int r; + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL); + if (!conn) { + LOCKD_ERR("dbus_bus_get error"); + return NULL; + } + + msg = dbus_message_new_method_call(dest, path, interface, method); + if (!msg) { + LOCKD_ERR("dbus_message_new_method_call(%s:%s-%s)", path, interface, method); + return NULL; + } + + dbus_message_iter_init_append(msg, &iter); + r = _lockd_append_variant(&iter, sig, param); + if (r < 0) { + LOCKD_ERR("append_variant error(%d)", r); + return NULL; + } + + r = dbus_connection_send(conn, msg, NULL); + dbus_message_unref(msg); + if (r != TRUE) { + LOCKD_ERR("dbus_connection_send error(%s:%s:%s-%s)", dest, path, interface, method); + return -ECOMM; + } + LOCKD_DBG("dbus_connection_send, ret=%d", r); + return NULL; +} + +DBusMessage *_lockd_invoke_dbus_method_sync(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[]) +{ + DBusConnection *conn; + DBusMessage *msg; + DBusMessageIter iter; + DBusMessage *reply; + DBusError err; + int r; + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL); + if (!conn) { + LOCKD_ERR("dbus_bus_get error"); + return NULL; + } + + msg = dbus_message_new_method_call(dest, path, interface, method); + if (!msg) { + LOCKD_ERR("dbus_message_new_method_call(%s:%s-%s)", path, interface, method); + return NULL; + } + + dbus_message_iter_init_append(msg, &iter); + r = _lockd_append_variant(&iter, sig, param); + if (r < 0) { + LOCKD_ERR("append_variant error(%d)", r); + return NULL; + } + + dbus_error_init(&err); + + reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_REPLY_TIMEOUT, &err); + if (!reply) { + LOCKD_ERR("dbus_connection_send error(No reply)"); + } + + if (dbus_error_is_set(&err)) { + LOCKD_ERR("dbus_connection_send error(%s:%s)", err.name, err.message); + reply = NULL; + } + + dbus_message_unref(msg); + dbus_error_free(&err); + + return reply; +} + +int lockd_get_hall_status(void) +{ + DBusError err; + DBusMessage *msg; + int ret, ret_val; + + LOCKD_DBG("[ == %s == ]", __func__); + msg = _lockd_invoke_dbus_method_sync(BUS_NAME, DEVICED_PATH_HALL, DEVICED_INTERFACE_HALL, + METHOD_GET_STATUS, NULL, NULL); + if (!msg) + return -EBADMSG; + + dbus_error_init(&err); + + ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID); + if (!ret) { + LOCKD_ERR("no message : [%s:%s]", err.name, err.message); + ret_val = -EBADMSG; + } + + dbus_message_unref(msg); + dbus_error_free(&err); + + LOCKD_DBG("%s-%s : %d", DEVICED_INTERFACE_HALL, METHOD_GET_STATUS, ret_val); + return ret_val; +} + +int lockd_get_lock_state(void) +{ + int idle_lock_state = VCONFKEY_IDLE_UNLOCK; + + if (vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &idle_lock_state) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + idle_lock_state = VCONFKEY_IDLE_UNLOCK; + } + LOCKD_DBG("Get lock state : %d", idle_lock_state); + return idle_lock_state; +} + +static void _lockd_on_changed_receive(void *data, DBusMessage *msg) +{ + DBusError err; + char *str; + int response; + int r; + int automatic_unlock = 0; + + struct lockd_data *lockd = (struct lockd_data *)data; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + LOCKD_DBG("hall signal is received"); + + r = dbus_message_is_signal(msg, DEVICED_INTERFACE_HALL, SIGNAL_HALL_STATE); + if (!r) { + LOCKD_ERR("dbus_message_is_signal error"); + return; + } + + LOCKD_DBG("%s - %s", DEVICED_INTERFACE_HALL, SIGNAL_HALL_STATE); + + dbus_error_init(&err); + r = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID); + if (!r) { + LOCKD_ERR("dbus_message_get_args error"); + return; + } + + LOCKD_DBG("receive data : %d", response); + lockd->hall_status = response; + +} + +static int _lockd_request_PmQos(int duration) +{ + DBusError err; + DBusMessage *msg; + int ret, ret_val; + char *arr[1]; + char val[32]; + + snprintf(val, sizeof(val), "%d", duration); + arr[0] = val; + + //msg = _lockd_invoke_dbus_method_sync(BUS_NAME, DEVICED_PATH_PMQOS, DEVICED_INTERFACE_PMQOS, + // METHOD_PMQOS_NAME, "i", arr); + msg = _lockd_invoke_dbus_method_async(BUS_NAME, DEVICED_PATH_PMQOS, DEVICED_INTERFACE_PMQOS, + METHOD_PMQOS_NAME, "i", arr); + + if (!msg) + return -EBADMSG; + + dbus_error_init(&err); + + ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID); + if (!ret) { + LOCKD_ERR("no message : [%s:%s]", err.name, err.message); + ret_val = -EBADMSG; + } + + dbus_message_unref(msg); + dbus_error_free(&err); + + LOCKD_DBG("%s-%s : %d", DEVICED_INTERFACE_PMQOS, METHOD_PMQOS_NAME, ret_val); + return ret_val; +} + +static void _lockd_delete_alarm_lite(alarm_id_t id, void * user_param) +{ + int ret_val = ALARMMGR_RESULT_SUCCESS; + LOCKD_DBG("Del alarm_id(%d)", id); + ret_val = alarmmgr_remove_alarm(id); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_enum_alarm_ids() failed"); + } +} + +static void _lockd_unset_alarms_lite(void) +{ + LOCKD_DBG("[ == %s == ]", __func__); + int ret_val = ALARMMGR_RESULT_SUCCESS; + ret_val = alarmmgr_enum_alarm_ids(_lockd_delete_alarm_lite, NULL); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_enum_alarm_ids() failed"); + } +} + +static void _lockd_lauch_other_lockscreen(alarm_id_t alarm_id, void *data) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + int ret_val = ALARMMGR_RESULT_SUCCESS; + + LOCKD_DBG("[ == %s == ], alarm_id(%d)", __func__, alarm_id); + + lockd_launch_app_other_lockscreen(lockd); + + if(alarm_id != -1) { + if(alarm_id != lockd->alarm_id) { + LOCKD_ERR("alarm ids are different callback->id(%d), lockd->alarm_id(%d)", alarm_id, lockd->alarm_id); + /* delete all registering alarm*/ + _lockd_unset_alarms_lite(); + lockd->alarm_id = -1; + } else { + ret_val = alarmmgr_remove_alarm(alarm_id); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_remove_alarm() failed"); + /* delete all registering alarm*/ + _lockd_unset_alarms_lite(); + } + lockd->alarm_id = -1; + } + } +} + +static Eina_Bool _lockd_set_alarm(int sec, void *data) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return EINA_FALSE; + } + + time_t current_time; + struct tm current_tm; + alarm_entry_t *alarm_info; + alarm_id_t alarm_id; + alarm_date_t alarm_time; + int ret_val = ALARMMGR_RESULT_SUCCESS; + + /* delete before registering alarm ids */ + if(lockd->alarm_id != -1){ + LOCKD_ERR("ad->alarm_id(%d) deleted", lockd->alarm_id); + ret_val = alarmmgr_remove_alarm(lockd->alarm_id); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_remove_alarm(%d) failed", lockd->alarm_id); + _lockd_unset_alarms_lite(); + } + lockd->alarm_id = -1; + } + + /* set alarm after sec */ + time(¤t_time); + + LOCKD_DBG("[ == %s ==], %s, after %d SEC.s alarm set", __func__, ctime(¤t_time), sec); + localtime_r(¤t_time, ¤t_tm); + + alarm_info = alarmmgr_create_alarm(); + if(alarm_info == NULL) { + LOCKD_ERR("alarmmgr_create_alarm() is failed\n"); + return EINA_FALSE; + } + + alarm_time.year = 0; + alarm_time.month = 0; + alarm_time.day = 0; + alarm_time.hour = current_tm.tm_hour; + alarm_time.min = current_tm.tm_min; + alarm_time.sec = current_tm.tm_sec + sec; + + alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, 0); + alarmmgr_set_time(alarm_info, alarm_time); + alarmmgr_set_type(alarm_info, ALARM_TYPE_VOLATILE); + + ret_val = alarmmgr_add_alarm_with_localtime(alarm_info, NULL, &alarm_id); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_add_alarm_with_localtime() failed"); + alarmmgr_free_alarm(alarm_info) ; + return EINA_FALSE; + } + + LOCKD_DBG("alarm id(%d) is set", alarm_id); + lockd->alarm_id = alarm_id; + alarmmgr_free_alarm(alarm_info) ; + + return EINA_TRUE; +} + + +#ifndef FEATURE_LITE +static Eina_Bool _lockd_play_smart_alert_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + struct lockd_data *lockd = (struct lockd_data *)data; + + feedback_initialize(); + feedback_play_type(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_REACTIVE_ALERT); + //feedback_deinitialize(); + //lockd_stop_sensor(lockd); + + return ECORE_CALLBACK_CANCEL; +} + +void _lockd_context_update_cb(int error, context_item_e context, char* context_data, void* user_data, int req_id) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + + struct lockd_data *lockd = (struct lockd_data *)user_data; + + if (error == CONTEXT_ERROR_NONE && context == CONTEXT_ITEM_MOVEMENT) { + int action = -1; + int ret = 0; + int calls = 0; + int messages = 0; + + context_context_data_get_int(context_data, CONTEXT_MOTION_ACTION, &action); + + switch (action) { + case CONTEXT_MOVEMENT_ACTION: + ret = vconf_get_int(VCONFKEY_STARTER_MISSED_CALL, &calls); + if(ret != 0) + calls = 0; + + ret = vconf_get_int(VCONFKEY_STARTER_UNREAD_MESSAGE, &messages); + if(ret != 0) + messages = 0; + + if(calls > 0 || messages > 0) { + LOCKD_WARN("[ sensor ] SMART ALERT calls = %d messages = %d", calls, messages); + ecore_timer_add(SMART_ALERT_INTERVAL, _lockd_play_smart_alert_cb, user_data); + } + break; + case CONTEXT_MOVEMENT_NONE: + break; + default: + break; + } + context_unset_changed_callback(CONTEXT_ITEM_MOVEMENT); + free(context_data); + } +} + +static Eina_Bool _lockd_smart_alert_idelr_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + + int val = -1; + struct lockd_data *lockd = (struct lockd_data *)data; + if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) { + LOCKD_ERR("Cannot get VCONFKEY_PM_STATE"); + return ECORE_CALLBACK_CANCEL; + } + + if ((val == VCONFKEY_PM_STATE_LCDOFF) || (val == VCONFKEY_PM_STATE_SLEEP)) { + LOCKD_DBG("LCD OFF ==> smart alert start"); + + int ret = 0; + int is_motion = 0; + int is_pickup = 0; + + ret = vconf_get_bool(VCONFKEY_SETAPPL_MOTION_ACTIVATION, &is_motion); + LOCKD_DBG("[ sensor ] ret = %d is_motion = %d", ret, is_motion); + if(ret == 0 && is_motion == 1) { + ret = vconf_get_bool(VCONFKEY_SETAPPL_USE_PICK_UP, &is_pickup); + LOCKD_DBG("[ sensor ] ret = %d is_pickup = %d", ret, is_pickup); + if(ret == 0 && is_pickup == 1) { + int ret = 0; + int calls = 0; + int messages = 0; + int req_id, r; + + ret = vconf_get_int(VCONFKEY_STARTER_MISSED_CALL, &calls); + if(ret != 0) + calls = 0; + + ret = vconf_get_int(VCONFKEY_STARTER_UNREAD_MESSAGE, &messages); + if(ret != 0) + messages = 0; + + if(calls > 0 || messages > 0) { + r = context_set_changed_callback(CONTEXT_ITEM_MOVEMENT, NULL, _lockd_context_update_cb, lockd, &req_id); + if (r != CONTEXT_ERROR_NONE) { + LOCKD_ERR("[ sensor ] context_set_changed_callback fail"); + } + LOCKD_WARN("[ sensor ] context_set_changed_callback, r=[%d]", r); + } + } + } + } else { + LOCKD_DBG("Not LCD OFF ==> cancel smart alert"); + } + return ECORE_CALLBACK_CANCEL; +} +#endif + + + +static Eina_Bool _lockd_sensor_idelr_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + + int val = -1; + if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) { + LOCKD_ERR("Cannot get VCONFKEY_PM_STATE"); + return ECORE_CALLBACK_CANCEL; + } + + if ((val == VCONFKEY_PM_STATE_LCDOFF) || (val == VCONFKEY_PM_STATE_SLEEP)) { + LOCKD_DBG("LCD OFF ==> sensor start"); + + int ret = 0; + int calls = 0; + int messages = 0; + + ret = vconf_get_int(VCONFKEY_STARTER_MISSED_CALL, &calls); + if(ret != 0) + calls = 0; + + ret = vconf_get_int(VCONFKEY_STARTER_UNREAD_MESSAGE, &messages); + if(ret != 0) + messages = 0; + + if(calls > 0 || messages > 0) { + if(lockd_start_sensor(data) == EINA_FALSE) { + LOCKD_ERR("smart_alert sensor start is failed"); + } + } else { + LOCKD_ERR("[ sensor ] sensor is not started calls = %d messages = %d", calls, messages); + } + } else { + LOCKD_DBG("Not LCD OFF ==> cancel sensor start"); + } + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool _lockd_alarm_idelr_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + struct lockd_data *lockd = (struct lockd_data *)data; + _lockd_unset_alarms_lite(); + lockd->alarm_id = -1; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool _lockd_launch_idelr_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + struct lockd_data *lockd = (struct lockd_data *)data; + _lockd_lauch_other_lockscreen(-1, lockd); + return ECORE_CALLBACK_CANCEL; +} + +static void _lockd_notify_pm_state_cb_lite(keynode_t * node, void *data) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + int val = -1; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + return; + } + + LOCKD_DBG("[ == %s == ] pm_state(%d)", __func__, val); + + if (val == VCONFKEY_PM_STATE_NORMAL) { + LOCKD_DBG("LCD ON"); + /* delete all alarm registering */ + LOCKD_DBG("%d", lockd->alarm_id); + + _lockd_unset_alarms_lite(); + lockd->alarm_id = -1; + + if(lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_NONE) { + LOCKD_DBG("Lockscreen type is none, unlock"); + } + } +} + +static int _show_lock_bg(void) +{ + bundle *b; + int r = 0; + LOCKD_DBG("%s, %d", __func__, __LINE__); + + if (menu_daemon_get_volume_pid() <0) { + LOCKD_DBG("volume is not running"); + return -1; + } + + b = bundle_create(); + + bundle_add(b, SHOW_LOCK, ISTRUE); + r = aul_launch_app(VOLUME_PKG_NAME, b); + if(b) { + bundle_free(b); + } + + return r; +} + +static void _lockd_notify_pm_lcdoff_cb_lite(keynode_t * node, void *data) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + int val = -1; + int lcdoff_source = vconf_keynode_get_int(node); + int accessbility_lock_time = 0; + int idle_lock_state = VCONFKEY_IDLE_UNLOCK; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + if (lcdoff_source < 0) { + LOCKD_ERR("Cannot get VCONFKEY, error (%d)", lcdoff_source); + return; + } + + LOCKD_DBG("[ %s ] LCD OFF by lcd off source(%d)", __func__, lcdoff_source); + + idle_lock_state = lockd_get_lock_state(); + + if(lcdoff_source == VCONFKEY_PM_LCDOFF_BY_POWERKEY) { + LOCKD_DBG("lcd off by powerkey"); +#if (!_FEATURE_LCD_OFF_DBUS) // move to dbus signal handler. + if (idle_lock_state == VCONFKEY_IDLE_UNLOCK) { + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SWIPE) { + display_lock_state(LCD_OFF, STAY_CUR_STATE, 0); + _lockd_request_PmQos(REQUEST_PMQOS_DURATION); + } + } + lockd_launch_app_other_lockscreen(lockd); +#endif + } else if (lcdoff_source == 3) { + LOCKD_DBG("lcd off by proximity sensor.."); + return; + } else { + LOCKD_DBG("lcd off by timeout"); + + if(idle_lock_state == VCONFKEY_IDLE_LOCK) { + LOCKD_DBG("VCONFKEY is set(not need to set alarm)"); + return; + } + + if(lockd->alarm_id != -1) { + LOCKD_ERR("Alarm is set yet (alarm_id = %d) : do nothing", lockd->alarm_id); + return; + } + + if(vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_LOCK_TIME_INT, &accessbility_lock_time) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + accessbility_lock_time = 0; + } + + if(accessbility_lock_time == 0) { + LOCKD_ERR("accessbility_lock_time is 0"); + _lockd_lauch_other_lockscreen(-1, lockd); + return; + } else { + if(lockd->is_alarm) { + LOCKD_DBG("set alarm %d sec", accessbility_lock_time); + if(_lockd_set_alarm(accessbility_lock_time, lockd) != EINA_TRUE) { + LOCKD_ERR("_lockd_set_alarm() failed"); + _lockd_lauch_other_lockscreen(-1, lockd); + } + } + else { + LOCKD_ERR("is_alarm is EINA_FALSE"); + _lockd_lauch_other_lockscreen(-1, lockd); + } + } + } +} + +static void _lockd_notify_time_changed_cb(keynode_t * node, void *data) +{ + int festival_wallpaper = 0; + LOCKD_DBG("system time chanded!!"); + + if(vconf_get_bool(VCONFKEY_LOCKSCREEN_FESTIVAL_WALLPAPER_DISPLAYING, &festival_wallpaper) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + festival_wallpaper = 0; + } + LOCKD_DBG("festival wallpaper : %d", festival_wallpaper); + if(festival_wallpaper){ + bundle *b; + b = bundle_create(); + if(b == NULL){ + LOCKD_ERR("bundle create failed.\n"); + return; + } + bundle_add(b, "popup_type", "festival"); + bundle_add(b, "festival_type", "festival_create"); + aul_launch_app(WALLPAPER_UI_SERVICE_PKG_NAME, b); + bundle_free(b); + } +} + +static void _lockd_notify_factory_mode_cb(keynode_t * node, void *data) +{ + int factory_mode = -1; + LOCKD_DBG("Factory mode Notification!!"); + + vconf_get_int(VCONFKEY_TELEPHONY_SIM_FACTORY_MODE, &factory_mode); + if (factory_mode == VCONFKEY_TELEPHONY_SIM_FACTORYMODE_ON) { + LOCKD_DBG("Factory mode ON, lock screen can't be launched..!!"); + _lockd_set_lock_state(VCONFKEY_IDLE_UNLOCK); + } +} + +static void +_lockd_notify_pwlock_state_changed_cb(keynode_t * node, void *data) +{ + LOCKD_DBG("pwlock state changed!!"); + + struct lockd_data *lockd = (struct lockd_data *)data; + int val = -1; + int pwlock_state = -1; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + pwlock_state = vconf_keynode_get_int(node); + + if(pwlock_state == VCONFKEY_PWLOCK_BOOTING_UNLOCK){ + if(checkfd){ + LOCKD_WARN("remove the progress file."); + _lockd_check_ongoing(EINA_FALSE); + } + if (vconf_ignore_key_changed + (VCONFKEY_PWLOCK_STATE, _lockd_notify_pwlock_state_changed_cb) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_PWLOCK_STATE"); + } + } +} + +static void +_lockd_notify_lock_state_cb(keynode_t * node, void *data) +{ + LOCKD_DBG("lock state changed!!"); + + struct lockd_data *lockd = (struct lockd_data *)data; + int val = -1; + int pwlock_state = -1; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + val = lockd_get_lock_state(); + vconf_get_int(VCONFKEY_PWLOCK_STATE, &pwlock_state); + + if (val == VCONFKEY_IDLE_UNLOCK) { + LOCKD_DBG("unlocked..!!"); + + if(lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD){ + if(pwlock_state == VCONFKEY_PWLOCK_BOOTING_UNLOCK){ + if(checkfd){ + LOCKD_WARN("remove the progress file."); + _lockd_check_ongoing(EINA_FALSE); + } + } + else if(pwlock_state == VCONFKEY_PWLOCK_BOOTING_LOCK){ + LOCKD_WARN("PWLOCK is not ready yet."); + if (vconf_notify_key_changed + (VCONFKEY_PWLOCK_STATE, _lockd_notify_pwlock_state_changed_cb, lockd) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT"); + } + } + } + + if (vconf_set_bool(VCONFKEY_SAT_NORMAL_PRIORITY_AVAILABLE_BOOL, EINA_FALSE) < 0) { + LOCKD_ERR("Cannot set VCONFKEY"); + } + + if (lockd->lock_app_pid > 0) { + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER) { + LOCKD_DBG("terminate lock app..!!"); + lockd_process_mgr_terminate_lock_app(lockd->lock_app_pid, 1); + lockd->lock_app_pid = 0; + } + } + }else if (val == VCONFKEY_IDLE_LOCK) { + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + } +} + +static Eina_Bool lockd_set_lock_state_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + _lockd_set_lock_state(VCONFKEY_IDLE_LOCK); + return ECORE_CALLBACK_CANCEL; +} + +static void +_lockd_notify_phone_lock_verification_cb(keynode_t * node, void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + + struct lockd_data *lockd = (struct lockd_data *)data; + int val = -1; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + if (vconf_get_bool(VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, &val) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + return; + } + + if (val == TRUE) { + /* password verified */ + /* lockd_unlock_lockscreen(lockd); */ + lockd_window_mgr_finish_lock(lockd->lockw); + _lockd_set_lock_state(VCONFKEY_IDLE_UNLOCK); + } +} + +static int lockd_app_dead_cb_lite(int pid, void *data) +{ + LOCKD_DBG("app dead cb call! (pid : %d)", pid); + + struct lockd_data *lockd = (struct lockd_data *)data; + int val = 0; + + if(pid == lockd->lock_app_pid || pid == lockd->phone_lock_app_pid){ + if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + } + LOCKD_DBG("lock daemon(%d) is terminated, lock type : %d pm state : %d", pid, lockd->lock_type, val); + if(lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER){ + lockd_unlock_other_lockscreen(lockd); + _lockd_play_sound(TRUE); + } + else{ + if(val < VCONFKEY_PM_STATE_LCDOFF){ + lockd->start_ready = TRUE; + lockd_launch_app_lockscreen_lite(lockd); + } + else{ + lockd_launch_app_lockscreen_lite(lockd); + } + } + } + + menu_daemon_check_dead_signal(pid); + + return 0; +} + +static Eina_Bool lockd_other_app_create_cb(void *data, int type, void *event) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + + if (lockd == NULL) { + return ECORE_CALLBACK_PASS_ON; + } + LOCKD_DBG("%s, %d", __func__, __LINE__); + if (lockd_window_set_window_effect(lockd->lockw, lockd->lock_app_pid, + event) == EINA_TRUE) { + //FIXME sometimes show cb is not called. + if(lockd_window_set_window_property(lockd->lockw, lockd->lock_app_pid, + event) == EINA_FALSE) { + LOCKD_ERR("window is not matched..!!"); + } + } + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool lockd_other_app_show_cb(void *data, int type, void *event) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + + if (lockd == NULL) { + return EINA_TRUE; + } + LOCKD_DBG("%s, %d", __func__, __LINE__); + if (lockd_window_set_window_property(lockd->lockw, lockd->lock_app_pid, + event)) { + lockd_window_set_scroll_property(lockd->lockw, 0); + ecore_idler_add(lockd_set_lock_state_cb, NULL); + } + return EINA_FALSE; +} + +static Eina_Bool _lockd_play_idelr_cb(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + _lockd_play_sound(FALSE); + return ECORE_CALLBACK_CANCEL; +} + + +static int lockd_launch_app_lockscreen_lite(struct lockd_data *lockd) +{ + LOCKD_DBG("launch app lock screen"); + + int call_state = -1, factory_mode = -1, test_mode = -1; + int r = 0; + int lcdoff_source = 0; + int focus_win_pid = 0; + int pw_type = 0; + int automatic_unlock = 0; + + //PM LOCK - don't go to sleep + display_lock_state(LCD_OFF, STAY_CUR_STATE, 0); + + vconf_get_int(VCONFKEY_TELEPHONY_SIM_FACTORY_MODE, &factory_mode); + if (factory_mode == VCONFKEY_TELEPHONY_SIM_FACTORYMODE_ON) { + LOCKD_ERR("Factory mode ON, lock screen can't be launched..!!"); + goto launch_out; + } + vconf_get_int(VCONFKEY_TESTMODE_SCREEN_LOCK, &test_mode); + if (test_mode == VCONFKEY_TESTMODE_SCREEN_LOCK_DISABLE) { + LOCKD_ERR("Test mode ON, lock screen can't be launched..!!"); + goto launch_out; + } + + if (lockd->is_first_boot == TRUE) { + if(vconf_get_int(VCONFKEY_PWLOCK_STATE, &pw_type) < 0) + { + LOCKD_ERR("vconf_get_int() failed"); + pw_type = VCONFKEY_PWLOCK_RUNNING_UNLOCK; + } + if(pw_type == VCONFKEY_PWLOCK_BOOTING_LOCK || pw_type == VCONFKEY_PWLOCK_RUNNING_LOCK) { + LOCKD_ERR("First boot & pwlock state[%d], lock screen can't be launched..!!", pw_type); + goto launch_out; + } + } + + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_NONE) { + LOCKD_ERR("Lock screen type is None..!!"); + goto launch_out; + } + + LOCKD_WARN("lock type : %d", lockd->lock_type); + switch (lockd->lock_type) { + + case SETTING_SCREEN_LOCK_TYPE_SWIPE: + if(lockd->start_ready == TRUE){ + lockd->lock_app_pid = + lockd_process_mgr_start_ready_lock(); + lockd->start_ready = FALSE; + } + else{ + lockd->lock_app_pid = + lockd_process_mgr_start_normal_lock(lockd, lockd_app_dead_cb_lite); + if (lockd->lock_app_pid < 0) { + goto launch_out; + } + } + break; + + case SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD: + case SETTING_SCREEN_LOCK_TYPE_PASSWORD: + vconf_set_bool(VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, FALSE); + + /* TO DO : Recovery should be checked by EAS interface later */ + /* After getting EAS interface, we should remove lockd->request_recovery */ + if (lockd->request_recovery == TRUE) { + lockd->phone_lock_app_pid = + lockd_process_mgr_start_recovery_lock(); + lockd->request_recovery = FALSE; + } else if (lockd->back_to_app == TRUE) { + lockd->phone_lock_app_pid = + lockd_process_mgr_start_back_to_app_lock(); + lockd->back_to_app = FALSE; + } else if (lockd->start_ready == TRUE) { + lockd->phone_lock_app_pid = + lockd_process_mgr_start_ready_lock(); + lockd->start_ready = FALSE; + } else { + lockd->phone_lock_app_pid = + lockd_process_mgr_start_phone_lock(); + } + phone_lock_pid = lockd->phone_lock_app_pid; + LOCKD_WARN("%s, %d, phone_lock_pid = %d", __func__, __LINE__, + phone_lock_pid); + lockd_window_set_phonelock_pid(lockd->lockw, phone_lock_pid); + if (phone_lock_pid > 0) { + if(starter_dbus_set_oomadj(phone_lock_pid, OOM_ADJ_VALUE_DEFAULT) < 0){ + LOCKD_ERR("failed to send oom dbus signal"); + } + if(lockd_process_mgr_check_home(focus_win_pid)) { + if(vconf_set_bool(VCONFKEY_SAT_NORMAL_PRIORITY_AVAILABLE_BOOL, EINA_TRUE) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + } + } + } + else{ + LOCKD_ERR("failed to launch phone lock."); + goto launch_out; + } + lockd_process_mgr_set_lockscreen_priority(phone_lock_pid); + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return 1; + break; + + default: + goto launch_out; + } + + + if (lockd->lock_app_pid > 0) { + if(starter_dbus_set_oomadj(lockd->lock_app_pid, OOM_ADJ_VALUE_DEFAULT) < 0){ + LOCKD_ERR("failed to send oom dbus signal"); + } + if(lockd_process_mgr_check_home(focus_win_pid)) { + if(vconf_set_bool(VCONFKEY_SAT_NORMAL_PRIORITY_AVAILABLE_BOOL, EINA_TRUE) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + } + } + } + else{ + LOCKD_ERR("failed to launch lock"); + goto launch_out; + } + LOCKD_WARN("lock app pid : %d", lockd->lock_app_pid); + lockd_process_mgr_set_lockscreen_priority(lockd->lock_app_pid); + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return 1; + + +launch_out: + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return -1; +} + + +static int lockd_launch_app_other_lockscreen(struct lockd_data *lockd) +{ + LOCKD_DBG("launch app other lock screen"); + + int call_state = -1, factory_mode = -1, test_mode = -1; + int r = 0; + int lcdoff_source = 0; + int focus_win_pid = 0; + int pw_type = 0; + int automatic_unlock = 0; + + //PM LOCK - don't go to sleep + display_lock_state(LCD_OFF, STAY_CUR_STATE, 0); + + vconf_get_int(VCONFKEY_TELEPHONY_SIM_FACTORY_MODE, &factory_mode); + if (factory_mode == VCONFKEY_TELEPHONY_SIM_FACTORYMODE_ON) { + LOCKD_ERR("Factory mode ON, lock screen can't be launched..!!"); + goto launch_out; + } + vconf_get_int(VCONFKEY_TESTMODE_SCREEN_LOCK, &test_mode); + if (test_mode == VCONFKEY_TESTMODE_SCREEN_LOCK_DISABLE) { + LOCKD_ERR("Test mode ON, lock screen can't be launched..!!"); + goto launch_out; + } + + if (lockd->is_first_boot == TRUE) { + if(vconf_get_int(VCONFKEY_PWLOCK_STATE, &pw_type) < 0) + { + LOCKD_ERR("vconf_get_int() failed"); + pw_type = VCONFKEY_PWLOCK_RUNNING_UNLOCK; + } + if(pw_type == VCONFKEY_PWLOCK_BOOTING_LOCK || pw_type == VCONFKEY_PWLOCK_RUNNING_LOCK) { + LOCKD_ERR("First boot & pwlock state[%d], lock screen can't be launched..!!", pw_type); + goto launch_out; + } + } + + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_NONE) { + LOCKD_ERR("Lock screen type is None..!!"); + goto launch_out; + } + + /* Get Call state */ + if(vconf_get_int(VCONFKEY_PM_LCDOFF_SOURCE, &lcdoff_source) < 0) + { + LOCKD_ERR("Cannot get VCONFKEY"); + } + focus_win_pid = lockd_window_mgr_get_focus_win_pid(); + vconf_get_int(VCONFKEY_CALL_STATE, &call_state); + if(lcdoff_source == VCONFKEY_PM_LCDOFF_BY_POWERKEY) { + if ((call_state != VCONFKEY_CALL_OFF) && (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER)) { + if (focus_win_pid >0) { + if (lockd_process_mgr_check_call(focus_win_pid) == TRUE) { + LOCKD_ERR("Call is FG => not allow to launch lock screen!!"); + goto launch_out; + } else { + LOCKD_DBG("Call is BG => allow to launch lock screen!!"); + } + } + } + } else { + if ((call_state != VCONFKEY_CALL_OFF) && (lockd->back_to_app == FALSE)) { + LOCKD_ERR("Current call state(%d) does not allow to launch lock screen.", + call_state); + goto launch_out; + } + } + + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER) { + if (lockd_process_mgr_check_lock(lockd->lock_app_pid) == TRUE) { + LOCKD_WARN("Lock Screen App is already running."); + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return 1; + } + + if (lockd->lock_app_pid > 0) { + LOCKD_ERR("Lock Screen App is remained, pid[%d].", lockd->lock_app_pid); + lockd_process_mgr_kill_lock_app(lockd->lock_app_pid); + lockd->lock_app_pid = 0; + } + if(lcdoff_source == VCONFKEY_PM_LCDOFF_BY_POWERKEY) + ecore_idler_add(_lockd_play_idelr_cb, NULL); + + lockd->lock_app_pid = + lockd_process_mgr_start_lock(lockd, lockd_app_dead_cb_lite, + lockd->lock_type); + if (lockd->lock_app_pid < 0) { + LOCKD_ERR("launch 3rd party lockscreen failed."); + goto launch_out; + } + /* reset window mgr before start win mgr */ + lockd_window_mgr_finish_lock(lockd->lockw); + lockd_window_mgr_ready_lock(lockd, lockd->lockw, lockd_other_app_create_cb, + lockd_other_app_show_cb); + } + + if (lockd->lock_app_pid > 0) { + if(starter_dbus_set_oomadj(lockd->lock_app_pid, OOM_ADJ_VALUE_DEFAULT) < 0){ + LOCKD_ERR("failed to send oom dbus signal"); + } + if(lockd_process_mgr_check_home(focus_win_pid)) { + if(vconf_set_bool(VCONFKEY_SAT_NORMAL_PRIORITY_AVAILABLE_BOOL, EINA_TRUE) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + } + } + } + LOCKD_WARN("lock app pid : %d", lockd->lock_app_pid); + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return 1; + + + launch_out: + _lockd_set_lock_state(VCONFKEY_IDLE_UNLOCK); + display_unlock_state(LCD_OFF, PM_SLEEP_MARGIN); + return -1; +} + +static void lockd_unlock_other_lockscreen(struct lockd_data *lockd) +{ + LOCKD_DBG("unlock other lock screen"); + lockd->lock_app_pid = 0; + + _lockd_set_lock_state(VCONFKEY_IDLE_UNLOCK); + lockd_window_mgr_finish_lock(lockd->lockw); +} + +inline static void lockd_set_sock_option(int fd, int cli) +{ + int size; + int ret; + struct timeval tv = { 1, 200 * 1000 }; /* 1.2 sec */ + + size = PHLOCK_SOCK_MAXBUFF; + ret = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)); + if(ret != 0) + return; + ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); + if(ret != 0) + return; + if (cli) { + ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + if(ret != 0) + return; + } +} + +static int lockd_create_sock(void) +{ + struct sockaddr_un saddr; + int fd; + + fd = socket(AF_UNIX, SOCK_STREAM, 0); /* support above version 2.6.27 */ + if (fd < 0) { + if (errno == EINVAL) { + fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd < 0) { + LOCKD_ERR + ("second chance - socket create error"); + return -1; + } + } else { + LOCKD_ERR("socket error"); + return -1; + } + } + + bzero(&saddr, sizeof(saddr)); + saddr.sun_family = AF_UNIX; + + strncpy(saddr.sun_path, PHLOCK_SOCK_PREFIX, sizeof(saddr.sun_path)-1); + saddr.sun_path[strlen(PHLOCK_SOCK_PREFIX)] = 0; + + unlink(saddr.sun_path); + + if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) { + LOCKD_ERR("bind error"); + close(fd); + return -1; + } + + if (chmod(saddr.sun_path, (S_IRWXU | S_IRWXG | S_IRWXO)) < 0) { + /* Flawfinder: ignore */ + LOCKD_ERR("failed to change the socket permission"); + close(fd); + return -1; + } + + lockd_set_sock_option(fd, 0); + + if (listen(fd, 10) == -1) { + LOCKD_ERR("listen error"); + close(fd); + return -1; + } + + return fd; +} + +static gboolean lockd_glib_check(GSource * src) +{ + GSList *fd_list; + GPollFD *tmp; + + fd_list = src->poll_fds; + do { + tmp = (GPollFD *) fd_list->data; + if ((tmp->revents & (POLLIN | POLLPRI))) + return TRUE; + fd_list = fd_list->next; + } while (fd_list); + + return FALSE; +} + +static char *lockd_read_cmdline_from_proc(int pid) +{ + int memsize = 32; + char path[32]; + char *cmdline = NULL, *tempptr = NULL; + FILE *fp = NULL; + + snprintf(path, sizeof(path), "/proc/%d/cmdline", pid); + + fp = fopen(path, "r"); + if (fp == NULL) { + LOCKD_ERR("Cannot open cmdline on pid[%d]", pid); + return NULL; + } + + cmdline = malloc(32); + if (cmdline == NULL) { + LOCKD_ERR("%s", "Out of memory"); + fclose(fp); + return NULL; + } + + bzero(cmdline, memsize); + if (fgets(cmdline, 32, fp) == NULL) { + LOCKD_ERR("%s", "Cannot read cmdline"); + free(cmdline); + fclose(fp); + return NULL; + } + + while (cmdline[memsize - 2] != 0) { + cmdline[memsize - 1] = (char)fgetc(fp); + tempptr = realloc(cmdline, memsize + 32); + if (tempptr == NULL) { + fclose(fp); + LOCKD_ERR("%s", "Out of memory"); + return NULL; + } + cmdline = tempptr; + bzero(cmdline + memsize, 32); + fgets(cmdline + memsize, 32, fp); + memsize += 32; + } + + if (fp != NULL) + fclose(fp); + return cmdline; +} + +static int lockd_sock_handler(void *data) +{ + int cl; + int len; + int sun_size; + int clifd = -1; + char cmd[PHLOCK_SOCK_MAXBUFF]; + char *cmdline = NULL; + int fd = -1; + int recovery_state = -1; + GPollFD *gpollfd; + + struct ucred cr; + struct sockaddr_un lockd_addr; + struct lockd_data *lockd = (struct lockd_data *)data; + + if ((lockd == NULL) || (lockd->gpollfd == NULL)) { + LOCKD_ERR("lockd->gpollfd is NULL"); + return -1; + } + gpollfd = (GPollFD *)lockd->gpollfd; + fd = gpollfd->fd; + + cl = sizeof(cr); + sun_size = sizeof(struct sockaddr_un); + + if ((clifd = + accept(fd, (struct sockaddr *)&lockd_addr, + (socklen_t *) & sun_size)) == -1) { + if (errno != EINTR) + LOCKD_ERR("accept error"); + return -1; + } + + if (getsockopt(clifd, SOL_SOCKET, SO_PEERCRED, &cr, (socklen_t *) & cl) + < 0) { + LOCKD_ERR("peer information error"); + close(clifd); + return -1; + } + LOCKD_ERR("Peer's pid=%d, uid=%d, gid=%d\n", cr.pid, cr.uid, cr.gid); + + memset(cmd, 0, PHLOCK_SOCK_MAXBUFF); + + lockd_set_sock_option(clifd, 1); + + /* receive single packet from socket */ + len = recv(clifd, cmd, PHLOCK_SOCK_MAXBUFF, 0); + + if (len < 0) { + LOCKD_ERR("recv error, read number is less than zero"); + close(clifd); + return -1; + } + + cmd[PHLOCK_SOCK_MAXBUFF - 1] = '\0'; + + LOCKD_ERR("cmd %s", cmd); + + /* Read command line of the PID from proc fs */ + cmdline = lockd_read_cmdline_from_proc(cr.pid); + if (cmdline == NULL) { + /* It's weired. no file in proc file system, */ + LOCKD_ERR("Error on opening /proc/%d/cmdline", cr.pid); + close(clifd); + return -1; + } + LOCKD_SECURE_ERR("/proc/%d/cmdline : %s", cr.pid, cmdline); + + if ((!strncmp(cmd, PHLOCK_UNLOCK_RESET_CMD, strlen(cmd))) + && (!strncmp(cmdline, OMA_DRM_AGENT_CMDLINE, strlen(cmdline)))) { + LOCKD_SECURE_ERR("%s request %s \n", cmdline, cmd); + if(phone_lock_pid > 0) { + LOCKD_SECURE_ERR("pid [%d] %s is verified, unlock..!!\n", cr.pid, + cmdline); + vconf_set_bool(VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, TRUE); + // reset lockscreen type + if (vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_SWIPE) < 0) { + LOCKD_ERR("%s set to %d is failed. error \n", + VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_SWIPE); + } + } + } else if (!strncmp(cmd, PHLOCK_LAUNCH_CMD, strlen(cmd))) { + if (!strncmp(cmdline, MDM_APP_CMDLINE, strlen(cmdline))) { + LOCKD_ERR("%s request %s \n", cmdline, cmd); + if (vconf_get_int(VCONFKEY_EAS_RECOVERY_MODE, &recovery_state) < 0) { + LOCKD_ERR("Cannot get vconfkey", VCONFKEY_EAS_RECOVERY_MODE); + lockd->request_recovery = FALSE; + } else if (recovery_state == 1) { + LOCKD_ERR("recovery mode : %d \n", recovery_state); + lockd->request_recovery = TRUE; + } else { + lockd->request_recovery = FALSE; + } + } + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD) { + lockd_launch_app_lockscreen_lite(lockd); + } else { + lockd->request_recovery = FALSE; + } + } else if (!strncmp(cmd, HOME_RAISE_CMD, strlen(cmd))) { + if ((!strncmp(cmdline, VOICE_CALL_APP_CMDLINE, strlen(cmdline))) + || (!strncmp(cmdline, VIDEO_CALL_APP_CMDLINE, strlen(cmdline)))) { + LOCKD_SECURE_ERR("%s request %s \n", cmdline, cmd); + menu_daemon_open_homescreen(NULL); + } + } else if (!strncmp(cmd, LOCK_SHOW_CMD, strlen(cmd))) { + if ((!strncmp(cmdline, VOICE_CALL_APP_CMDLINE, strlen(cmdline))) + || (!strncmp(cmdline, VIDEO_CALL_APP_CMDLINE, strlen(cmdline)))) { + LOCKD_SECURE_ERR("%s request %s \n", cmdline, cmd); + lockd->back_to_app = TRUE; + } + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD){ + lockd_launch_app_lockscreen_lite(lockd); + } else { + lockd->back_to_app = FALSE; + } + } else if (!strncmp(cmd, LOCK_LAUNCH_CMD, strlen(cmd))) { + LOCKD_SECURE_ERR("%s request %s \n", cmdline, cmd); + if (!strncmp(cmdline, VOICE_CALL_APP_CMDLINE, strlen(cmdline))) { + lockd_launch_app_lockscreen_lite(lockd); + } + } + + if(cmdline != NULL) { + free(cmdline); + cmdline = NULL; + } + + close(clifd); + return 0; +} + +static gboolean lockd_glib_handler(gpointer data) +{ + if (lockd_sock_handler(data) < 0) { + LOCKD_ERR("lockd_sock_handler is failed..!!"); + } + return TRUE; +} + +static gboolean lockd_glib_dispatch(GSource * src, GSourceFunc callback, + gpointer data) +{ + callback(data); + return TRUE; +} + +static gboolean lockd_glib_prepare(GSource * src, gint * timeout) +{ + return FALSE; +} + +static GSourceFuncs funcs = { + .prepare = lockd_glib_prepare, + .check = lockd_glib_check, + .dispatch = lockd_glib_dispatch, + .finalize = NULL +}; + +static int lockd_init_sock(struct lockd_data *lockd) +{ + int fd; + GPollFD *gpollfd; + GSource *src; + int ret; + + fd = lockd_create_sock(); + if (fd < 0) { + LOCKD_ERR("lock daemon create sock failed..!!"); + } + + src = g_source_new(&funcs, sizeof(GSource)); + + gpollfd = (GPollFD *) g_malloc(sizeof(GPollFD)); + gpollfd->events = POLLIN; + gpollfd->fd = fd; + + lockd->gpollfd = gpollfd; + + g_source_add_poll(src, lockd->gpollfd); + g_source_set_callback(src, (GSourceFunc) lockd_glib_handler, + (gpointer) lockd, NULL); + g_source_set_priority(src, G_PRIORITY_LOW); + + ret = g_source_attach(src, NULL); + if (ret == 0) + return -1; + + g_source_unref(src); + + return 0; +} + + + + +static void _lockd_notify_bt_device_connected_status_cb(keynode_t * node, void *data) +{ + int is_connected = 0; + struct lockd_data *lockd = (struct lockd_data *)data; + + vconf_get_bool(VCONFKEY_SETAPPL_AUTO_LOCK_DEVICE_STATUS_BOOL , &is_connected); + LOCKD_WARN("BT connect status is changed to [%d]", is_connected); + + if (is_connected) { + if (lockd_start_bt_monitor() < 0) { + LOCKD_ERR("Fail starter BT monitor"); + } + } else { + lockd_stop_bt_monitor(); + lockd_change_security_auto_lock(is_connected); + } +} + + +static void _lockd_notify_lock_type_changed_cb(keynode_t * node, void *data) +{ + int lock_type = -1; + struct lockd_data *lockd = (struct lockd_data *)data; + LOCKD_DBG("lock type is changed..!!"); + + lock_type = vconf_keynode_get_int(node); + lockd->lock_type = lock_type; + + if(lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER){ + LOCKD_DBG("lock type is 3rd party lock"); + lockd_init_vconf(lockd); + if(lockd->lock_app_pid > 0){ + lockd_process_mgr_terminate_lock_app(lockd->lock_app_pid, 1); + lockd->lock_app_pid = 0; + } + if(lockd->phone_lock_app_pid > 0){ + lockd_process_mgr_terminate_lock_app(lockd->phone_lock_app_pid, 1); + lockd->phone_lock_app_pid = 0; + } + } + else{ + LOCKD_DBG("lock type is not 3rd party lock"); + lockd_fini_vconf(lockd); + lockd->start_ready = TRUE; + lockd_launch_app_lockscreen_lite(lockd); + } +} + + +static void lockd_fini_vconf(struct lockd_data *lockd) +{ + int val = -1; + + if (vconf_ignore_key_changed + (VCONFKEY_PM_STATE, _lockd_notify_pm_state_cb_lite) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_PM_STATE"); + } + + if (vconf_ignore_key_changed + (VCONFKEY_PM_LCDOFF_SOURCE, _lockd_notify_pm_lcdoff_cb_lite) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_PM_LCDOFF_SOURCE"); + } + + if (vconf_ignore_key_changed + (VCONFKEY_TELEPHONY_SIM_FACTORY_MODE, _lockd_notify_factory_mode_cb) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_TELEPHONY_SIM_FACTORY_MODE"); + } +#if 0 + if (vconf_ignore_key_changed + (VCONFKEY_SYSTEM_TIME_CHANGED, _lockd_notify_time_changed_cb) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_SYSTEM_TIME_CHANGED"); + } +#endif + if (vconf_ignore_key_changed + (VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, _lockd_notify_phone_lock_verification_cb) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION"); + } + if (vconf_ignore_key_changed + (VCONFKEY_IDLE_LOCK_STATE, _lockd_notify_lock_state_cb) != 0) { + LOCKD_ERR("Fail vconf_ignore_key_changed : VCONFKEY_IDLE_LOCK_STATE"); + } +} + + +static void lockd_init_vconf(struct lockd_data *lockd) +{ + int val = -1; + + if (vconf_notify_key_changed + (VCONFKEY_PM_STATE, _lockd_notify_pm_state_cb_lite, lockd) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY"); + } + + if (vconf_notify_key_changed + (VCONFKEY_PM_LCDOFF_SOURCE, _lockd_notify_pm_lcdoff_cb_lite, lockd) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY"); + } + + if (vconf_notify_key_changed + (VCONFKEY_TELEPHONY_SIM_FACTORY_MODE, _lockd_notify_factory_mode_cb, NULL) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY"); + } +#if 0 + if (vconf_notify_key_changed + (VCONFKEY_SYSTEM_TIME_CHANGED, _lockd_notify_time_changed_cb, NULL) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY"); + } +#endif + if (vconf_notify_key_changed + (VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, + _lockd_notify_phone_lock_verification_cb, lockd) != 0) { + if (vconf_get_bool(VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, &val) < 0) { + LOCKD_ERR + ("Cannot get VCONFKEY"); + vconf_set_bool(VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, 0); + if (vconf_notify_key_changed + (VCONFKEY_LOCKSCREEN_PHONE_LOCK_VERIFICATION, + _lockd_notify_phone_lock_verification_cb, + lockd) != 0) { + LOCKD_ERR + ("Fail vconf_notify_key_changed " ); + } + } else { + LOCKD_ERR + ("Fail vconf_notify_key_changed " ); + } + } + + if (vconf_notify_key_changed + (VCONFKEY_IDLE_LOCK_STATE, + _lockd_notify_lock_state_cb, + lockd) != 0) { + LOCKD_ERR + ("[Error] vconf notify : lock state"); + } +} + + +static Eina_Bool lockd_init_alarm(void *data) +{ + struct lockd_data *lockd = (struct lockd_data *)data; + + if(!lockd) { + LOCKD_ERR("parameter is NULL"); + return EINA_FALSE; + } + + LOCKD_DBG("%s, %d", __func__, __LINE__); + + int ret_val = 0; + /* alarm id initialize */ + lockd->alarm_id = -1; + + g_type_init(); + ret_val = alarmmgr_init(PACKAGE_NAME); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_init() failed(%d)", ret_val); + return EINA_FALSE; + } + ret_val = alarmmgr_set_cb((alarm_cb_t)_lockd_lauch_other_lockscreen, lockd); + if(ret_val != ALARMMGR_RESULT_SUCCESS) { + LOCKD_ERR("alarmmgr_init() failed"); + return EINA_FALSE; + } + + LOCKD_DBG("alarm init success"); + return EINA_TRUE; +} + +static int lockd_init_hall_signal(void *data) +{ + E_DBus_Connection *conn; + E_DBus_Signal_Handler *handler; + + struct lockd_data *lockd = (struct lockd_data *)data; + if(!lockd) { + LOCKD_ERR("parameter is NULL"); + return EINA_FALSE; + } + + conn = e_dbus_bus_get(DBUS_BUS_SYSTEM); + if (conn == NULL) { + LOCKD_ERR("e_dbus_bus_get error"); + return -1; + } + lockd->hall_conn = conn; + +#if 0 + int r; + r = e_dbus_request_name(conn, BUS_NAME, 0, NULL, NULL); + if (!r) { + LOCKD_ERR("e_dbus_request_name erro"); + return -1; + } +#endif + + handler = e_dbus_signal_handler_add(conn, NULL, DEVICED_PATH_HALL, + DEVICED_INTERFACE_HALL, SIGNAL_HALL_STATE, + _lockd_on_changed_receive, lockd); + if (handler == NULL) { + LOCKD_ERR("e_dbus_signal_handler_add error"); + return -1; + } + lockd->hall_handler = handler; + /* S-Cover Lock : Signal <!-- END --> */ +} + + + +static Eina_Bool _lockd_launch_lockscreen_by_pwr_key(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + + int idle_lock_state = VCONFKEY_IDLE_UNLOCK; + struct lockd_data *lockd = (struct lockd_data *)data; + + LOCKD_DBG("lcd off by powerkey"); + + if (idle_lock_state == VCONFKEY_IDLE_UNLOCK) { + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SWIPE) { + display_lock_state(LCD_OFF, STAY_CUR_STATE, 0); + _lockd_request_PmQos(REQUEST_PMQOS_DURATION); + } + } + lockd_launch_app_lockscreen_lite(lockd); + return ECORE_CALLBACK_CANCEL; +} + + +static void _lockd_receive_lcd_off(void *data, DBusMessage *msg) +{ + DBusError err; + int r; + int idle_lock_state = VCONFKEY_IDLE_UNLOCK; + + struct lockd_data *lockd = (struct lockd_data *)data; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + + LOCKD_DBG("lcd off signal is received"); + + r = dbus_message_is_signal(msg, DEVICED_INTERFACE_LCD_OFF, METHOD_LCD_OFF_NAME); + if (!r) { + LOCKD_ERR("dbus_message_is_signal error"); + return; + } + + LOCKD_DBG("%s - %s", DEVICED_INTERFACE_LCD_OFF, METHOD_LCD_OFF_NAME); + +#if 0 //need to check if lockscreen is displayed before lcd off. + idle_lock_state = lockd_get_lock_state(); + + LOCKD_DBG("lcd off by powerkey"); + + if (idle_lock_state == VCONFKEY_IDLE_UNLOCK) { + if (lockd->lock_type == LOCK_TYPE_SECURITY || lockd->lock_type == LOCK_TYPE_NORMAL) { + _lockd_request_PmQos(REQUEST_PMQOS_DURATION); + display_lock_state(LCD_OFF, STAY_CUR_STATE, 0); + } + } + lockd_launch_app_lockscreen_lite(lockd); +#else + ecore_idler_add(_lockd_launch_lockscreen_by_pwr_key, lockd); +#endif +} + + +static int lockd_init_lcd_off_signal(void *data) +{ + E_DBus_Connection *conn; + E_DBus_Signal_Handler *handler; + + struct lockd_data *lockd = (struct lockd_data *)data; + if(!lockd) { + LOCKD_ERR("parameter is NULL"); + return EINA_FALSE; + } + + conn = e_dbus_bus_get(DBUS_BUS_SYSTEM); + if (conn == NULL) { + LOCKD_ERR("e_dbus_bus_get error"); + return -1; + } + lockd->display_conn = conn; + + handler = e_dbus_signal_handler_add(conn, NULL, DEVICED_PATH_LCD_OFF, + DEVICED_INTERFACE_LCD_OFF, METHOD_LCD_OFF_NAME, + _lockd_receive_lcd_off, lockd); + if (handler == NULL) { + LOCKD_ERR("e_dbus_signal_handler_add error"); + return -1; + } + lockd->display_handler = handler; +} + +void lockd_check_vconf_festival_wallpaper(void *data){ + struct lockd_data *lockd = (struct lockd_data *)data; + + if (lockd == NULL) { + LOCKD_ERR("lockd is NULL"); + return; + } + int festival_wallpaper = 0; + + if(vconf_get_bool(VCONFKEY_LOCKSCREEN_FESTIVAL_WALLPAPER_DISPLAYING, &festival_wallpaper) < 0) { + LOCKD_ERR("Cannot get VCONFKEY"); + festival_wallpaper = 0; + } + LOCKD_DBG("festival wallpaper : %d", festival_wallpaper); + if(festival_wallpaper){ + bundle *b; + b = bundle_create(); + if(b == NULL){ + LOCKD_ERR("bundle create failed.\n"); + return; + } + bundle_add(b, "popup_type", "festival"); + bundle_add(b, "festival_type", "festival_create"); + aul_launch_app(WALLPAPER_UI_SERVICE_PKG_NAME, b); + bundle_free(b); + } + +} + +static void _lockd_check_ongoing(bool ongoing) +{ + if (ongoing) { + /* check previous process */ + if (checkfd) { + LOCKD_ERR("checkfd fail\n"); + return; + } + if (access(PASSWORD_LOCK_PROGRESS, F_OK) == 0) { + LOCKD_ERR("check access fail\n"); + return; + } + /* make tmp file */ + checkfd = creat(PASSWORD_LOCK_PROGRESS, 0640); + if (checkfd < 0) { + LOCKD_ERR("fail to make %s file\n", PASSWORD_LOCK_PROGRESS); + checkfd = 0; + } + LOCKD_WARN("make %s file\n", PASSWORD_LOCK_PROGRESS); + checkfd = 1; + } else { + if (!checkfd) + return; + if (unlink(PASSWORD_LOCK_PROGRESS) < 0) + LOCKD_ERR("fail to remove %s file\n", PASSWORD_LOCK_PROGRESS); + close(checkfd); + checkfd = 0; + LOCKD_WARN("delete %s file\n", PASSWORD_LOCK_PROGRESS); + } +} + +static void lockd_start_lock_daemon_lite(void *data) +{ + struct lockd_data *lockd = NULL; + int r = 0; + + lockd = (struct lockd_data *)data; + + if (!lockd) { + return; + } + + LOCKD_DBG("%s, %d", __func__, __LINE__); + + lockd_process_mgr_init(); + + /* init alarm manager */ +// lockd_check_vconf_festival_wallpaper(lockd); + + lockd->is_alarm = lockd_init_alarm(lockd); + + + /* Initialize socket */ + r = lockd_init_sock(lockd); + if (r < 0) { + LOCKD_ERR("lockd init socket failed: %d", r); + } + + /* Create internal 1x1 window */ + lockd->lockw = lockd_window_init(); + + aul_listen_app_dead_signal(lockd_app_dead_cb_lite, data); +} + +static Eina_Bool _lockd_check_wallpaper_service(void *data) +{ + LOCKD_DBG("%s, %d", __func__, __LINE__); + struct lockd_data *lockd = (struct lockd_data *)data; + lockd_check_vconf_festival_wallpaper(lockd); + return ECORE_CALLBACK_CANCEL; +} + + +int start_lock_daemon_lite(int launch_lock, int is_first_boot) +{ + struct lockd_data *lockd = NULL; + int recovery_state = -1; + int lock_type = 0; + int first_boot = 0; + int ret = 0; + + LOCKD_DBG("%s, %d", __func__, __LINE__); + + lockd = (struct lockd_data *)malloc(sizeof(struct lockd_data)); + memset(lockd, 0x0, sizeof(struct lockd_data)); + lockd_start_lock_daemon_lite(lockd); + + vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type); + lockd->lock_type = lock_type; + if(lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD || lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD){ + if(checkfd){ + _lockd_check_ongoing(EINA_FALSE); + } + else{ + _lockd_check_ongoing(EINA_TRUE); + } + } + + if (vconf_notify_key_changed + (VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, _lockd_notify_lock_type_changed_cb, lockd) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT"); + } + + if (vconf_notify_key_changed + (VCONFKEY_SYSTEM_TIME_CHANGED, _lockd_notify_time_changed_cb, NULL) != 0) { + LOCKD_ERR("Fail vconf_notify_key_changed : VCONFKEY"); + } + + if (vconf_notify_key_changed + (VCONFKEY_IDLE_LOCK_STATE, + _lockd_notify_lock_state_cb, + lockd) != 0) { + LOCKD_ERR + ("[Error] vconf notify : lock state"); + } + + lockd->back_to_app = FALSE; + + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_NONE) + return -1; + if ((lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD) || (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD)) { + if (vconf_get_int(VCONFKEY_EAS_RECOVERY_MODE, &recovery_state) < 0) { + LOCKD_ERR("Cannot get vconfkey" ); + lockd->request_recovery = FALSE; + } else if (recovery_state == 1) { + LOCKD_DBG("recovery mode : %d \n", recovery_state); + lockd->request_recovery = TRUE; + } else { + lockd->request_recovery = FALSE; + } + } else { + lockd->request_recovery = FALSE; + } + + vconf_set_bool(VCONFKEY_SAT_NORMAL_PRIORITY_AVAILABLE_BOOL, EINA_TRUE); + + if (launch_lock == FALSE) { + LOCKD_ERR("Don't launch lockscreen.."); + ecore_idler_add(_lockd_check_wallpaper_service, lockd); + return 0; + } + + lockd->is_first_boot = is_first_boot; + if (lockd->is_first_boot == TRUE){ + LOCKD_ERR("first_boot : %d \n", lockd->is_first_boot); + lockd->start_ready = TRUE; + ret = lockd_launch_app_lockscreen_lite(lockd); + if(ret < 0){ + LOCKD_ERR("launch lockscreen failed. retry one more time."); + ret = lockd_launch_app_lockscreen_lite(lockd); + if(ret < 0){ + LOCKD_ERR("failed to launch lockscreen."); + } + } + ecore_idler_add(_lockd_check_wallpaper_service, lockd); + return 0; + } + + if (lockd->lock_type == SETTING_SCREEN_LOCK_TYPE_OTHER) { + lockd_init_vconf(lockd); + ret = lockd_launch_app_other_lockscreen(lockd); + if(ret < 0){ + LOCKD_ERR("launch 3rd party lockscreen failed. retry one more time."); + ret = lockd_launch_app_other_lockscreen(lockd); + if(ret < 0){ + LOCKD_ERR("failed to launch 3rd party lockscreen."); + } + } + } else { + ret = lockd_launch_app_lockscreen_lite(lockd); + if(ret < 0){ + LOCKD_ERR("launch lockscreen failed. retry one more time."); + ret = lockd_launch_app_lockscreen_lite(lockd); + if(ret < 0){ + LOCKD_ERR("failed to launch lockscreen."); + } + } + } + ecore_idler_add(_lockd_check_wallpaper_service, lockd); + + if(feedback_initialize() != FEEDBACK_ERROR_NONE) { + LOCKD_ERR("[CAUTION][ERROR] feedback_initialize() is failed..!!"); + } + + return ret; +} + + |