display: state-transition: Remove update_display_time()

display states can have various timeout values depending on the policy.
update_display_time() was used for updating timeout values
accoring to the priority.

In this context, display state transition occurs after a "timeout".

This function is added below display-state-transition.
void display_state_transition_update_display_state_timeout_by_priority(void);
-> This updates timeout values depending on the policy.
1. If there are custom timeout values, then updates to that values.
2. If lockscreen is being displayed,
   then the screen timeout value will be set to lock_screen_timeout.
3. Lastly, timeout value will be set to default setting value.

To support this, getter/setter is added for specific timeout values.

Change-Id: I6cf483f17402948546d364a172334a95890238c5
Signed-off-by: Yunhee Seo <yuni.seo@samsung.com>

diff --git a/plugins/iot-headed/display/core.c b/plugins/iot-headed/display/core.c
index 0dcadf9..d2c1440 100644 (file)
--- a/plugins/iot-headed/display/core.c
+++ b/plugins/iot-headed/display/core.c
@@ -78,9 +78,7 @@
  * @{
  */
 
-#define LOCK_SCREEN_INPUT_TIMEOUT      10000
 #define LOCK_SCREEN_CONTROL_TIMEOUT    5000
-#define ALWAYS_ON_TIMEOUT              360000000
 
 #define GESTURE_STR            "gesture"
 #define POWER_KEY_STR          "powerkey"
@@ -101,11 +99,8 @@ static void (*power_saving_func) (int onoff);
 static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT;
 
 static int system_wakeup_flag = false;
-static unsigned int custom_normal_timeout = 0;
-static unsigned int custom_dim_timeout = 0;
 static char *custom_change_name;
 static guint lock_timeout_id;
-static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT;
 static struct timeval lcdon_tv;
 /*
  * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial
@@ -317,53 +312,10 @@ inline void lcd_off_procedure(enum device_flags flag)
        enter_doze();
 }
 
-static void update_display_time(void)
-{
-       int run_timeout, val;
-
-       /* first priority : custom timeout */
-       if (custom_normal_timeout > 0) {
-               states[S_NORMAL].timeout = custom_normal_timeout;
-               states[S_LCDDIM].timeout = custom_dim_timeout;
-               _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)",
-                   custom_normal_timeout, custom_dim_timeout);
-               return;
-       }
-
-       /* second priority : lock state */
-       if ((__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) &&
-           !get_lock_screen_bg_state()) {
-               /* timeout is different according to key or event. */
-               states[S_NORMAL].timeout = lock_screen_timeout;
-               _I("LOCK: Timeout(%d ms) is set by normal.",
-                   lock_screen_timeout);
-               return;
-       }
-
-       /* default setting */
-       get_run_timeout(&run_timeout);
-
-       /* for sdk
-        * if the run_timeout is zero, it regards AlwaysOn state
-        */
-       if (run_timeout == 0 || display_conf.lcd_always_on) {
-               run_timeout = ALWAYS_ON_TIMEOUT;
-               _I("LCD always on.");
-       }
-
-       states[S_NORMAL].timeout = run_timeout;
-
-       get_dim_timeout(&val);
-       states[S_LCDDIM].timeout = val;
-
-       _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout);
-       _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout);
-}
-
 static void update_display_locktime(int time)
 {
-       lock_screen_timeout = time;
-       update_display_time();
+       display_state_transition_set_lock_screen_timeout(time);
+       display_state_transition_update_display_state_timeout_by_priority();
 }
 
 void lcd_on_direct(enum device_flags flags)
@@ -422,7 +374,7 @@ int custom_lcdon(int timeout)
 
        _I("Custom lcd on timeout(%d ms).", timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -466,7 +418,7 @@ int custom_lcdoff(enum device_flags flag)
                lcd_off_procedure(flag);
 
        if (set_custom_lcdon_timeout(0) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -507,7 +459,7 @@ int display_on_by_reason(const char *reason, int timeout)
 
        _I("platform lcd on by %s (%d ms)", reason, timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -603,7 +555,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid)
                if (display_panel_get_dpms_cached_state() == DPMS_ON)
                        lcd_off_procedure(LCD_OFF_BY_EVENT);
                if (set_custom_lcdon_timeout(0))
-                       update_display_time();
+                       display_state_transition_update_display_state_timeout_by_priority();
                default_proc_change_state_action(next, -1);
                break;
        case S_SLEEP:
@@ -869,7 +821,7 @@ static int default_trans(int evt)
 
                if ((get_pm_cur_state() == S_NORMAL) || (get_pm_cur_state() == S_LCDOFF))
                        if (set_custom_lcdon_timeout(0) == true)
-                               update_display_time();
+                               display_state_transition_update_display_state_timeout_by_priority();
 
                if (check_lcdoff_direct() == true) {
                        /* enter next state directly */
@@ -1155,7 +1107,7 @@ static int update_setting(int key_idx, int val)
 
        switch (key_idx) {
        case SETTING_TO_NORMAL:
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOW_BATT:
@@ -1218,13 +1170,13 @@ static int update_setting(int key_idx, int val)
                        is_lcdon_blocked() == LCDON_BLOCK_NONE)
                        lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT);
                stop_lock_timer();
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOCK_SCREEN_BG:
                set_lock_screen_bg_state(val);
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
@@ -1248,6 +1200,7 @@ static void check_seed_status(void)
        int bat_state;
        int brt = 0;
        int lock_state;
+       int lock_screen_timeout = 0;
 
        /* Charging check */
        if (fp_get_charging_status && (fp_get_charging_status(&tmp) == 0) && (tmp > 0))
@@ -1287,6 +1240,7 @@ static void check_seed_status(void)
                _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno());
        }
        set_lock_screen_state(lock_state);
+       display_state_transition_get_lock_screen_timeout(&lock_screen_timeout);
        if (lock_state == VCONFKEY_IDLE_LOCK) {
                states[S_NORMAL].timeout = lock_screen_timeout;
                _I("LCD NORMAL timeout(%d ms) is set"
@@ -1337,19 +1291,23 @@ static const char *errMSG[INIT_END] = {
 
 int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
 {
+       unsigned int custom_normal_timeout = 0;
+       unsigned int custom_dim_timeout = 0;
+
        if (on == 0 && dim == 0) {
                _I("LCD timeout changed: default setting");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        } else if (on < 0 || dim < 0) {
                _E("Failed to set value(on=%d dim=%d).", on, dim);
                return -EINVAL;
        } else {
                _I("LCD timeout changed: on=%ds dim=%ds", on, dim);
-               custom_normal_timeout = SEC_TO_MSEC(on);
-               custom_dim_timeout = SEC_TO_MSEC(dim);
+               display_state_transition_set_custom_timeout(S_NORMAL, SEC_TO_MSEC(on));
+               display_state_transition_set_custom_timeout(S_LCDDIM, SEC_TO_MSEC(dim));
        }
        /* Apply new backlight time */
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 
@@ -1366,6 +1324,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
                custom_change_name = 0;
        }
 
+       display_state_transition_get_custom_timeout(S_NORMAL, &custom_normal_timeout);
+       display_state_transition_get_custom_timeout(S_LCDDIM, &custom_dim_timeout);
        if (custom_normal_timeout == 0 &&
            custom_dim_timeout == 0 &&
            !holdkey_block)
@@ -1374,7 +1334,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
        custom_change_name = strndup(name, strlen(name));
        if (!custom_change_name) {
                _E("Failed to malloc.");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
                display_lock_set_custom_holdkey_block(false);
                return -ENOMEM;
        }
@@ -1400,10 +1361,11 @@ void reset_lcd_timeout(GDBusConnection *conn,
 
        free(custom_change_name);
        custom_change_name = 0;
-       custom_normal_timeout = custom_dim_timeout = 0;
+       display_state_transition_set_custom_timeout(S_NORMAL, 0);
+       display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        display_lock_set_custom_holdkey_block(false);
 
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 }

diff --git a/plugins/mobile/display/core.c b/plugins/mobile/display/core.c
index 33e50d8..a5bda11 100644 (file)
--- a/plugins/mobile/display/core.c
+++ b/plugins/mobile/display/core.c
@@ -79,7 +79,6 @@
  * @{
  */
 
-#define LOCK_SCREEN_INPUT_TIMEOUT      10000
 #define LOCK_SCREEN_CONTROL_TIMEOUT    5000
 #define ALWAYS_ON_TIMEOUT              360000000
 
@@ -103,11 +102,8 @@ static void (*power_saving_func) (int onoff);
 static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT;
 
 static int system_wakeup_flag = false;
-static unsigned int custom_normal_timeout = 0;
-static unsigned int custom_dim_timeout = 0;
 static char *custom_change_name;
 static guint lock_timeout_id;
-static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT;
 static struct timeval lcdon_tv;
 /*
  * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial
@@ -324,53 +320,10 @@ inline void lcd_off_procedure(enum device_flags flag)
        enter_doze();
 }
 
-static void update_display_time(void)
-{
-       int run_timeout, val;
-
-       /* first priority : custom timeout */
-       if (custom_normal_timeout > 0) {
-               states[S_NORMAL].timeout = custom_normal_timeout;
-               states[S_LCDDIM].timeout = custom_dim_timeout;
-               _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)",
-                   custom_normal_timeout, custom_dim_timeout);
-               return;
-       }
-
-       /* second priority : lock state */
-       if ((__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) &&
-           !get_lock_screen_bg_state()) {
-               /* timeout is different according to key or event. */
-               states[S_NORMAL].timeout = lock_screen_timeout;
-               _I("LOCK: Timeout(%d ms) is set by normal.",
-                   lock_screen_timeout);
-               return;
-       }
-
-       /* default setting */
-       get_run_timeout(&run_timeout);
-
-       /* for sdk
-        * if the run_timeout is zero, it regards AlwaysOn state
-        */
-       if (run_timeout == 0 || display_conf.lcd_always_on) {
-               run_timeout = ALWAYS_ON_TIMEOUT;
-               _I("LCD always on.");
-       }
-
-       states[S_NORMAL].timeout = run_timeout;
-
-       get_dim_timeout(&val);
-       states[S_LCDDIM].timeout = val;
-
-       _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout);
-       _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout);
-}
-
 static void update_display_locktime(int time)
 {
-       lock_screen_timeout = time;
-       update_display_time();
+       display_state_transition_set_lock_screen_timeout(time);
+       display_state_transition_update_display_state_timeout_by_priority();
 }
 
 void lcd_on_direct(enum device_flags flags)
@@ -429,7 +382,7 @@ int custom_lcdon(int timeout)
 
        _I("Custom lcd on timeout(%d ms).", timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -473,7 +426,7 @@ int custom_lcdoff(enum device_flags flag)
                lcd_off_procedure(flag);
 
        if (set_custom_lcdon_timeout(0) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -514,7 +467,7 @@ int display_on_by_reason(const char *reason, int timeout)
 
        _I("platform lcd on by %s (%d ms)", reason, timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -614,7 +567,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid)
                        lcd_off_procedure(LCD_OFF_BY_EVENT);
                }
                if (set_custom_lcdon_timeout(0))
-                       update_display_time();
+                       display_state_transition_update_display_state_timeout_by_priority();
                default_proc_change_state_action(next, -1);
                break;
        case S_SLEEP:
@@ -879,7 +832,7 @@ static int default_trans(int evt)
 
                if ((get_pm_cur_state() == S_NORMAL) || (get_pm_cur_state() == S_LCDOFF))
                        if (set_custom_lcdon_timeout(0) == true)
-                               update_display_time();
+                               display_state_transition_update_display_state_timeout_by_priority();
 
                if (check_lcdoff_direct() == true) {
                        /* enter next state directly */
@@ -1165,7 +1118,7 @@ static int update_setting(int key_idx, int val)
 
        switch (key_idx) {
        case SETTING_TO_NORMAL:
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOW_BATT:
@@ -1228,13 +1181,13 @@ static int update_setting(int key_idx, int val)
                        is_lcdon_blocked() == LCDON_BLOCK_NONE)
                        lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT);
                stop_lock_timer();
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOCK_SCREEN_BG:
                set_lock_screen_bg_state(val);
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
@@ -1258,6 +1211,7 @@ static void check_seed_status(void)
        int bat_state;
        int brt = 0;
        int lock_state;
+       int lock_screen_timeout = 0;
 
        /* Charging check */
        if (fp_get_charging_status && (fp_get_charging_status(&tmp) == 0) && (tmp > 0))
@@ -1297,6 +1251,7 @@ static void check_seed_status(void)
                _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno());
        }
        set_lock_screen_state(lock_state);
+       display_state_transition_get_lock_screen_timeout(&lock_screen_timeout);
        if (lock_state == VCONFKEY_IDLE_LOCK) {
                states[S_NORMAL].timeout = lock_screen_timeout;
                _I("LCD NORMAL timeout(%d ms) is set"
@@ -1347,19 +1302,23 @@ static const char *errMSG[INIT_END] = {
 
 int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
 {
+       unsigned int custom_normal_timeout = 0;
+       unsigned int custom_dim_timeout = 0;
+
        if (on == 0 && dim == 0) {
                _I("LCD timeout changed: default setting");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        } else if (on < 0 || dim < 0) {
                _E("Failed to set value(on=%d dim=%d).", on, dim);
                return -EINVAL;
        } else {
                _I("LCD timeout changed: on=%ds dim=%ds", on, dim);
-               custom_normal_timeout = SEC_TO_MSEC(on);
-               custom_dim_timeout = SEC_TO_MSEC(dim);
+               display_state_transition_set_custom_timeout(S_NORMAL, SEC_TO_MSEC(on));
+               display_state_transition_set_custom_timeout(S_LCDDIM, SEC_TO_MSEC(dim));
        }
        /* Apply new backlight time */
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 
@@ -1376,6 +1335,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
                custom_change_name = 0;
        }
 
+       display_state_transition_get_custom_timeout(S_NORMAL, &custom_normal_timeout);
+       display_state_transition_get_custom_timeout(S_LCDDIM, &custom_dim_timeout);
        if (custom_normal_timeout == 0 &&
            custom_dim_timeout == 0 &&
            !holdkey_block)
@@ -1384,7 +1345,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
        custom_change_name = strndup(name, strlen(name));
        if (!custom_change_name) {
                _E("Failed to malloc.");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
                display_lock_set_custom_holdkey_block(false);
                return -ENOMEM;
        }
@@ -1410,10 +1372,11 @@ void reset_lcd_timeout(GDBusConnection *conn,
 
        free(custom_change_name);
        custom_change_name = 0;
-       custom_normal_timeout = custom_dim_timeout = 0;
+       display_state_transition_set_custom_timeout(S_NORMAL, 0);
+       display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        display_lock_set_custom_holdkey_block(false);
 
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 }

diff --git a/plugins/tv/display/core.c b/plugins/tv/display/core.c
index 968eae4..6794768 100644 (file)
--- a/plugins/tv/display/core.c
+++ b/plugins/tv/display/core.c
@@ -77,9 +77,7 @@
  * @{
  */
 
-#define LOCK_SCREEN_INPUT_TIMEOUT      10000
 #define LOCK_SCREEN_CONTROL_TIMEOUT    5000
-#define ALWAYS_ON_TIMEOUT              360000000
 
 #define GESTURE_STR            "gesture"
 #define POWER_KEY_STR          "powerkey"
@@ -101,11 +99,8 @@ static void (*power_saving_func) (int onoff);
 static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT;
 
 static int system_wakeup_flag = false;
-static unsigned int custom_normal_timeout = 0;
-static unsigned int custom_dim_timeout = 0;
 static char *custom_change_name;
 static guint lock_timeout_id;
-static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT;
 static struct timeval lcdon_tv;
 /*
  * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial
@@ -317,53 +312,10 @@ inline void lcd_off_procedure(enum device_flags flag)
        enter_doze();
 }
 
-static void update_display_time(void)
-{
-       int run_timeout, val;
-
-       /* first priority : custom timeout */
-       if (custom_normal_timeout > 0) {
-               states[S_NORMAL].timeout = custom_normal_timeout;
-               states[S_LCDDIM].timeout = custom_dim_timeout;
-               _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)",
-                   custom_normal_timeout, custom_dim_timeout);
-               return;
-       }
-
-       /* second priority : lock state */
-       if ((__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) &&
-           !get_lock_screen_bg_state()) {
-               /* timeout is different according to key or event. */
-               states[S_NORMAL].timeout = lock_screen_timeout;
-               _I("LOCK: Timeout(%d ms) is set by normal.",
-                   lock_screen_timeout);
-               return;
-       }
-
-       /* default setting */
-       get_run_timeout(&run_timeout);
-
-       /* for sdk
-        * if the run_timeout is zero, it regards AlwaysOn state
-        */
-       if (run_timeout == 0 || display_conf.lcd_always_on) {
-               run_timeout = ALWAYS_ON_TIMEOUT;
-               _I("LCD always on.");
-       }
-
-       states[S_NORMAL].timeout = run_timeout;
-
-       get_dim_timeout(&val);
-       states[S_LCDDIM].timeout = val;
-
-       _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout);
-       _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout);
-}
-
 static void update_display_locktime(int time)
 {
-       lock_screen_timeout = time;
-       update_display_time();
+       display_state_transition_set_lock_screen_timeout(time);
+       display_state_transition_update_display_state_timeout_by_priority();
 }
 
 void lcd_on_direct(enum device_flags flags)
@@ -422,7 +374,7 @@ int custom_lcdon(int timeout)
 
        _I("Custom lcd on timeout(%d ms).", timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -466,7 +418,7 @@ int custom_lcdoff(enum device_flags flag)
                lcd_off_procedure(flag);
 
        if (set_custom_lcdon_timeout(0) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -507,7 +459,7 @@ int display_on_by_reason(const char *reason, int timeout)
 
        _I("platform lcd on by %s (%d ms)", reason, timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -603,7 +555,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid)
                if (display_panel_get_dpms_cached_state() == DPMS_ON)
                        lcd_off_procedure(LCD_OFF_BY_EVENT);
                if (set_custom_lcdon_timeout(0))
-                       update_display_time();
+                       display_state_transition_update_display_state_timeout_by_priority();
                default_proc_change_state_action(next, -1);
                break;
        case S_SLEEP:
@@ -869,7 +821,7 @@ static int default_trans(int evt)
 
                if ((get_pm_cur_state() == S_NORMAL) || (get_pm_cur_state() == S_LCDOFF))
                        if (set_custom_lcdon_timeout(0) == true)
-                               update_display_time();
+                               display_state_transition_update_display_state_timeout_by_priority();
 
                if (check_lcdoff_direct() == true) {
                        /* enter next state directly */
@@ -1155,7 +1107,7 @@ static int update_setting(int key_idx, int val)
 
        switch (key_idx) {
        case SETTING_TO_NORMAL:
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOW_BATT:
@@ -1218,13 +1170,13 @@ static int update_setting(int key_idx, int val)
                        is_lcdon_blocked() == LCDON_BLOCK_NONE)
                        lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT);
                stop_lock_timer();
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOCK_SCREEN_BG:
                set_lock_screen_bg_state(val);
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
@@ -1248,6 +1200,7 @@ static void check_seed_status(void)
        int bat_state;
        int brt = 0;
        int lock_state;
+       int lock_screen_timeout = 0;
 
        /* Charging check */
        if (fp_get_charging_status && (fp_get_charging_status(&tmp) == 0) && (tmp > 0))
@@ -1287,6 +1240,7 @@ static void check_seed_status(void)
                _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno());
        }
        set_lock_screen_state(lock_state);
+       display_state_transition_get_lock_screen_timeout(&lock_screen_timeout);
        if (lock_state == VCONFKEY_IDLE_LOCK) {
                states[S_NORMAL].timeout = lock_screen_timeout;
                _I("LCD NORMAL timeout(%d ms) is set"
@@ -1337,19 +1291,23 @@ static const char *errMSG[INIT_END] = {
 
 int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
 {
+       unsigned int custom_normal_timeout = 0;
+       unsigned int custom_dim_timeout = 0;
+
        if (on == 0 && dim == 0) {
                _I("LCD timeout changed: default setting");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        } else if (on < 0 || dim < 0) {
                _E("Failed to set value(on=%d dim=%d).", on, dim);
                return -EINVAL;
        } else {
                _I("LCD timeout changed: on=%ds dim=%ds", on, dim);
-               custom_normal_timeout = SEC_TO_MSEC(on);
-               custom_dim_timeout = SEC_TO_MSEC(dim);
+               display_state_transition_set_custom_timeout(S_NORMAL, SEC_TO_MSEC(on));
+               display_state_transition_set_custom_timeout(S_LCDDIM, SEC_TO_MSEC(dim));
        }
        /* Apply new backlight time */
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 
@@ -1366,6 +1324,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
                custom_change_name = 0;
        }
 
+       display_state_transition_get_custom_timeout(S_NORMAL, &custom_normal_timeout);
+       display_state_transition_get_custom_timeout(S_LCDDIM, &custom_dim_timeout);
        if (custom_normal_timeout == 0 &&
            custom_dim_timeout == 0 &&
            !holdkey_block)
@@ -1374,7 +1334,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
        custom_change_name = strndup(name, strlen(name));
        if (!custom_change_name) {
                _E("Failed to malloc.");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
                display_lock_set_custom_holdkey_block(false);
                return -ENOMEM;
        }
@@ -1400,10 +1361,11 @@ void reset_lcd_timeout(GDBusConnection *conn,
 
        free(custom_change_name);
        custom_change_name = 0;
-       custom_normal_timeout = custom_dim_timeout = 0;
+       display_state_transition_set_custom_timeout(S_NORMAL, 0);
+       display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        display_lock_set_custom_holdkey_block(false);
 
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 }

diff --git a/plugins/wearable/display/core.c b/plugins/wearable/display/core.c
index 7fa444b..600c6f2 100644 (file)
--- a/plugins/wearable/display/core.c
+++ b/plugins/wearable/display/core.c
@@ -85,9 +85,7 @@
  * @{
  */
 
-#define LOCK_SCREEN_INPUT_TIMEOUT      10000
 #define LOCK_SCREEN_CONTROL_TIMEOUT    5000
-#define ALWAYS_ON_TIMEOUT              360000000
 #define LATE_LCD_TRANSIT               1
 
 #define GESTURE_STR         "gesture"
@@ -113,12 +111,9 @@ static void (*power_saving_func) (int onoff);
 static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT;
 
 static int system_wakeup_flag = false;
-static unsigned int custom_normal_timeout = 0;
-static unsigned int custom_dim_timeout = 0;
 static char *custom_change_name;
 static guint lock_timeout_id;
 static guint transit_timer;
-static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT;
 static struct timeval lcdon_tv;
 /*
  * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial
@@ -612,59 +607,16 @@ inline void lcd_off_procedure(enum device_flags flag)
        enter_doze();
 }
 
-static void update_display_time(void)
-{
-       int run_timeout, val;
-
-       /* first priority : custom timeout */
-       if (custom_normal_timeout > 0) {
-               states[S_NORMAL].timeout = custom_normal_timeout;
-               states[S_LCDDIM].timeout = custom_dim_timeout;
-               _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)",
-                   custom_normal_timeout, custom_dim_timeout);
-               return;
-       }
-
-       /* second priority : lock state */
-       if ((__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) &&
-           !get_lock_screen_bg_state()) {
-               /* timeout is different according to key or event. */
-               states[S_NORMAL].timeout = lock_screen_timeout;
-               _I("LOCK: Timeout(%d ms) is set by normal.",
-                   lock_screen_timeout);
-               return;
-       }
-
-       /* default setting */
-       get_run_timeout(&run_timeout);
-
-       /* for sdk
-        * if the run_timeout is zero, it regards AlwaysOn state
-        */
-       if (run_timeout == 0 || display_conf.lcd_always_on) {
-               run_timeout = ALWAYS_ON_TIMEOUT;
-               _I("LCD always on.");
-       }
-
-       states[S_NORMAL].timeout = run_timeout;
-
-       get_dim_timeout(&val);
-       states[S_LCDDIM].timeout = val;
-
-       _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout);
-       _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout);
-}
-
 static void update_display_locktime(int time)
 {
-       lock_screen_timeout = time;
-       update_display_time();
+       display_state_transition_set_lock_screen_timeout(time);
+       display_state_transition_update_display_state_timeout_by_priority();
 }
 
 static void set_dim_state(bool on)
 {
        _I("Dim state is %d.", on);
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        states[get_pm_cur_state()].trans(EVENT_INPUT);
 }
 
@@ -714,7 +666,7 @@ static gboolean timer_refresh_cb(gpointer data)
         * When the device's screen is another app, it will do turn off after 7 seconds.
         */
        if (set_custom_lcdon_timeout(5000) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -751,7 +703,7 @@ int custom_lcdon(int timeout)
        }
 
        if (update)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -796,7 +748,7 @@ int custom_lcdoff(enum device_flags flag)
                lcd_off_procedure(flag);
 
        if (set_custom_lcdon_timeout(0) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -837,7 +789,7 @@ int display_on_by_reason(const char *reason, int timeout)
 
        _I("platform lcd on by %s (%d ms)", reason, timeout);
        if (set_custom_lcdon_timeout(timeout) == true)
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
 
        /* state transition */
        set_pm_old_state(get_pm_cur_state());
@@ -938,7 +890,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid)
                if (display_panel_get_dpms_cached_state() == DPMS_ON)
                        lcd_off_procedure(LCD_OFF_BY_EVENT);
                if (set_custom_lcdon_timeout(0))
-                       update_display_time();
+                       display_state_transition_update_display_state_timeout_by_priority();
                default_proc_change_state_action(next, -1);
                break;
        case S_SLEEP:
@@ -1213,7 +1165,7 @@ static int default_trans(int evt)
 
                if ((get_pm_cur_state() == S_NORMAL) || (get_pm_cur_state() == S_LCDOFF))
                        if (set_custom_lcdon_timeout(0) == true)
-                               update_display_time();
+                               display_state_transition_update_display_state_timeout_by_priority();
 
                if (check_lcdoff_direct() == true) {
                        /* enter next state directly */
@@ -1511,7 +1463,7 @@ static int update_setting(int key_idx, int val)
 
        switch (key_idx) {
        case SETTING_TO_NORMAL:
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOW_BATT:
@@ -1572,13 +1524,13 @@ static int update_setting(int key_idx, int val)
                        is_lcdon_blocked() == LCDON_BLOCK_NONE)
                        lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT);
                stop_lock_timer();
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
        case SETTING_LOCK_SCREEN_BG:
                set_lock_screen_bg_state(val);
-               update_display_time();
+               display_state_transition_update_display_state_timeout_by_priority();
                if (get_pm_cur_state() == S_NORMAL)
                        states[get_pm_cur_state()].trans(EVENT_INPUT);
                break;
@@ -1602,6 +1554,7 @@ static void check_seed_status(void)
        int bat_state;
        int brt = 0;
        int lock_state;
+       int lock_screen_timeout = 0;
 
        /* Charging check */
        if (fp_get_charging_status && (fp_get_charging_status(&tmp) == 0) && (tmp > 0))
@@ -1641,6 +1594,7 @@ static void check_seed_status(void)
                _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno());
        }
        set_lock_screen_state(lock_state);
+       display_state_transition_get_lock_screen_timeout(&lock_screen_timeout);
        if (lock_state == VCONFKEY_IDLE_LOCK) {
                states[S_NORMAL].timeout = lock_screen_timeout;
                _I("LCD NORMAL timeout(%d ms) is set"
@@ -1691,19 +1645,23 @@ static const char *errMSG[INIT_END] = {
 
 int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
 {
+       unsigned int custom_normal_timeout = 0;
+       unsigned int custom_dim_timeout = 0;
+
        if (on == 0 && dim == 0) {
                _I("LCD timeout changed: default setting");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        } else if (on < 0 || dim < 0) {
                _E("Failed to set value(on=%d dim=%d).", on, dim);
                return -EINVAL;
        } else {
                _I("LCD timeout changed: on=%ds dim=%ds", on, dim);
-               custom_normal_timeout = SEC_TO_MSEC(on);
-               custom_dim_timeout = SEC_TO_MSEC(dim);
+               display_state_transition_set_custom_timeout(S_NORMAL, SEC_TO_MSEC(on));
+               display_state_transition_set_custom_timeout(S_LCDDIM, SEC_TO_MSEC(dim));
        }
        /* Apply new backlight time */
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 
@@ -1720,6 +1678,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
                custom_change_name = 0;
        }
 
+       display_state_transition_get_custom_timeout(S_NORMAL, &custom_normal_timeout);
+       display_state_transition_get_custom_timeout(S_LCDDIM, &custom_dim_timeout);
        if (custom_normal_timeout == 0 &&
            custom_dim_timeout == 0 &&
            !holdkey_block)
@@ -1728,7 +1688,8 @@ int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name)
        custom_change_name = strndup(name, strlen(name));
        if (!custom_change_name) {
                _E("Failed to malloc.");
-               custom_normal_timeout = custom_dim_timeout = 0;
+               display_state_transition_set_custom_timeout(S_NORMAL, 0);
+               display_state_transition_set_custom_timeout(S_LCDDIM, 0);
                display_lock_set_custom_holdkey_block(false);
                return -ENOMEM;
        }
@@ -1754,10 +1715,11 @@ void reset_lcd_timeout(GDBusConnection *conn,
 
        free(custom_change_name);
        custom_change_name = 0;
-       custom_normal_timeout = custom_dim_timeout = 0;
+       display_state_transition_set_custom_timeout(S_NORMAL, 0);
+       display_state_transition_set_custom_timeout(S_LCDDIM, 0);
        display_lock_set_custom_holdkey_block(false);
 
-       update_display_time();
+       display_state_transition_update_display_state_timeout_by_priority();
        if (get_pm_cur_state() == S_NORMAL)
                states[get_pm_cur_state()].trans(EVENT_INPUT);
 }

diff --git a/src/display/display-plugin.c b/src/display/display-plugin.c
index 14d1863..9985701 100644 (file)
--- a/src/display/display-plugin.c
+++ b/src/display/display-plugin.c
@@ -250,6 +250,19 @@ int display_plugin_config_get_lcdoff_timeout(int *lcdoff_timeout)
        return -EOPNOTSUPP;
 }
 
+int display_plugin_config_get_lcd_always_on(int *lcd_always_on)
+{
+       if (!lcd_always_on)
+               return -EINVAL;
+
+       if (g_display_plugin.config) {
+               *lcd_always_on = g_display_plugin.config->lcd_always_on;
+               return 0;
+       }
+
+       return -EOPNOTSUPP;
+}
+
 int display_plugin_set_dim_state(bool on)
 {
        if (g_display_plugin.set_dim_state) {

diff --git a/src/display/display-plugin.h b/src/display/display-plugin.h
index e66a7c4..fe88489 100644 (file)
--- a/src/display/display-plugin.h
+++ b/src/display/display-plugin.h
@@ -106,5 +106,6 @@ int display_plugin_state_get_state_by_state_index(int state_index, enum state_t
 /* FIXME: display config getter/setter is also temporary in this file */
 int display_plugin_config_get_timeout_enable(bool *timeout_enable);
 int display_plugin_config_get_lcdoff_timeout(int *lcdoff_timeout);
+int display_plugin_config_get_lcd_always_on(int *lcd_always_on);
 
 #endif //__DISPLAY_PLUGIN_H__

diff --git a/src/display/display-state-transition.c b/src/display/display-state-transition.c
index d61667c..5676860 100644 (file)
--- a/src/display/display-state-transition.c
+++ b/src/display/display-state-transition.c
@@ -23,11 +23,17 @@
 
 #include "device-interface.h"
 #include "display-state-transition.h"
+#include "display-lock.h"
 #include "display-plugin.h"
 #include "power/power-suspend.h"
 #include "shared/log.h"
 
+#define ALWAYS_ON_TIMEOUT              360000000
+
 static guint state_transition_timer_id;
+static unsigned int custom_normal_timeout = 0;
+static unsigned int custom_dim_timeout = 0;
+static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT;
 
 static int trans_table[S_END][EVENT_END] = {
        /* Timeout,   Input */
@@ -116,4 +122,106 @@ int display_state_transition_reset_state_transition_timeout(int timeout)
                display_plugin_state_do_default_trans(get_pm_cur_state(), EVENT_TIMEOUT);
 
        return 0;
+}
+
+int display_state_transition_set_custom_timeout(enum state_t state, unsigned int timeout)
+{
+       const char *state_name = NULL;
+
+       switch (state) {
+       case S_NORMAL:
+               custom_normal_timeout = timeout;
+       case S_LCDDIM:
+               custom_dim_timeout = timeout;
+       default:
+               display_plugin_state_get_name(state, &state_name);
+               _W("%s state has no custom timeout", state_name);
+               return -EPERM;
+       }
+       return 0;
+}
+
+int display_state_transition_get_custom_timeout(enum state_t state, unsigned int *timeout)
+{
+       if (!timeout)
+               return -EINVAL;
+
+       const char *state_name = NULL;
+
+       switch (state) {
+       case S_NORMAL:
+               *timeout = custom_normal_timeout;
+       case S_LCDDIM:
+               *timeout = custom_dim_timeout;
+       default:
+               *timeout = 0;
+               display_plugin_state_get_name(state, &state_name);
+               _W("There is no specific timeout value for %s state", state_name);
+       }
+       return 0;
+}
+
+
+int display_state_transition_set_lock_screen_timeout(int timeout)
+{
+       lock_screen_timeout = timeout;
+       return 0;
+}
+
+int display_state_transition_get_lock_screen_timeout(int *timeout)
+{
+       if (!timeout)
+               return -EINVAL;
+
+       *timeout = lock_screen_timeout;
+       return 0;
+}
+
+void display_state_transition_update_display_state_timeout_by_priority(void)
+{
+       int run_timeout, val;
+       int lcd_always_on = 0;
+       int normal_state_timeout = 0;
+       int dim_state_timeout = 0;
+
+       /* first priority : custom timeout */
+       if (custom_normal_timeout > 0) {
+               display_plugin_state_set_timeout(S_NORMAL, custom_normal_timeout);
+               display_plugin_state_set_timeout(S_LCDDIM, custom_dim_timeout);
+               _I("CUSTOM : timeout is set by normal(%u ms), dim(%u ms)",
+                   custom_normal_timeout, custom_dim_timeout);
+               return;
+       }
+
+       /* second priority : lock state */
+       if ((__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) &&
+           !get_lock_screen_bg_state()) {
+               /* timeout is different according to key or event. */
+               display_plugin_state_set_timeout(S_NORMAL, lock_screen_timeout);
+               _I("LOCK: Timeout(%d ms) is set by normal.",
+                   lock_screen_timeout);
+               return;
+       }
+
+       /* default setting */
+       get_run_timeout(&run_timeout);
+
+       /* for sdk
+        * if the run_timeout is zero, it regards AlwaysOn state
+        */
+       display_plugin_config_get_lcd_always_on(&lcd_always_on);
+       if (run_timeout == 0 || lcd_always_on) {
+               run_timeout = ALWAYS_ON_TIMEOUT;
+               _I("LCD always on.");
+       }
+
+       display_plugin_state_set_timeout(S_NORMAL, run_timeout);
+
+       get_dim_timeout(&val);
+       display_plugin_state_set_timeout(S_LCDDIM, val);
+
+       display_plugin_state_get_timeout(S_NORMAL, &normal_state_timeout);
+       display_plugin_state_get_timeout(S_LCDDIM, &dim_state_timeout);
+       _I("Normal: NORMAL timeout is set by %d ms", normal_state_timeout);
+       _I("Normal: DIM timeout is set by %d ms", dim_state_timeout);
 }
\ No newline at end of file

diff --git a/src/display/display-state-transition.h b/src/display/display-state-transition.h
index a8bab4d..51762a1 100644 (file)
--- a/src/display/display-state-transition.h
+++ b/src/display/display-state-transition.h
@@ -26,9 +26,16 @@
 
 #include "core.h"
 
+#define LOCK_SCREEN_INPUT_TIMEOUT      10000
+
 int display_state_transition_get_next_transition_display_state(enum state_t from_state, enum state_t *to_state, int evt_type);
 int display_state_transition_set_transition_table_display_state(enum state_t display_state, enum state_t set_state, int evt_type);
 bool display_state_transition_is_there_state_transition_timer(void);
 int display_state_transition_reset_state_transition_timeout(int timeout);
+int display_state_transition_set_custom_timeout(enum state_t state, unsigned int timeout);
+int display_state_transition_get_custom_timeout(enum state_t state, unsigned int *timeout);
+int display_state_transition_set_lock_screen_timeout(int timeout);
+int display_state_transition_get_lock_screen_timeout(int *timeout);
+void display_state_transition_update_display_state_timeout_by_priority(void);
 
 #endif /* __DISPLAY_STATE_TRANSITION_H__ */
\ No newline at end of file