SET(SRCS
src/apps/apps.c
src/control/control.c
- src/core/late-booting-done-notifier.c
+ src/core/delayed-init-notifier.c
src/core/devices.c
src/core/event-handler.c
src/core/execute.c
#define S_COVER_TIMEOUT 8000
#define GET_HOLDKEY_BLOCK_STATE(x) ((x >> SHIFT_LOCK_FLAG) & HOLD_KEY_BLOCK_BIT)
-#define BOOTING_DONE_WATING_TIME 60000 /* 1 minute */
+#define DELAYED_INIT_WATING_TIME 60000 /* 1 minute */
#define LOCK_SCREEN_WATING_TIME 300 /* 0.3 second */
#define LONG_PRESS_INTERVAL 2 /* 2 seconds */
states[get_pm_cur_state()].trans(EVENT_INPUT);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static bool done = false;
return 0;
}
-static gboolean delayed_init_dpms(gpointer data)
+static gboolean delayed_init_done_dpms(gpointer data)
{
int timeout;
static void add_timer_for_init_dpms(void)
{
- guint id = g_timeout_add(500/* milliseconds */, delayed_init_dpms, NULL);
+ guint id = g_timeout_add(500/* milliseconds */, delayed_init_done_dpms, NULL);
if (id == 0)
_E("Failed to add init_dpms timeout.");
}
register_kernel_uevent_control(&lcd_uevent_ops);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
register_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
register_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
*/
if (disp_plgn->pm_lock_internal)
disp_plgn->pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF,
- STAY_CUR_STATE, BOOTING_DONE_WATING_TIME);
+ STAY_CUR_STATE, DELAYED_INIT_WATING_TIME);
/* Initial display state right after the booting done */
if (is_lcdon_blocked())
exit_sysfs();
break;
case INIT_POLL:
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
return 0;
}
-static int booting_done_cb(void *data)
+static int delayed_init_done(void *data)
{
booting_check = 0;
touchled = find_device(TOUCHLED_NAME);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb);
}
#define S_COVER_TIMEOUT 8000
#define GET_HOLDKEY_BLOCK_STATE(x) ((x >> SHIFT_LOCK_FLAG) & HOLD_KEY_BLOCK_BIT)
-#define BOOTING_DONE_WATING_TIME 60000 /* 1 minute */
+#define DELAYED_INIT_WATING_TIME 60000 /* 1 minute */
#define LOCK_SCREEN_WATING_TIME 300 /* 0.3 second */
#define LONG_PRESS_INTERVAL 400 /* 0.4 seconds */
states[get_pm_cur_state()].trans(EVENT_INPUT);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static bool done = false;
return 0;
}
-static gboolean delayed_init_dpms(gpointer data)
+static gboolean delayed_init_done_dpms(gpointer data)
{
int timeout;
static void add_timer_for_init_dpms(void)
{
- guint id = g_timeout_add(500/* milliseconds */, delayed_init_dpms, NULL);
+ guint id = g_timeout_add(500/* milliseconds */, delayed_init_done_dpms, NULL);
if (id == 0)
_E("Failed to add init_dpms timeout.");
}
register_kernel_uevent_control(&lcd_uevent_ops);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
register_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
register_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
*/
if (disp_plgn->pm_lock_internal)
disp_plgn->pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF,
- STAY_CUR_STATE, BOOTING_DONE_WATING_TIME);
+ STAY_CUR_STATE, DELAYED_INIT_WATING_TIME);
/* Initial display state right after the booting done */
if (is_lcdon_blocked())
exit_sysfs();
break;
case INIT_POLL:
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
return hal_device_display_put_backend();
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done = false;
int is_lcdon_blocked(void)
{
/* block lcdon until booting done in silent boot mode */
- if (silent_boot && !booting_done(NULL))
+ if (silent_boot && !delayed_init_done(NULL))
return LCDON_BLOCK_DURING_SILENT_BOOT;
return LCDON_BLOCK_NONE;
int init_sysfs(unsigned int flags)
{
register_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
return 0;
}
return 0;
}
-static int booting_done_cb(void *data)
+static int delayed_init_done(void *data)
{
booting_check = 0;
touchled = find_device(TOUCHLED_NAME);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb);
}
#define S_COVER_TIMEOUT 8000
#define GET_HOLDKEY_BLOCK_STATE(x) ((x >> SHIFT_LOCK_FLAG) & HOLD_KEY_BLOCK_BIT)
-#define BOOTING_DONE_WATING_TIME 60000 /* 1 minute */
+#define DELAYED_INIT_WATING_TIME 60000 /* 1 minute */
#define LOCK_SCREEN_WATING_TIME 300 /* 0.3 second */
#define LONG_PRESS_INTERVAL 2 /* 2 seconds */
states[get_pm_cur_state()].trans(EVENT_INPUT);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static bool done = false;
return 0;
}
-static gboolean delayed_init_dpms(gpointer data)
+static gboolean delayed_init_done_dpms(gpointer data)
{
int timeout;
static void add_timer_for_init_dpms(void)
{
- guint id = g_timeout_add(500/* milliseconds */, delayed_init_dpms, NULL);
+ guint id = g_timeout_add(500/* milliseconds */, delayed_init_done_dpms, NULL);
if (id == 0)
_E("Failed to add init_dpms timeout.");
}
register_kernel_uevent_control(&lcd_uevent_ops);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
register_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
register_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
*/
if (disp_plgn->pm_lock_internal)
disp_plgn->pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF,
- STAY_CUR_STATE, BOOTING_DONE_WATING_TIME);
+ STAY_CUR_STATE, DELAYED_INIT_WATING_TIME);
/* Initial display state right after the booting done */
if (is_lcdon_blocked())
exit_sysfs();
break;
case INIT_POLL:
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
return 0;
}
-static int booting_done_cb(void *data)
+static int delayed_init_done(void *data)
{
booting_check = 0;
touchled = find_device(TOUCHLED_NAME);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb);
}
#define S_COVER_TIMEOUT 8000
#define GET_HOLDKEY_BLOCK_STATE(x) ((x >> SHIFT_LOCK_FLAG) & HOLD_KEY_BLOCK_BIT)
-#define BOOTING_DONE_WATING_TIME 60000 /* 1 minute */
+#define DELAYED_INIT_WATING_TIME 60000 /* 1 minute */
#define LOCK_SCREEN_WATING_TIME 300 /* 0.3 second */
#define LONG_PRESS_INTERVAL 500 /* 0.5 seconds */
states[get_pm_cur_state()].trans(EVENT_INPUT);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static bool done = false;
return 0;
}
-static gboolean delayed_init_dpms(gpointer data)
+static gboolean delayed_init_done_dpms(gpointer data)
{
int timeout;
static void add_timer_for_init_dpms(void)
{
- guint id = g_timeout_add(500/* milliseconds */, delayed_init_dpms, NULL);
+ guint id = g_timeout_add(500/* milliseconds */, delayed_init_done_dpms, NULL);
if (id == 0)
_E("Failed to add init_dpms timeout.");
}
register_kernel_uevent_control(&lcd_uevent_ops);
register_kernel_uevent_control(&sec_dsim_uevent_ops);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
register_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
register_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
*/
if (disp_plgn->pm_lock_internal)
disp_plgn->pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF,
- STAY_CUR_STATE, BOOTING_DONE_WATING_TIME);
+ STAY_CUR_STATE, DELAYED_INIT_WATING_TIME);
/* Initial display state right after the booting done */
if (is_lcdon_blocked())
exit_sysfs();
break;
case INIT_POLL:
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_BACKGROUND, display_app_background);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_FOREGROUND, display_app_foreground);
unregister_notifier(DEVICE_NOTIFIER_APPLICATION_TERMINATED, display_app_terminated);
return 0;
}
-static int booting_done_cb(void *data)
+static int delayed_init_done(void *data)
{
booting_check = 0;
display_add_actor(&display_powerkey_actor);
display_add_actor(&display_menukey_actor);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb);
}
_E("Failed to update powersaver state %d.", ret);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
int ret, status;
static void powersaver_init(void *data)
{
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static void powersaver_exit(void *data)
return ops->execute(data);
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
int status;
static int done;
direct_launch:
_D("Popup value=%s", value);
- if (booting_done(NULL)) {
+ if (delayed_init_done(NULL)) {
if (launched_poweroff == 1) {
_I("Will be foreced power off.");
{
int ret;
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_POWER_SUPPLY, lowbat_monitor_init);
ret = gdbus_add_object(NULL, DEVICED_PATH_BATTERY, &dbus_interface);
bool battery_do_not_disturb(void);
int battery_pm_change_internal(int pid, int s_bits);
-static int booting_done(void *data);
+static int delayed_init_done(void *data);
static void update_health(enum battery_noti_status status);
static bool battery_dev_available = false;
static int load_uevent(struct parse_result *result, void *user_data);
battery_initialized = true;
- ret_val = booting_done(NULL);
+ ret_val = delayed_init_done(NULL);
if (ret_val) {
if (battery.online > POWER_SUPPLY_TYPE_BATTERY)
power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_ON);
if (ret_val != 1)
return;
- ret_val = booting_done(NULL);
+ ret_val = delayed_init_done(NULL);
if (ret_val) {
/* If the same notification is requested repeatedly, it is ignored by power_supply_noti().
* A notification will be triggered only when charge_status changes between
.nr_methods = ARRAY_SIZE(dbus_methods),
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
device_notifier_state_e state = DEVICE_NOTIFIER_STATE_START;
CHARGE_MISC_EVENT_SIGNAL, battery.misc,
CHARGE_HEALTH_SIGNAL, battery.health, battery.health_s);
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
return done;
}
/* process check battery timer until booting done */
power_supply_timer_start();
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_EVENT_HANDLER, event_handler_state_changed);
ret_dbus = gdbus_add_object(NULL, DEVICED_PATH_BATTERY, &dbus_interface);
--- /dev/null
+/*
+ * deviced
+ *
+ * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd.
+ *
+ * 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 "log.h"
+#include "shared/device-notifier.h"
+#include "shared/common.h"
+#include "core/devices.h"
+#include <libsyscommon/libgdbus.h>
+#include <libsyscommon/list.h>
+
+static guint delayed_init_timer;
+
+#define DELAYED_INIT_WAIT_TIME 30 /* second */
+#define DEFAULT_DELAYED_INIT_VALUE (guint)0x0DEF0DEF
+
+static void delayed_init_stop(void)
+{
+ if (delayed_init_timer == 0 || delayed_init_timer == DEFAULT_DELAYED_INIT_VALUE)
+ return;
+
+ g_source_remove(delayed_init_timer);
+ delayed_init_timer = 0;
+}
+
+static int delayed_init_done(void *data)
+{
+ static int done;
+
+ if (data == NULL)
+ goto out;
+
+ done = *(int *)data;
+ if (delayed_init_timer == 0)
+ return done;
+ delayed_init_stop();
+out:
+ return done;
+}
+
+static gboolean delayed_init_timer_cb(void *data)
+{
+ int done;
+
+ delayed_init_stop();
+ delayed_init_timer = 0;
+
+ done = delayed_init_done(NULL);
+ if (done)
+ return G_SOURCE_REMOVE;
+
+ _I("delayed init");
+
+ done = 1;
+ device_notify_once(DEVICE_NOTIFIER_DELAYED_INIT, (void *)&done);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void delayed_init_done_notifier_init(void *data)
+{
+ int ret;
+
+ ret = check_systemd_active();
+ if (ret == TRUE) {
+ _I("restart booting done");
+ return;
+ }
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
+ delayed_init_timer = g_timeout_add_seconds(DELAYED_INIT_WAIT_TIME,
+ delayed_init_timer_cb, NULL);
+
+ if (!delayed_init_timer)
+ delayed_init_timer = DEFAULT_DELAYED_INIT_VALUE;
+}
+
+static void delayed_init_done_notifier_exit(void *data)
+{
+
+}
+
+static const struct device_ops notifier_device_ops = {
+ DECLARE_NAME_LEN("delayed-init-notifier"),
+ .init = delayed_init_done_notifier_init,
+ .exit = delayed_init_done_notifier_exit,
+};
+
+DEVICE_OPS_REGISTER(¬ifier_device_ops)
+++ /dev/null
-/*
- * deviced
- *
- * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd.
- *
- * 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 "log.h"
-#include "shared/device-notifier.h"
-#include "shared/common.h"
-#include "core/devices.h"
-#include <libsyscommon/libgdbus.h>
-#include <libsyscommon/list.h>
-
-static guint late_init_timer;
-
-#define LATE_INIT_WAIT_TIME 30 /* second */
-#define DEFAULT_LATE_INIT_VALUE (guint)0x0DEF0DEF
-
-static void late_init_stop(void)
-{
- if (late_init_timer == 0 || late_init_timer == DEFAULT_LATE_INIT_VALUE)
- return;
-
- g_source_remove(late_init_timer);
- late_init_timer = 0;
-}
-
-static int booting_done(void *data)
-{
- static int done;
-
- if (data == NULL)
- goto out;
-
- done = *(int *)data;
- if (late_init_timer == 0)
- return done;
- late_init_stop();
-out:
- return done;
-}
-
-static int early_booting_done(void *data)
-{
- static int done;
-
- if (data == NULL)
- goto out;
-
- done = *(int *)data;
-out:
- return done;
-}
-
-static gboolean late_init_timer_cb(void *data)
-{
- int done;
-
- late_init_stop();
- done = early_booting_done(NULL);
- if (!done)
- device_notify(DEVICE_NOTIFIER_EARLY_BOOTING_DONE, (void *)&done);
- done = booting_done(NULL);
- late_init_timer = 0;
- if (done)
- return G_SOURCE_REMOVE;
- _I("late booting done");
- done = TRUE;
- device_notify_once(DEVICE_NOTIFIER_BOOTING_DONE, (void *)&done);
- return G_SOURCE_REMOVE;
-}
-
-static void late_booting_done_notifier_init(void *data)
-{
- int ret;
-
- ret = check_systemd_active();
- if (ret == TRUE) {
- _I("restart booting done");
- return;
- }
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
- register_notifier(DEVICE_NOTIFIER_EARLY_BOOTING_DONE, early_booting_done);
- late_init_timer = g_timeout_add_seconds(LATE_INIT_WAIT_TIME,
- late_init_timer_cb, NULL);
-
- if (!late_init_timer)
- late_init_timer = DEFAULT_LATE_INIT_VALUE;
-}
-
-static void late_booting_done_notifier_exit(void *data)
-{
-
-}
-
-static const struct device_ops notifier_device_ops = {
- DECLARE_NAME_LEN("late-booting-done-notifier"),
- .init = late_booting_done_notifier_init,
- .exit = late_booting_done_notifier_exit,
-};
-
-DEVICE_OPS_REGISTER(¬ifier_device_ops)
if (ret == 1) {
/* Restarted: deviced was terminated */
_I("Notify relaunch.");
- device_notify_once(DEVICE_NOTIFIER_BOOTING_DONE, &ret);
+ device_notify_once(DEVICE_NOTIFIER_DELAYED_INIT, &ret);
}
_I("sd_notify(READY=1)");
.nr_methods = ARRAY_SIZE(dbus_methods),
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
int ret = 0;
if (ret < 0)
_E("Failed to init dbus method: %d", ret);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static void pmqos_exit(void *data)
{
/* unregister notifier for each event */
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_CPU_BOOST_LOWBAT, pmqos_lowbat);
unregister_notifier(DEVICE_NOTIFIER_CPU_BOOST_POWEROFF, pmqos_poweroff);
}
return 0;
}
-static int booting_done_cb(void *data)
+static int delayed_init_done(void *data)
{
int state;
display_info.reset_autobrightness_min = reset_autobrightness_min;
register_notifier(DEVICE_NOTIFIER_LCD, lcd_changed_cb);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static void auto_brightness_exit(void *data)
exit_lsensor();
unregister_notifier(DEVICE_NOTIFIER_LCD, lcd_changed_cb);
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static const struct display_ops display_autobrightness_ops = {
static bool extcon_dev_available = false;
static void extcon_deferred_init(void);
-static int booting_done(void *data);
+static int delayed_init_done(void *data);
void add_extcon(struct extcon_ops *dev)
{
char *str;
int ret;
- if (!booting_done(NULL))
+ if (!delayed_init_done(NULL))
extcon_deferred_init();
g_variant_get(param, "(s)", &str);
char *device;
int ret;
- if (!booting_done(NULL))
+ if (!delayed_init_done(NULL))
extcon_deferred_init();
g_variant_get(param, "(s)", &device);
char *device;
int ret;
- if (!booting_done(NULL))
+ if (!delayed_init_done(NULL))
extcon_deferred_init();
g_variant_get(param, "(s)", &device);
initialized = true;
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
if (retval < 0)
_E("Failed to init dbus method: %d", retval);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static void extcon_exit(void *data)
static struct display_plugin *disp_plgn;
static guint sig_id[2] = {0, 0};
-void remove_booting_done_handler(void *data)
+void remove_delayed_init_done_handler(void *data)
{
gdbus_signal_unsubscribe(NULL, sig_id[0]);
gdbus_signal_unsubscribe(NULL, sig_id[1]);
}
-static void booting_done_received(GDBusConnection *conn,
+static void delayed_init_done_received(GDBusConnection *conn,
const gchar *sender,
const gchar *path,
const gchar *iface,
return;
}
CRITICAL_LOG("System session is ready.");
- device_notify_once(DEVICE_NOTIFIER_BOOTING_DONE, &system_done);
+ device_notify_once(DEVICE_NOTIFIER_DELAYED_INIT, &system_done);
} else if (strcmp(name, SYSTEMD_DBUS_SIGNAL_USER_STARTUP_FINISHED) == 0) {
if (user_done)
if (!system_done || !user_done)
return;
- remove_booting_done_handler(NULL);
+ remove_delayed_init_done_handler(NULL);
_I("Real booting done. Unlock LCD_OFF.");
if (disp_plgn->pm_unlock_internal)
doze_init();
}
-void add_booting_done_handler(void *data)
+void add_delayed_init_done_handler(void *data)
{
/* System Session is loaded completely */
/*ret = */
SYSTEMD_DBUS_PATH,
SYSTEMD_DBUS_IFACE_MANAGER,
SYSTEMD_DBUS_SIGNAL_SYSTEM_STARTUP_FINISHED,
- booting_done_received,
+ delayed_init_done_received,
NULL, NULL);
if (sig_id[0] <= 0)
SYSTEMD_DBUS_PATH,
SYSTEMD_DBUS_IFACE_MANAGER,
SYSTEMD_DBUS_SIGNAL_USER_STARTUP_FINISHED,
- booting_done_received,
+ delayed_init_done_received,
NULL, NULL);
if (sig_id[1] <= 0)
#ifndef __DEVICED_BOOT_H__
#define __DEVICED_BOOT_H__
-void add_booting_done_handler(void *data);
-void remove_booting_done_handler(void *data);
+void add_delayed_init_done_handler(void *data);
+void remove_delayed_init_done_handler(void *data);
extern int silent_boot;
return 0;
}
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
if (ret_val < 0)
_E("Failed to init dbus method: %d", ret_val);
- add_booting_done_handler(NULL);
+ add_delayed_init_done_handler(NULL);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
add_poweroff_option(POWEROFF_TYPE_POWEROFF, NULL);
add_poweroff_option(POWEROFF_TYPE_RESTART, NULL);
static const char *device_notifier_type_str[DEVICE_NOTIFIER_MAX] = {
NOTIFY_STR(DEVICE_NOTIFIER_DAEMON_RESTARTED),
- NOTIFY_STR(DEVICE_NOTIFIER_BOOTING_DONE),
+ NOTIFY_STR(DEVICE_NOTIFIER_DELAYED_INIT),
NOTIFY_STR(DEVICE_NOTIFIER_LCD),
NOTIFY_STR(DEVICE_NOTIFIER_LCD_OFF),
NOTIFY_STR(DEVICE_NOTIFIER_LOWBAT),
NOTIFY_STR(DEVICE_NOTIFIER_USB_DEBUG_MODE),
NOTIFY_STR(DEVICE_NOTIFIER_USB_TETHERING_MODE),
NOTIFY_STR(DEVICE_NOTIFIER_EVENT_HANDLER),
- NOTIFY_STR(DEVICE_NOTIFIER_EARLY_BOOTING_DONE),
NOTIFY_STR(DEVICE_NOTIFIER_PMQOS),
NOTIFY_STR(DEVICE_NOTIFIER_PMQOS_ULTRAPOWERSAVING),
NOTIFY_STR(DEVICE_NOTIFIER_PMQOS_POWERSAVING),
enum device_notifier_type {
DEVICE_NOTIFIER_DAEMON_RESTARTED,
- DEVICE_NOTIFIER_BOOTING_DONE,
+ DEVICE_NOTIFIER_DELAYED_INIT,
DEVICE_NOTIFIER_LCD,
DEVICE_NOTIFIER_LCD_OFF,
DEVICE_NOTIFIER_LCD_OFF_COMPLETE,
DEVICE_NOTIFIER_CPU_BOOST_LOWBAT,
DEVICE_NOTIFIER_CPU_BOOST_POWEROFF,
/* Experimental for Specific device - contact to deviced owner */
- DEVICE_NOTIFIER_EARLY_BOOTING_DONE,
DEVICE_NOTIFIER_PMQOS,
DEVICE_NOTIFIER_PMQOS_ULTRAPOWERSAVING,
DEVICE_NOTIFIER_PMQOS_POWERSAVING,
static bool thermal_dev_available = false;
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
{
int ret;
- ret = register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ ret = register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
if (ret < 0)
_E("Failed to register booting done notifier.");
{
int ret;
- ret = unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ ret = unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
if (ret < 0)
_E("Failed to unregister booting done notifier.");
.nr_methods = ARRAY_SIZE(dbus_methods),
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done;
int ret;
}
ret = hal_device_touchscreen_glove_mode_set_state(TOUCHSENSITIVITY_GLOVE_MODE_ON);
_I("Change auto touch sensitivity enable: %s", ret ? "fail" : "set");
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
out:
return done;
}
if (ret <= 0)
_E("Failed to register signal handler: %d", ret);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static const struct device_ops sensitivity_device_ops = {
static int touchscreen_start(enum device_flags flags);
static int touchscreen_stop(enum device_flags flags);
-static int booting_done(void *data);
+static int delayed_init_done(void *data);
static struct display_config *display_conf;
static struct _backlight_ops *backlight_ops;
return 0;
/* Do not enable touchscreen during silent boot mode */
- if (silent_boot && !booting_done(NULL))
+ if (silent_boot && !delayed_init_done(NULL))
return -ENOTSUP;
/*
.nr_methods = ARRAY_SIZE(dbus_methods),
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
static int done = false;
if (ret < 0)
_E("Failed to init dbus method. (%d)", ret);
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
}
static const struct device_ops touchscreen_device_ops = {
.nr_methods = ARRAY_SIZE(dbus_methods),
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
/* To reduce the latency of the first Tzip operation, you can apply this optimization.
tzip_server_init(); */
tzip_lock_init();
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
register_notifier(DEVICE_NOTIFIER_POWEROFF, tzip_poweroff);
ret = gdbus_add_object(NULL, DEVICED_PATH_TZIP, &dbus_interface);
{
_D("tzip_exit");
tzip_server_exit();
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
unregister_notifier(DEVICE_NOTIFIER_POWEROFF, tzip_poweroff);
tzip_lock_deinit();
};
-static int booting_done(void *data)
+static int delayed_init_done(void *data)
{
/**
* To search the attched usb host device is not an urgent task.
usbhost_init_from_udev_enumerate();
/* unregister booting done notifier */
- unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ unregister_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
return 0;
}
_E("Failed to register dbus interface and method: %d", ret);
/* register notifier */
- register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done);
+ register_notifier(DEVICE_NOTIFIER_DELAYED_INIT, delayed_init_done);
ret = asprintf(&POLICY_FILEPATH, "%s/%s", ROOTPATH, POLICY_FILENAME);
if (ret < 0) {
projects / platform / core / system / deviced.git / commitdiff