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 <taemin.yeom@samsung.com>

diff --git a/include/power-internal.h b/include/power-internal.h
index f11eab6..f79cd57 100644 (file)
--- 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 (file)
--- 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;
                }