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,
};
/**
* @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.
* @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_* */
/**
* @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,
* @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.
* 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,
* @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,
/**
* @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.
* @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.
#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)
{
}
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;
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;
}
// 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);
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)
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)
}
// 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);
}
-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)
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)
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;
}