From d74cfdb521220aad1e043ff80a9cd45019c29f10 Mon Sep 17 00:00:00 2001 From: TaeminYeom Date: Mon, 12 Dec 2022 17:53:11 +0900 Subject: [PATCH] power: Add "DEVICE" or "device" prefix to enum and API To prevent collision, it is a principle to attach a prefix of project name. However, previous codes does not meet it. changed enum: power_state_e -> device_power_state_e POWER_STATE_* -> DEVICE_POWER_STATE_* power_transient_state_e -> device_power_transient_state_e POWER_STATE_TRANSIENT_* -> DEVICE_POWER_STATE_TRANSIENT_* POWER_STATE_TRANSIENT_*_EARLY -> DEVICE_POWER_STATE_TRANSIENT_*_EARLY POWER_STATE_TRANSIENT_*_LATE -> DEVICE_POWER_STATE_TRANSIENT_*_LATE POWER_STATE_*_INDEX -> DEVICE_POWER_STATE_*_INDEX POWER_STATE_TRANSIENT_*_INDEX -> DEVICE_POWER_STATE_TRANSIENT_*_INDEX changed callback: power_change_state_wait_callback -> device_power_change_state_wait_callback Change-Id: I386e48101e094427870ee83a5cbc2c035b331ad5 Signed-off-by: TaeminYeom --- include/power-internal.h | 98 ++++++++++++++++++++++++------------------------ src/power-internal.c | 64 +++++++++++++++---------------- 2 files changed, 81 insertions(+), 81 deletions(-) diff --git a/include/power-internal.h b/include/power-internal.h index f11eab6..f79cd57 100644 --- a/include/power-internal.h +++ b/include/power-internal.h @@ -41,25 +41,25 @@ extern "C" { int device_power_poweroff(void); enum { - POWER_STATE_MIN_INDEX = 4, - POWER_STATE_START_INDEX = POWER_STATE_MIN_INDEX, - POWER_STATE_NORMAL_INDEX, - POWER_STATE_SLEEP_INDEX, - POWER_STATE_POWEROFF_INDEX, - POWER_STATE_REBOOT_INDEX, - POWER_STATE_EXIT_INDEX, - POWER_STATE_MAX_INDEX, + DEVICE_POWER_STATE_MIN_INDEX = 4, + DEVICE_POWER_STATE_START_INDEX = DEVICE_POWER_STATE_MIN_INDEX, + DEVICE_POWER_STATE_NORMAL_INDEX, + DEVICE_POWER_STATE_SLEEP_INDEX, + DEVICE_POWER_STATE_POWEROFF_INDEX, + DEVICE_POWER_STATE_REBOOT_INDEX, + DEVICE_POWER_STATE_EXIT_INDEX, + DEVICE_POWER_STATE_MAX_INDEX, }; enum { - POWER_STATE_TRANSIENT_MIN_INDEX = POWER_STATE_MAX_INDEX + 1, - POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX = POWER_STATE_TRANSIENT_MIN_INDEX, - POWER_STATE_TRANSIENT_RESUMING_INDEX, - POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX, - POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX, - POWER_STATE_TRANSIENT_SUSPENDING_INDEX, - POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX, - POWER_STATE_TRANSIENT_MAX_INDEX, + DEVICE_POWER_STATE_TRANSIENT_MIN_INDEX = DEVICE_POWER_STATE_MAX_INDEX + 1, + DEVICE_POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX = DEVICE_POWER_STATE_TRANSIENT_MIN_INDEX, + DEVICE_POWER_STATE_TRANSIENT_RESUMING_INDEX, + DEVICE_POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX, + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX, + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_INDEX, + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX, + DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX, }; /** @@ -67,14 +67,14 @@ enum { * @since_tizen 6.5 */ typedef enum { - POWER_STATE_START = (1ULL << POWER_STATE_START_INDEX), /**< initial state of power module */ - POWER_STATE_NORMAL = (1ULL << POWER_STATE_NORMAL_INDEX), /**< normal state */ - POWER_STATE_SLEEP = (1ULL << POWER_STATE_SLEEP_INDEX), /**< sleep state */ - POWER_STATE_POWEROFF = (1ULL << POWER_STATE_POWEROFF_INDEX), /**< poweroff state */ - POWER_STATE_REBOOT = (1ULL << POWER_STATE_REBOOT_INDEX), /**< reboot state */ - POWER_STATE_EXIT = (1ULL << POWER_STATE_EXIT_INDEX), /**< exit state */ - POWER_STATE_ALL = ((1ULL << POWER_STATE_MAX_INDEX) - (1ULL << POWER_STATE_MIN_INDEX)), /**< all the above states */ -} power_state_e; + DEVICE_POWER_STATE_START = (1ULL << DEVICE_POWER_STATE_START_INDEX), /**< initial state of power module */ + DEVICE_POWER_STATE_NORMAL = (1ULL << DEVICE_POWER_STATE_NORMAL_INDEX), /**< normal state */ + DEVICE_POWER_STATE_SLEEP = (1ULL << DEVICE_POWER_STATE_SLEEP_INDEX), /**< sleep state */ + DEVICE_POWER_STATE_POWEROFF = (1ULL << DEVICE_POWER_STATE_POWEROFF_INDEX), /**< poweroff state */ + DEVICE_POWER_STATE_REBOOT = (1ULL << DEVICE_POWER_STATE_REBOOT_INDEX), /**< reboot state */ + DEVICE_POWER_STATE_EXIT = (1ULL << DEVICE_POWER_STATE_EXIT_INDEX), /**< exit state */ + DEVICE_POWER_STATE_ALL = ((1ULL << DEVICE_POWER_STATE_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_MIN_INDEX)), /**< all the above states */ +} device_power_state_e; /** * @brief Enumeration for transient state. @@ -82,13 +82,13 @@ typedef enum { * @since_tizen 7.0 */ typedef enum { - POWER_STATE_TRANSIENT_RESUMING_EARLY = (1ULL << POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX), /**< the first step of transitioning from sleep to normal */ - POWER_STATE_TRANSIENT_RESUMING = (1ULL << POWER_STATE_TRANSIENT_RESUMING_INDEX), /**< the second step of transitioning from sleep to normal */ - POWER_STATE_TRANSIENT_RESUMING_LATE = (1ULL << POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX), /**< the last step of transitioning from sleep to normal */ - POWER_STATE_TRANSIENT_SUSPENDING_EARLY = (1ULL << POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX), /**< the first step of transitioning from normal to sleep */ - POWER_STATE_TRANSIENT_SUSPENDING = (1ULL << POWER_STATE_TRANSIENT_SUSPENDING_INDEX), /**< the second step of transitioning from normal to sleep */ - POWER_STATE_TRANSIENT_SUSPENDING_LATE = (1ULL << POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX), /**< the last step of transitioning from normal to sleep */ -} power_transient_state_e; + DEVICE_POWER_STATE_TRANSIENT_RESUMING_EARLY = (1ULL << DEVICE_POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX), /**< the first step of transitioning from sleep to normal */ + DEVICE_POWER_STATE_TRANSIENT_RESUMING = (1ULL << DEVICE_POWER_STATE_TRANSIENT_RESUMING_INDEX), /**< the second step of transitioning from sleep to normal */ + DEVICE_POWER_STATE_TRANSIENT_RESUMING_LATE = (1ULL << DEVICE_POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX), /**< the last step of transitioning from sleep to normal */ + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_EARLY = (1ULL << DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX), /**< the first step of transitioning from normal to sleep */ + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING = (1ULL << DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_INDEX), /**< the second step of transitioning from normal to sleep */ + DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_LATE = (1ULL << DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX), /**< the last step of transitioning from normal to sleep */ +} device_power_transient_state_e; struct device_change_state_info { uint64_t prev_state; /* previous state before the state transition, one of POWER_STATE_* */ @@ -99,23 +99,23 @@ struct device_change_state_info { /** * @brief Called when a device power state is changed. - * @details If both power_change_state_wait_callback() and power_change_state_callback() have registered to the same power state, \n - * then the power_change_state_wait_callback() will be invoked first and the power_change_state_callback() will follow. + * @details If both device_power_change_state_wait_callback() and device_power_change_state_callback() have registered to the same power state, \n + * then the device_power_change_state_wait_callback() will be invoked first and the device_power_change_state_callback() will follow. * @since_tizen 6.5 * @param[out] info Information about state change * @param[out] user_data User data passed from the callback registration */ -typedef void (*power_change_state_wait_callback) (const struct device_change_state_info *info, void *user_data); +typedef void (*device_power_change_state_wait_callback) (const struct device_change_state_info *info, void *user_data); /** * @brief Add a callback to observe power state change. * @details Register a callback for specific power state. \n * The callback will be invoked when the deviced changes state to the designated power state. \n - * An actual action, such as triggering poweroff on changing state to #POWER_STATE_POWEROFF or \n - * wake unlock on changing state to #POWER_STATE_SLEEP, will be deferred to give a chance \n + * An actual action, such as triggering poweroff on changing state to #DEVICE_POWER_STATE_POWEROFF or \n + * wake unlock on changing state to #DEVICE_POWER_STATE_SLEEP, will be deferred to give a chance \n * for the API caller to prepare for the action. * @since_tizen 6.5 - * @param[in] state_bits Bitwise ORed #power_state_e + * @param[in] state_bits Bitwise ORed #device_power_state_e * @param[in] cb Callback function * @param[in] user_data Data to be passed to the callback function * @return 0 on success, @@ -123,7 +123,7 @@ typedef void (*power_change_state_wait_callback) (const struct device_change_sta * @retval #DEVICE_ERROR_NONE Successful * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed */ -int device_power_add_change_state_wait_callback(power_state_e state_bits, power_change_state_wait_callback cb, void *user_data); +int device_power_add_change_state_wait_callback(device_power_state_e state_bits, device_power_change_state_wait_callback cb, void *user_data); /** * @brief Add a callback to observe transient power state. @@ -132,7 +132,7 @@ int device_power_add_change_state_wait_callback(power_state_e state_bits, power_ * Similar to the device_power_add_change_state_wait_callback(), it defers transition to the next state \n * until it is confirmed to be ready to go. \n * @since_tizen 7.0 - * @param[in] transient_bits Bitwise ORed #power_transient_state_e + * @param[in] transient_bits Bitwise ORed #device_power_transient_state_e * @param[in] cb Callback function * @param[in] user_data Data to be passed to the callback function * @return 0 on success, @@ -140,12 +140,12 @@ int device_power_add_change_state_wait_callback(power_state_e state_bits, power_ * @retval #DEVICE_ERROR_NONE Successful * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed */ -int device_power_add_transient_state_wait_callback(power_transient_state_e transient_bits, power_change_state_wait_callback cb, void *user_data); +int device_power_add_transient_state_wait_callback(device_power_transient_state_e transient_bits, device_power_change_state_wait_callback cb, void *user_data); /** * @brief Notify the deviced that it is ready for the actual action. * @details Notify the deviced that it is ok to take an actual action of change state. \n - * This function only works on the id received from power_change_state_wait_callback(). + * This function only works on the id received from device_power_change_state_wait_callback(). * @since_tizen 6.5 * @param[in] id Id of a state change * @return 0 on success, @@ -158,27 +158,27 @@ int device_power_change_state_wait_done(uint64_t id); /** * @brief Remove callback that has registered to power state. * @since_tizen 6.5 - * @param[in] state_bits Bitwise ORed #power_state_e + * @param[in] state_bits Bitwise ORed #device_power_state_e */ -void device_power_remove_change_state_wait_callback(power_state_e state_bits); +void device_power_remove_change_state_wait_callback(device_power_state_e state_bits); /** * @brief Remove callback that has registered to transient power state. * @since_tizen 7.0 - * @param[in] transient_bits Bitwise ORed #power_transient_state_e + * @param[in] transient_bits Bitwise ORed #device_power_transient_state_e */ -void device_power_remove_transient_state_wait_callback(power_transient_state_e transient_bits); +void device_power_remove_transient_state_wait_callback(device_power_transient_state_e transient_bits); /** * @brief Async callback of device_power_change_state(). - * @details If both power_change_state_wait_callback() and power_change_state_callback() have registered to the same power state, \n - * then the power_change_state_wait_callback() will be invoked first and the power_change_state_callback() will follow. + * @details If both device_power_change_state_wait_callback() and device_power_change_state_callback() have registered to the same power state, \n + * then the device_power_change_state_wait_callback() will be invoked first and the device_power_change_state_callback() will follow. * @since_tizen 6.5 * @param[out] state State to be changed * @param[out] retval Return of change state * @param[out] user_data The user data passed from the change state function */ -typedef void (*power_change_state_callback) (uint64_t state, int retval, void *user_data); +typedef void (*device_power_change_state_callback) (uint64_t state, int retval, void *user_data); /** * @brief Send request for changing power state asynchronously. @@ -192,7 +192,7 @@ typedef void (*power_change_state_callback) (uint64_t state, int retval, void *u * @retval #DEVICE_ERROR_NONE Successful * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed */ -int device_power_change_state(uint64_t state, int timeout_sec, power_change_state_callback cb, void *user_data); +int device_power_change_state(uint64_t state, int timeout_sec, device_power_change_state_callback cb, void *user_data); /** * @brief Check if reboot is possible on the current device state. diff --git a/src/power-internal.c b/src/power-internal.c index 0ab5d64..ae5bb8b 100644 --- a/src/power-internal.c +++ b/src/power-internal.c @@ -10,17 +10,17 @@ #define DBUS_METHOD_SYNC_CALL_TIMEOUT_MS 10000 /* 10 second */ struct power_change_state_wait_handler { - power_change_state_wait_callback callback; + device_power_change_state_wait_callback callback; void *user_data; }; struct power_change_state_handler { - power_change_state_callback callback; + device_power_change_state_callback callback; void *user_data; uint64_t state; }; -static int change_state_signal_id[POWER_STATE_TRANSIENT_MAX_INDEX]; +static int change_state_signal_id[DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX]; static void signal_unsubscribed_callback(void *data) { @@ -51,21 +51,21 @@ static void signal_callback(GDBusConnection *connection, } static int __register_signal_callback(GDBusConnection *connection, - int index, power_change_state_wait_callback cb, void *data) + int index, device_power_change_state_wait_callback cb, void *data) { - static const char *signame[POWER_STATE_TRANSIENT_MAX_INDEX] = { - [POWER_STATE_START_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_START, - [POWER_STATE_NORMAL_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_NORMAL, - [POWER_STATE_SLEEP_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SLEEP, - [POWER_STATE_POWEROFF_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_POWEROFF, - [POWER_STATE_REBOOT_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_REBOOT, - [POWER_STATE_EXIT_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_EXIT, - [POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING_EARLY, - [POWER_STATE_TRANSIENT_RESUMING_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING, - [POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING_LATE, - [POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING_EARLY, - [POWER_STATE_TRANSIENT_SUSPENDING_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING, - [POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING_LATE, + static const char *signame[DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX] = { + [DEVICE_POWER_STATE_START_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_START, + [DEVICE_POWER_STATE_NORMAL_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_NORMAL, + [DEVICE_POWER_STATE_SLEEP_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SLEEP, + [DEVICE_POWER_STATE_POWEROFF_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_POWEROFF, + [DEVICE_POWER_STATE_REBOOT_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_REBOOT, + [DEVICE_POWER_STATE_EXIT_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_EXIT, + [DEVICE_POWER_STATE_TRANSIENT_RESUMING_EARLY_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING_EARLY, + [DEVICE_POWER_STATE_TRANSIENT_RESUMING_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING, + [DEVICE_POWER_STATE_TRANSIENT_RESUMING_LATE_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_RESUMING_LATE, + [DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_EARLY_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING_EARLY, + [DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING, + [DEVICE_POWER_STATE_TRANSIENT_SUSPENDING_LATE_INDEX] = DEVICED_SIGNAL_POWER_CHANGE_STATE_TO_SUSPENDING_LATE, }; struct power_change_state_wait_handler *h; @@ -95,7 +95,7 @@ static int __register_signal_callback(GDBusConnection *connection, return DEVICE_ERROR_NONE; } -static int register_signal_callback(uint64_t states, power_change_state_wait_callback cb, void *data) +static int register_signal_callback(uint64_t states, device_power_change_state_wait_callback cb, void *data) { GDBusConnection *connection; GVariant *retgv = NULL; @@ -130,7 +130,7 @@ static int register_signal_callback(uint64_t states, power_change_state_wait_cal } // subscribe signal - for (int index = 0; index < POWER_STATE_TRANSIENT_MAX_INDEX; ++index) + for (int index = 0; index < DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX; ++index) if((states & (1ULL << index)) && (change_state_signal_id[index] == 0)) __register_signal_callback(connection, index, cb, data); @@ -138,9 +138,9 @@ static int register_signal_callback(uint64_t states, power_change_state_wait_cal return DEVICE_ERROR_NONE; } -int device_power_add_change_state_wait_callback(power_state_e state_bits, power_change_state_wait_callback cb, void *data) +int device_power_add_change_state_wait_callback(device_power_state_e state_bits, device_power_change_state_wait_callback cb, void *data) { - uint64_t valid = (1ULL << POWER_STATE_MAX_INDEX) - (1ULL << POWER_STATE_MIN_INDEX); + uint64_t valid = (1ULL << DEVICE_POWER_STATE_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_MIN_INDEX); uint64_t invalid = (state_bits & ~valid); if (invalid) @@ -149,9 +149,9 @@ int device_power_add_change_state_wait_callback(power_state_e state_bits, power_ return register_signal_callback(state_bits, cb, data); } -int device_power_add_transient_state_wait_callback(power_transient_state_e transient_bits, power_change_state_wait_callback cb, void *data) +int device_power_add_transient_state_wait_callback(device_power_transient_state_e transient_bits, device_power_change_state_wait_callback cb, void *data) { - uint64_t valid = (1ULL << POWER_STATE_TRANSIENT_MAX_INDEX) - (1ULL << POWER_STATE_TRANSIENT_MIN_INDEX); + uint64_t valid = (1ULL << DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_TRANSIENT_MIN_INDEX); uint64_t invalid = (transient_bits & ~valid); if (invalid) @@ -224,7 +224,7 @@ static void unregister_signal_callback(uint64_t states) } // unsubscribe signal - for (int index = 0; index < POWER_STATE_TRANSIENT_MAX_INDEX; ++index) + for (int index = 0; index < DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX; ++index) if((states & (1ULL << index)) && (change_state_signal_id[index] > 0)) __unregister_signal_callback(connection, index); @@ -243,9 +243,9 @@ static void unregister_signal_callback(uint64_t states) } -void device_power_remove_change_state_wait_callback(power_state_e state_bits) +void device_power_remove_change_state_wait_callback(device_power_state_e state_bits) { - uint64_t valid = (1ULL << POWER_STATE_MAX_INDEX) - (1ULL << POWER_STATE_MIN_INDEX); + uint64_t valid = (1ULL << DEVICE_POWER_STATE_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_MIN_INDEX); uint64_t invalid = (state_bits & ~valid); if (invalid) @@ -254,9 +254,9 @@ void device_power_remove_change_state_wait_callback(power_state_e state_bits) unregister_signal_callback(state_bits); } -void device_power_remove_transient_state_wait_callback(power_transient_state_e transient_bits) +void device_power_remove_transient_state_wait_callback(device_power_transient_state_e transient_bits) { - uint64_t valid = (1ULL << POWER_STATE_TRANSIENT_MAX_INDEX) - (1ULL << POWER_STATE_TRANSIENT_MIN_INDEX); + uint64_t valid = (1ULL << DEVICE_POWER_STATE_TRANSIENT_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_TRANSIENT_MIN_INDEX); uint64_t invalid = (transient_bits & ~valid); if (invalid) @@ -303,25 +303,25 @@ cleanup: free(h); } -int device_power_change_state(uint64_t state, int timeout_sec, power_change_state_callback cb, void *user_data) +int device_power_change_state(uint64_t state, int timeout_sec, device_power_change_state_callback cb, void *user_data) { GError *err = NULL; GDBusConnection *connection; struct power_change_state_handler *h = NULL; - uint64_t valid = (1ULL << POWER_STATE_MAX_INDEX) - (1ULL << POWER_STATE_MIN_INDEX); + uint64_t valid = (1ULL << DEVICE_POWER_STATE_MAX_INDEX) - (1ULL << DEVICE_POWER_STATE_MIN_INDEX); uint64_t invalid = (state & ~valid); if (invalid) return DEVICE_ERROR_INVALID_PARAMETER; if (!device_power_check_reboot_allowed()) { - if (state == POWER_STATE_POWEROFF) { + if (state == DEVICE_POWER_STATE_POWEROFF) { _E("Failed to Poweroff due to partition cloning."); return DEVICE_ERROR_OPERATION_FAILED; } - if (state == POWER_STATE_REBOOT) { + if (state == DEVICE_POWER_STATE_REBOOT) { _E("Failed to Reboot due to partition cloning."); return DEVICE_ERROR_OPERATION_FAILED; } -- 2.7.4