Most of INTERNAL_LOCK_XXX has changed to the same name, DEVICED_EVENT_XXX.
A few of them, mostly INTERNAL_LOCK_PM, has changed to the best matching
name that reflects its context.
Change-Id: I4574e82985defed2578338b6c2bb3cbd34f023ea
Signed-off-by: Youngjae Cho <y0.cho@samsung.com>
#include <vconf.h>
#include <sys/types.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <linux/input.h>
#include "ambient-mode.h"
if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
/* change state - LCD on */
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_NORMAL);
display_state_transition_do_state_transition_by_input_poll_event();
}
display_lock_release_lock_all(S_NORMAL);
display_lock_release_lock_all(S_LCDDIM);
display_state_transition_update_lcdoff_reason(VCONFKEY_PM_LCDOFF_BY_POWERKEY);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_OFF);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_OFF);
} else {
ignore = false;
skip_combination = false;
#include <stdbool.h>
#include <string.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core/log.h"
#include "battery.h"
noti_type = METHOD_LOW_NOTI_UPDATE;
else {
noti_type = METHOD_LOW_NOTI_ON;
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_LOWBAT, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_BATTERY_CAPACITY_LOW, LCD_NORMAL);
}
prev_level = battery_info.warning;
if (battery->charge_now)
noti_type = METHOD_CRITICAL_NOTI_UPDATE;
else {
noti_type = METHOD_CRITICAL_NOTI_ON;
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_LOWBAT, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_BATTERY_CAPACITY_LOW, LCD_NORMAL);
}
prev_level = battery_info.critical;
if (battery->charge_now)
static void update_ovp(enum battery_noti_status status)
{
if (status == DEVICE_NOTI_ON)
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_DIM);
else
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
}
static void health_timer_reset(void)
CRITICAL_LOG("Popup: Battery health status is not good, %s.", battery->health_s);
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BATTERY_HEALTH, (void *)&battery->health);
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
- display_lock_request_lock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, STAY_CUR_STATE, 0);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_DIM);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, STAY_CUR_STATE, 0);
if (battery->health == HEALTH_LOW)
battery_charge_err_low_act(NULL);
else if (battery->health == HEALTH_HIGH)
#include <vconf.h>
#include <sys/types.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <linux/input.h>
#include "ambient-mode.h"
if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
/* change state - LCD on */
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_NORMAL);
display_state_transition_do_state_transition_by_input_poll_event();
}
display_lock_release_lock_all(S_NORMAL);
display_lock_release_lock_all(S_LCDDIM);
display_state_transition_update_lcdoff_reason(VCONFKEY_PM_LCDOFF_BY_POWERKEY);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_OFF);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_OFF);
} else {
ignore = false;
skip_combination = false;
#include <vconf.h>
#include <sys/types.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <linux/input.h>
#include "ambient-mode.h"
if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
/* change state - LCD on */
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_NORMAL);
display_state_transition_do_state_transition_by_input_poll_event();
}
display_lock_release_lock_all(S_NORMAL);
display_lock_release_lock_all(S_LCDDIM);
display_state_transition_update_lcdoff_reason(VCONFKEY_PM_LCDOFF_BY_POWERKEY);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_OFF);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_OFF);
} else {
ignore = false;
skip_combination = false;
#include <time.h>
#include <glib.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core.h"
#include "core/log.h"
static void update_ovp(enum battery_noti_status status)
{
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
}
static void battery_notification_init(void *data)
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <hal/device/hal-bezel.h>
#include <assert.h>
#include <vconf.h>
bezel_wakeup = vconf_keynode_get_bool(key_nodes);
_I("Bezel wakeup condition: %d", bezel_wakeup);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_BEZEL, LCD_NORMAL);
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BEZEL_WAKEUP, (void *)((intptr_t)bezel_wakeup));
}
ret = hal_device_bezel_set_sw_state(bezel_state);
if (ret == 0) {
_I("Bezel rotary event condition is %d", bezel_state);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_BEZEL, LCD_NORMAL);
} else {
_E("Failed to set bezel rotary event condition.");
}
#include <vconf.h>
#include <sys/types.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <linux/input.h>
#include "ambient-mode.h"
if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
/* change state - LCD on */
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_NORMAL);
display_state_transition_do_state_transition_by_input_poll_event();
}
display_lock_release_lock_all(S_NORMAL);
display_lock_release_lock_all(S_LCDDIM);
display_state_transition_update_lcdoff_reason(VCONFKEY_PM_LCDOFF_BY_POWERKEY);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POWERKEY, LCD_OFF);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_INPUT_POWERKEY, LCD_OFF);
} else {
ignore = false;
skip_combination = false;
#include "shared/log.h"
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#define DBUS_COREAPPS_SWIMMODE_PATH "/Org/Tizen/Coreapps/home/swimmode"
#define DBUS_COREAPPS_SWIMMODE_INTERFACE "org.tizen.coreapps.home.swimmode"
_I("Request swim mode state %d by %d", val, pid);
if (display_panel_get_dpms_cached_state() != DPMS_ON) {
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_SWIM, S_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_MISC_SWIMMODE, S_NORMAL);
lcd_state = true;
}
swim_execute((void *)((intptr_t)val));
if (lcd_state) {
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_SWIM, S_LCDOFF);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_MISC_SWIMMODE, S_LCDOFF);
}
}
#include <libsyscommon/libgdbus.h>
#include <libsyscommon/list.h>
#include <libsyscommon/common.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "lowbat-handler.h"
#include "battery-ops.h"
if (lowbat_popup_option == BAT_OPT_ERR_TEMP_LOW ||
lowbat_popup_option == BAT_OPT_ERR_TEMP_HIGH ||
lowbat_popup_option == BAT_OPT_ERR_CF_OPEN) {
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_LOWBAT, LCD_DIM);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_BATTERY_CAPACITY_LOW, LCD_DIM);
} else {
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_LOWBAT, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_BATTERY_CAPACITY_LOW, LCD_NORMAL);
}
if (lowbat_popup_option == BAT_OPT_ERR_TEMP_LOW ||
lowbat_popup_option == BAT_OPT_ERR_TEMP_HIGH ||
int battery_charge_err_low_act(void *data)
{
- display_lock_request_lock_with_option(INTERNAL_LOCK_OVERCOOL, LCD_OFF, STAY_CUR_STATE, 60000);
+ display_lock_request_lock_with_option(DEVICED_EVENT_BATTERY_HEALTH_OVERCOOL, LCD_OFF, STAY_CUR_STATE, 60000);
return lowbat_popup(BAT_OPT_ERR_TEMP_LOW);
}
int battery_charge_err_high_act(void *data)
{
- display_lock_request_lock_with_option(INTERNAL_LOCK_OVERHEAT, LCD_OFF, STAY_CUR_STATE, 60000);
+ display_lock_request_lock_with_option(DEVICED_EVENT_BATTERY_HEALTH_OVERHEAT, LCD_OFF, STAY_CUR_STATE, 60000);
return lowbat_popup(BAT_OPT_ERR_TEMP_HIGH);
}
#include <hal/device/hal-battery.h>
#include <sys/stat.h>
#include <libsyscommon/ini-parser.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "shared/devices.h"
#include "shared/device-notifier.h"
if (old == bInserted)
return;
old = bInserted;
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
}
static void health_status_broadcast(void)
bat_full_noti = 1;
/* turn on LCD, if battery is fully charged */
if (battery_plgn->check_power_supply_noti && battery_plgn->check_power_supply_noti()) {
- battery_pm_change_internal(INTERNAL_LOCK_BATTERY_FULL, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_BATTERY_CAPACITY_FULL, LCD_NORMAL);
} else
_I("Block LCD.");
old_battery.present = battery.present;
if (status == DEVICE_NOTI_ON) {
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_DIM);
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BATTERY_PRESENT, (void *)&battery.present);
- display_lock_request_lock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, STAY_CUR_STATE, 0);
} else {
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BATTERY_PRESENT, (void *)&battery.present);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, PM_SLEEP_MARGIN);
}
if (battery_plgn->changed_battery_cf)
battery_plgn->changed_battery_cf(battery.present);
launching_health_popup = true;
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BATTERY_HEALTH, (void *)&battery.health);
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
- display_lock_request_lock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, STAY_CUR_STATE, LCD_DIM_TIME_IN_BATTERY_HEALTH);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_DIM);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, STAY_CUR_STATE, LCD_DIM_TIME_IN_BATTERY_HEALTH);
if (battery.health == HEALTH_LOW)
battery_charge_err_low_act(NULL);
else if (battery.health == HEALTH_HIGH)
static gboolean health_popup_cb(void *data)
{
launch_health_popup();
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
return G_SOURCE_CONTINUE;
}
if (!abnormal_health_popup_timer)
abnormal_health_popup_timer = g_timeout_add_seconds(ABNORMAL_CHECK_TIMER_INTERVAL, health_popup_cb, NULL);
} else {
- battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
syscommon_notifier_emit_notify(DEVICE_NOTIFIER_BATTERY_HEALTH, (void *)&battery.health);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, PM_SLEEP_MARGIN);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
health_status_broadcast();
if (abnormal_health_popup_timer) {
CRITICAL_LOG("Battery health returned to normal. Stop abnormal popup.");
if (abnormal_health_popup_timer)
g_source_remove(abnormal_health_popup_timer);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
- display_lock_request_lock_with_option(INTERNAL_LOCK_POPUP, LCD_DIM, STAY_CUR_STATE, LCD_DIM_TIME_IN_BATTERY_HEALTH);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_POPUP, LCD_DIM, STAY_CUR_STATE, LCD_DIM_TIME_IN_BATTERY_HEALTH);
if (battery.health == HEALTH_LOW)
battery_charge_err_low_act(NULL);
else if (battery.health == HEALTH_HIGH)
int ret_lock = -1;
int ret_val;
- ret_lock = display_lock_request_lock_with_option(INTERNAL_LOCK_BATTERY, LCD_OFF, STAY_CUR_STATE, 0);
+ ret_lock = display_lock_request_lock_with_option(DEVICED_EVENT_BATTERY, LCD_OFF, STAY_CUR_STATE, 0);
if (old_battery.charge_now != battery.charge_now || battery.charge_now == CHARGER_ABNORMAL) {
ret_val = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, battery.charge_now);
if (!strcmp(old_battery.status_s, CHARGEFULL_NAME) &&
!strcmp(battery.status_s, CHARGENOW_NAME)) {
- battery_pm_change_internal(INTERNAL_LOCK_BATTERY, LCD_NORMAL);
+ battery_pm_change_internal(DEVICED_EVENT_BATTERY, LCD_NORMAL);
}
if (old_battery.charge_full != battery.charge_full)
}
if (ret_lock == 0) {
- display_lock_request_unlock_with_option(INTERNAL_LOCK_BATTERY, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_BATTERY, LCD_OFF, PM_SLEEP_MARGIN);
}
}
#include <fcntl.h>
#include <libsyscommon/libgdbus.h>
#include <libsyscommon/common.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core.h"
#include "display.h"
val = vconf_keynode_get_bool(key_nodes);
if (val != ambient_condition) {
if (display_panel_get_dpms_cached_state() != DPMS_ON)
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_DISPLAY_AMBIENT, LCD_NORMAL);
}
ambient_condition = val;
* So at that time deviced should turn off display to match the pair.
*/
if (on) {
- display_lock_request_lock_with_option(INTERNAL_LOCK_AMBIENT,
+ display_lock_request_lock_with_option(DEVICED_EVENT_DISPLAY_AMBIENT,
LCD_OFF, STAY_CUR_STATE, AMBIENT_CLOCK_WAITING_TIME);
} else
ambient_pid = 0;
void ambient_check_invalid_state(pid_t pid)
{
- if (pid != INTERNAL_LOCK_AMBIENT)
+ if (pid != DEVICED_EVENT_DISPLAY_AMBIENT)
return;
if (syscommon_is_emulator()) {
(ambient_state == false))
return;
- display_lock_request_lock_with_option(INTERNAL_LOCK_AMBIENT, LCD_OFF, STAY_CUR_STATE,
+ display_lock_request_lock_with_option(DEVICED_EVENT_DISPLAY_AMBIENT, LCD_OFF, STAY_CUR_STATE,
AMBIENT_CLOCK_WAITING_TIME);
}
display_panel_set_panel_state_by_off_state(NORMAL_MODE);
broadcast_lcd_off_late(LCD_OFF_LATE_MODE);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_AMBIENT, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_DISPLAY_AMBIENT, LCD_OFF, PM_SLEEP_MARGIN);
}
update_count++;
return;
}
- display_lock_request_lock_with_option(INTERNAL_LOCK_AMBIENT, LCD_OFF, GOTO_STATE_NOW, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_DISPLAY_AMBIENT, LCD_OFF, GOTO_STATE_NOW, 0);
_I("Display off in suspend state.");
lcd_direct_control(DPMS_OFF, NORMAL_MODE);
broadcast_lcd_off_late(LCD_OFF_LATE_MODE);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_AMBIENT, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_DISPLAY_AMBIENT, LCD_OFF, PM_SLEEP_MARGIN);
}
static void ambient_init(void *data)
#include <assert.h>
#include <libsyscommon/libgdbus.h>
#include <libsyscommon/proc.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <device/display.h>
#include <device/power.h>
if (NOT_SUPPORT_OPS(display_device_ops))
goto out;
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_DISPLAY, LCD_NORMAL);
display_device_ops->stop(CORE_LOGIC_MODE);
out:
if (!strcmp(on, "on")) {
pm_save_logdump();
- display_lock_request_lock_with_option(INTERNAL_LOCK_DUMPMODE, LCD_OFF,
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_DUMPMODE, LCD_OFF,
STAY_CUR_STATE, DUMP_MODE_WATING_TIME);
display_backlight_unset_blink();
} else if (!strcmp(on, "off")) {
- display_lock_request_unlock_with_option(INTERNAL_LOCK_DUMPMODE, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_DUMPMODE, LCD_OFF, PM_SLEEP_MARGIN);
display_backlight_set_blink(0);
} else if (!strcmp(on, "blink")) {
display_backlight_set_blink(500);
*
*/
#include <libsyscommon/proc.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "shared/common.h"
#include "ambient-mode.h"
display_plugin_state_get_name(dl->state, &stname);
_I("Display lock expired, state=%s pid=%d", stname, dl->pid);
- if (dl->pid == INTERNAL_LOCK_AMBIENT)
+ if (dl->pid == DEVICED_EVENT_DISPLAY_AMBIENT)
ambient_check_invalid_state(dl->pid);
if (dl->state == S_LCDOFF)
dl->broadcast_warning = true;
if (state == S_NORMAL || state == S_LCDDIM)
dl->background = is_app_background(pid);
- if (pid < INTERNAL_LOCK_BASE)
+ if (pid < DEVICED_EVENT_BASE)
dl->warning_id = g_timeout_add_seconds(LOCK_WATCHDOG_PERIOD_SEC, lock_watchdog_callback, dl);
add_lock(dl);
buf[strlen(buf) - 1] = 0;
if (diff > LOCK_TIME_WARNING) {
- if (diff > LOCK_TIME_WARNING * 60 && dl->pid < INTERNAL_LOCK_BASE && dl->broadcast_warning) {
+ if (diff > LOCK_TIME_WARNING * 60 && dl->pid < DEVICED_EVENT_BASE && dl->broadcast_warning) {
ret = gdbus_signal_emit(NULL,
DEVICED_PATH_DISPLAY,
DEVICED_INTERFACE_DISPLAY,
if ((state == S_LCDOFF) && (get_pm_cur_state() == S_SLEEP) &&
(pm_get_power_lock() == POWER_UNLOCK))
- display_state_transition_do_proc_change_state(data->cond, INTERNAL_LOCK_PM);
+ display_state_transition_do_proc_change_state(data->cond, DEVICED_EVENT_DISPLAY_LOCK);
ret = display_lock_request_lock(state, pid, data->timeout);
if (ret == -EALREADY)
display_plugin_state_get_name(state, &state_name);
_I("[%s] locked by %5d with %u ms", state_name, pid, data->timeout);
- if (pid < INTERNAL_LOCK_BASE) {
+ if (pid < DEVICED_EVENT_BASE) {
/* for debug */
if (state == S_LCDOFF)
lock_type = PM_LCDOFF_STR;
display_plugin_state_get_name(state, &state_name);
_I("[%s] unlocked by %5d", state_name, pid);
- if (pid < INTERNAL_LOCK_BASE) {
+ if (pid < DEVICED_EVENT_BASE) {
/* for debug */
if (state == S_LCDOFF)
lock_type = PM_LCDOFF_STR;
#include <unistd.h>
#include <vconf-keys.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "battery/power-supply.h"
#include "shared/device-notifier.h"
char buf[PATH_MAX];
int cmdline, r;
- if (pid >= INTERNAL_LOCK_BASE)
+ if (pid >= DEVICED_EVENT_BASE)
snprintf(buf, PATH_MAX, "/proc/%d/cmdline", getpid());
else
snprintf(buf, PATH_MAX, "/proc/%d/cmdline", pid);
_I("Stay touch screen off: %d", on);
stay_touchscreen_off = on;
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_TOUCHSCREEN, LCD_NORMAL);
}
void display_misc_get_stay_touchscreen_off(bool *on)
if ((get_charging_status(&charging_status) == 0) && (charging_status > 0))
set_pm_status_flag(CHRGR_FLAG);
-}
\ No newline at end of file
+}
_I("Lcd paneloff mode: %d", on);
lcd_paneloff_mode = on;
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_PM, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_DISPLAY, LCD_NORMAL);
}
/* FIXME: This function is temporary, it can be redefined or not */
* limitations under the License.
*/
+#include <system/syscommon-plugin-deviced-common-interface.h>
+
#include "display-signal.h"
#include "display-util.h"
#include "poll.h"
{
int ret;
- if (pid >= INTERNAL_LOCK_BASE)
+ if (pid >= DEVICED_EVENT_BASE)
return;
/* Send dbus signal to resourced */
return done;
_I("Booting done, release booting lock.");
- display_lock_request_unlock_with_option(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_BOOTING, LCD_OFF, PM_SLEEP_MARGIN);
return done;
}
* deviced guarantees all booting script is executing.
* Last script of booting unlocks this suspend blocking state.
*/
- display_lock_request_lock_with_option(INTERNAL_LOCK_BOOTING, LCD_OFF,
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_BOOTING, LCD_OFF,
STAY_CUR_STATE, DELAYED_INIT_WATING_TIME);
/* Initial display state right after the booting done */
if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) {
timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT);
}
- display_lock_request_lock_with_option(INTERNAL_LOCK_BOOTING, LCD_NORMAL,
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_BOOTING, LCD_NORMAL,
STAY_CUR_STATE, timeout);
}
}
#include <libsyscommon/list.h>
#include <libsyscommon/file.h>
#include <libsyscommon/common.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core.h"
#include "display-misc.h"
}
info->hash = val;
- if (pid < INTERNAL_LOCK_BASE)
+ if (pid < DEVICED_EVENT_BASE)
info->name = strndup(pname, strlen(pname));
else {
char internal_case[25];
PM_CONTROL_EVENT,
};
-enum {
- INTERNAL_LOCK_BASE = 100000,
- INTERNAL_LOCK_AMBIENT,
- INTERNAL_LOCK_BATTERY,
- INTERNAL_LOCK_BATTERY_FULL,
- INTERNAL_LOCK_BOOTING,
- INTERNAL_LOCK_DUMPMODE,
- INTERNAL_LOCK_HDMI,
- INTERNAL_LOCK_ODE,
- INTERNAL_LOCK_POPUP,
- INTERNAL_LOCK_SOUNDDOCK,
- INTERNAL_LOCK_TIME,
- INTERNAL_LOCK_USB,
- INTERNAL_LOCK_USB_HOST,
- INTERNAL_LOCK_POWEROFF,
- INTERNAL_LOCK_SUSPEND,
- INTERNAL_LOCK_COOL_DOWN,
- INTERNAL_LOCK_LOWBAT,
- INTERNAL_LOCK_CRADLE,
- INTERNAL_LOCK_EARJACK,
- INTERNAL_LOCK_POWERKEY,
- INTERNAL_LOCK_PM,
- INTERNAL_LOCK_SWIM,
- INTERNAL_LOCK_OVERHEAT,
- INTERNAL_LOCK_OVERCOOL,
-};
-
#define SIGNAL_NAME_LCD_CONTROL "lcdcontol"
#define LCD_NORMAL 0x01 /**< NORMAL state */
#include <stdio.h>
#include <vconf.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core/log.h"
#include "shared/device-notifier.h"
int ret;
_I("Cradle changed. status=%d", status);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_CRADLE, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_EXTCON_CRADLE, LCD_NORMAL);
cradle_send_broadcast(status);
ret = vconf_set_int(VCONFKEY_SYSMAN_CRADLE_STATUS, status);
if (ret < 0) {
}
if (status == DOCK_SOUND) {
- display_lock_request_lock_with_option(INTERNAL_LOCK_CRADLE, LCD_DIM, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_EXTCON_CRADLE, LCD_DIM, STAY_CUR_STATE, 0);
} else if (status == DOCK_NONE) {
- display_lock_request_unlock_with_option(INTERNAL_LOCK_CRADLE, LCD_DIM, PM_SLEEP_MARGIN);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_EXTCON_CRADLE, LCD_DIM, PM_SLEEP_MARGIN);
}
return 0;
cradle = cradle_extcon_ops.status;
if (cradle == DOCK_SOUND) {
- display_lock_request_lock_with_option(INTERNAL_LOCK_CRADLE, LCD_DIM, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_EXTCON_CRADLE, LCD_DIM, STAY_CUR_STATE, 0);
_I("Sound dock is connected. Dim lock is on.");
}
#include <vconf.h>
#include <bundle.h>
#include <eventsystem.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core/log.h"
#include "poll.h"
earjack_send_broadcast(status);
earjack_send_system_event(status);
if (status != EARJACK_DISCONNECTED) {
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_EARJACK, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_EXTCON_EARJACK, LCD_NORMAL);
}
old_status = status;
#include <stdarg.h>
#include <libsyscommon/libgdbus.h>
#include <libsyscommon/bitmap.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core/log.h"
#include "shared/common.h"
va_end(args);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
return ret;
}
g_variant_new("(s)", type),
__cb, -1, NULL);
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_POPUP, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_MISC_POPUP, LCD_NORMAL);
return ret;
}
#include <fcntl.h>
#include <sys/timerfd.h>
#include <libsyscommon/libgdbus.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <dlfcn.h>
#include "core/log.h"
else
pm_state = 0x4;
- display_lock_request_lock_with_option(INTERNAL_LOCK_TIME, pm_state, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_TIME, pm_state, STAY_CUR_STATE, 0);
ret = handle_date(argv[0]);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_TIME, pm_state, STAY_CUR_STATE);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_TIME, pm_state, STAY_CUR_STATE);
return ret;
}
else
pm_state = 0x4;
- display_lock_request_lock_with_option(INTERNAL_LOCK_TIME, pm_state, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_MISC_TIME, pm_state, STAY_CUR_STATE, 0);
ret = handle_timezone(argv[0]);
- display_lock_request_unlock_with_option(INTERNAL_LOCK_TIME, pm_state, STAY_CUR_STATE);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_MISC_TIME, pm_state, STAY_CUR_STATE);
return ret;
}
#include <vconf.h>
#include <libsyscommon/libsystemd.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include "core/log.h"
#include "core/udev.h"
int ret;
unsigned int mode = usb_state_get_selected_mode();
- display_lock_request_lock_with_option(INTERNAL_LOCK_USB, LCD_OFF, STAY_CUR_STATE, 0);
+ display_lock_request_lock_with_option(DEVICED_EVENT_EXTCON_USB, LCD_OFF, STAY_CUR_STATE, 0);
usb_state_set_connection(USB_CONNECTED);
send_usb_state_changed_event(VCONFKEY_SYSMAN_USB_CONNECTED);
/* Important: You have to keep going to unlock display_lock_request_unlock_with_option */
}
- display_lock_request_unlock_with_option(INTERNAL_LOCK_USB, LCD_OFF, STAY_CUR_STATE);
+ display_lock_request_unlock_with_option(DEVICED_EVENT_EXTCON_USB, LCD_OFF, STAY_CUR_STATE);
return ret;
}
#include <tzplatform_config.h>
#include <libsyscommon/libgdbus.h>
#include <libsyscommon/list.h>
+#include <system/syscommon-plugin-deviced-common-interface.h>
#include <dlfcn.h>
#include "core/log.h"
broadcast_usbhost_signal(USB_HOST_ADDED, usbhost);
if (display_on_usb_conn_changed)
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_USB_HOST, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_EXTCON_USBHOST, LCD_NORMAL);
/* for debugging */
_I("USB HOST Added.");
broadcast_usbhost_signal(USB_HOST_REMOVED, usbhost);
if (display_on_usb_conn_changed)
- display_state_transition_request_state_transition_with_option(INTERNAL_LOCK_USB_HOST, LCD_NORMAL);
+ display_state_transition_request_state_transition_with_option(DEVICED_EVENT_EXTCON_USBHOST, LCD_NORMAL);
/* for debugging */
_I("USB HOST Removed.");