From b3d72a64ca39fef39127aeb040f370c9e2798c2e Mon Sep 17 00:00:00 2001 From: Jiyoung Yun Date: Tue, 13 Jan 2015 15:21:27 +0900 Subject: [PATCH] device: Merge public api on Tizen 2.3 into tizen branch Detail Tizen Device Native API guideline: https://developer.tizen.org/dev-guide/2.3.0/org.tizen.mobile.native.apireference/group__CAPI__SYSTEM__DEVICE__MODULE.html Signed-off-by: Jiyoung Yun Change-Id: If11e3576cd5911466b818c7b478a847556be0193 --- CMakeLists.txt | 11 +- capi-system-device.pc.in | 7 +- include/battery.h | 117 +++++++++++ include/callback.h | 109 ++++++++++ include/device-error.h | 55 +++++ include/device.h | 13 +- include/display.h | 216 +++++++++++++++++++ include/haptic.h | 175 ++++++++++++++++ include/led.h | 152 ++++++++++++++ include/power.h | 134 ++++++++++++ packaging/capi-system-device.spec | 8 +- src/battery.c | 389 +++-------------------------------- src/callback.c | 236 +++++++++++++++++++++ include/device_log.h => src/common.h | 34 ++- src/cpu.c | 2 +- src/dbus.c | 235 +++++++++++++++++++++ src/dbus.h | 55 +++++ src/device.c | 213 ++++++++++++++----- src/display.c | 222 ++++++++++++++++++++ src/haptic.c | 179 ++++++++++++++++ src/led.c | 169 +++++++++++++++ src/list.h | 83 ++++++++ src/memory.c | 2 +- src/power.c | 217 +++++++++++++++++++ 24 files changed, 2590 insertions(+), 443 deletions(-) create mode 100755 include/battery.h create mode 100755 include/callback.h create mode 100755 include/device-error.h create mode 100755 include/display.h create mode 100755 include/haptic.h create mode 100755 include/led.h create mode 100755 include/power.h create mode 100644 src/callback.c rename include/device_log.h => src/common.h (51%) create mode 100644 src/dbus.c create mode 100644 src/dbus.h create mode 100644 src/display.c create mode 100644 src/haptic.c create mode 100644 src/led.c create mode 100644 src/list.h create mode 100644 src/power.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 6dd3dcf..6d22fd7 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,7 +10,7 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX}) SET(INC_DIR include) INCLUDE_DIRECTORIES(${INC_DIR}) -SET(dependents "devman dlog vconf capi-base-common") +SET(dependents "deviced dlog vconf dbus-1 dbus-glib-1 capi-base-common capi-system-info") SET(pc_dependents "capi-base-common") INCLUDE(FindPkgConfig) @@ -19,7 +19,7 @@ FOREACH(flag ${${fw_name}_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall") SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") IF("${ARCH}" STREQUAL "arm") @@ -44,11 +44,12 @@ SET_TARGET_PROPERTIES(${fw_name} ) INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR}) +INSTALL(FILES ${INC_DIR}/device.h ${INC_DIR}/device-error.h + DESTINATION include/system) INSTALL( - DIRECTORY ${INC_DIR}/ DESTINATION include/system + DIRECTORY ${INC_DIR}/ DESTINATION include/device FILES_MATCHING - PATTERN "*_private.h" EXCLUDE - PATTERN "*_log.h" EXCLUDE + PATTERN "device.h" EXCLUDE PATTERN "${INC_DIR}/*.h" ) diff --git a/capi-system-device.pc.in b/capi-system-device.pc.in index 1d79ad0..ef89a5e 100644 --- a/capi-system-device.pc.in +++ b/capi-system-device.pc.in @@ -4,12 +4,11 @@ prefix=@PREFIX@ exec_prefix=/usr libdir=@LIB_INSTALL_DIR@ -includedir=/usr/include/system +includedir=/usr/include Name: @PC_NAME@ Description: @PACKAGE_DESCRIPTION@ Version: @VERSION@ -Requires: @PC_REQUIRED@ +Requires: @PC_REQUIRED@ Libs: -L${libdir} @PC_LDFLAGS@ -Cflags: -I${includedir} - +Cflags: -I${includedir} -I/usr/include/system diff --git a/include/battery.h b/include/battery.h new file mode 100755 index 0000000..4449e4d --- /dev/null +++ b/include/battery.h @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_BATTERY_H__ +#define __TIZEN_SYSTEM_BATTERY_H__ + +#include +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_BATTERY_MODULE + * @{ + */ + +/** + * @brief Enumeration for the battery level status. + * @since_tizen 2.3 + */ +typedef enum +{ + DEVICE_BATTERY_LEVEL_EMPTY = 0, /**< The battery goes empty. Prepare for the safe termination of the application, because the device starts a shutdown process soon after entering this level. */ + DEVICE_BATTERY_LEVEL_CRITICAL, /**< The battery charge is at a critical state. You may have to stop using multimedia features, because they are not guaranteed to work correctly at this battery status. */ + DEVICE_BATTERY_LEVEL_LOW, /**< The battery has little charge left. */ + DEVICE_BATTERY_LEVEL_HIGH, /**< The battery status is not to be careful. */ + DEVICE_BATTERY_LEVEL_FULL, /**< The battery status is full. */ +} device_battery_level_e; + +/** + * @brief Gets the battery charge percentage. + * @details It returns an integer value from @c 0 to @c 100 that indicates remaining battery charge + * as a percentage of the maximum level. + * + * @since_tizen 2.3 + * + * @remarks In order to be notified when the battery state changes, use system_info_set_changed_cb(). + * + * @param[out] percent The remaining battery charge percentage (@c 0 ~ @c 100) + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + */ +int device_battery_get_percent(int *percent); + +/** + * @brief Gets the charging state. + * + * @since_tizen 2.3 + * + * @param[out] charging The battery charging state + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_add_callback + * @see device_remove_callback + * @see #DEVICE_CALLBACK_BATTERY_CHARGING + */ +int device_battery_is_charging(bool *charging); + +/** + * @brief Gets the battery level status. + * + * @since_tizen 2.3 + * + * @param[out] status The battery level status + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_battery_level_e + * @see device_add_callback + * @see device_remove_callback + * @see #DEVICE_CALLBACK_BATTERY_LEVEL + */ +int device_battery_get_level_status(device_battery_level_e *status); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_BATTERY_H__ diff --git a/include/callback.h b/include/callback.h new file mode 100755 index 0000000..3394862 --- /dev/null +++ b/include/callback.h @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_CALLBACK_H__ +#define __TIZEN_SYSTEM_CALLBACK_H__ + +#include +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_CALLBACK_MODULE + * @{ + */ + +/** + * @brief Enumeration for the device state callback. + * @since_tizen 2.3 + */ +typedef enum +{ + DEVICE_CALLBACK_BATTERY_CAPACITY, /**< Called when a battery charge percentage is changed */ + DEVICE_CALLBACK_BATTERY_LEVEL, /**< Called when a battery level is changed */ + DEVICE_CALLBACK_BATTERY_CHARGING, /**< Called when battery charging state is changed */ + DEVICE_CALLBACK_DISPLAY_STATE, /**< Called when a display state is changed */ + DEVICE_CALLBACK_MAX +} device_callback_e; + +/** + * @brief Called when a device status is changed. + * @details Each device callback has a different output param type. \n + * So you need to check below output param before using this function. \n + * callback enum output type \n + * DEVICE_CALLBACK_BATTERY_CAPACITY int \n + * DEVICE_CALLBACK_BATTERY_LEVEL int \n + * DEVICE_CALLBACK_BATTERY_CHARGING bool \n + * DEVICE_CALLBACK_DISPLAY_STATE int + * + * @since_tizen 2.3 + * + * @param[out] type The device type to monitor + * @param[out] value The changed value \n + * @param[out] user_data The user data passed from the callback registration function + */ +typedef void (*device_changed_cb)(device_callback_e type, void *value, void *user_data); + +/** + * @brief Adds a callback to the observing device state. + * + * @since_tizen 2.3 + * + * @param[in] type The device type to monitor + * @param[in] callback The callback function to add + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_ALREADY_IN_PROGRESS Operation already + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + */ +int device_add_callback(device_callback_e type, device_changed_cb callback, void *user_data); + +/** + * @brief Removes a device callback function. + * + * @since_tizen 2.3 + * + * @param[in] type The device type to monitor + * @param[in] callback The callback function to remove + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + */ +int device_remove_callback(device_callback_e type, device_changed_cb callback); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_CALLBACK_H__ diff --git a/include/device-error.h b/include/device-error.h new file mode 100755 index 0000000..08dd5b8 --- /dev/null +++ b/include/device-error.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_DEVICE_ERROR_H__ +#define __TIZEN_SYSTEM_DEVICE_ERROR_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_MODULE + * @{ + */ + +/** + * @brief Enumerations of error code for Device. + */ +typedef enum +{ + DEVICE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + DEVICE_ERROR_OPERATION_FAILED = TIZEN_ERROR_NOT_PERMITTED, /**< Operation not permitted */ + DEVICE_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + DEVICE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + DEVICE_ERROR_ALREADY_IN_PROGRESS = TIZEN_ERROR_ALREADY_IN_PROGRESS, /**< Operation already in progress */ + DEVICE_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported in this device */ + DEVICE_ERROR_NOT_INITIALIZED = TIZEN_ERROR_DEVICE | 0x13, /**< Not initialized */ +} device_error_e; + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_DEVICE_ERROR_H__ diff --git a/include/device.h b/include/device.h index 93fabd3..efbc83e 100755 --- a/include/device.h +++ b/include/device.h @@ -21,7 +21,7 @@ #define __TIZEN_SYSTEM_DEVICE_H__ #include -#include +#include "device-error.h" #ifdef __cplusplus extern "C" { @@ -34,17 +34,6 @@ extern "C" { */ /** - * @brief Enumerations of error code for Device. - */ -typedef enum -{ - DEVICE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ - DEVICE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ - DEVICE_ERROR_OPERATION_FAILED = TIZEN_ERROR_SYSTEM_CLASS | 0x12, /**< Operation failed */ - DEVICE_ERROR_NOT_SUPPORTED = TIZEN_ERROR_SYSTEM_CLASS | 0x13, /**< Not supported in this device */ -} device_error_e; - -/** * @brief Enumerations of the battery warning status */ typedef enum diff --git a/include/display.h b/include/display.h new file mode 100755 index 0000000..6d47413 --- /dev/null +++ b/include/display.h @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_DISPLAY_H__ +#define __TIZEN_SYSTEM_DISPLAY_H__ + +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_DISPLAY_MODULE + * @{ + */ + +/** + * @brief Gets the number of display devices. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[out] device_number The total number of displays + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_display_get_brightness() + * @see device_display_set_brightness() + * @see device_display_get_max_brightness() + */ +int device_display_get_numbers(int *device_number); + +/** + * @brief Gets the maximum brightness value that can be set. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] display_index The index of the display \n + * It can be greater than or equal to @c 0 and less than + * the number of displays returned by device_display_get_numbers(). \n + * The index zero is always assigned to the main display. + * @param[out] max_brightness The maximum brightness value of the display + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_display_get_numbers() + * @see device_display_set_brightness() + * @see device_display_get_brightness() + */ +int device_display_get_max_brightness(int display_index, int *max_brightness); + +/** + * @brief Gets the display brightness value. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] display_index The index of the display \n + * It can be greater than or equal to @c 0 and less than + * the number of displays returned by device_display_get_numbers(). \n + * The index zero is always assigned to the main display. + * @param[out] brightness The current brightness value of the display + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_display_get_numbers() + * @see device_display_set_brightness() + * @see device_display_get_max_brightness() + */ +int device_display_get_brightness(int display_index, int *brightness); + +/** + * @brief Sets the display brightness value. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] display_index The index of the display \n + * It can be greater than or equal to @c 0 and less than + * the number of displays returned by device_display_get_numbers(). \n + * The index zero is always assigned to the main display. + * @param[in] brightness The new brightness value to set \n + * The maximum value can be represented by device_display_get_max_brightness(). + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_display_get_numbers() + * @see device_display_get_max_brightness() + * @see device_display_get_brightness() + */ +int device_display_set_brightness(int display_index, int brightness); + +/** + * @brief Enumeration for the available display states. + * @details An application cannot put the device into the power off state or the suspend state. + * @since_tizen 2.3 + */ +typedef enum +{ + DISPLAY_STATE_NORMAL, /**< Normal state */ + DISPLAY_STATE_SCREEN_DIM, /**< Screen dim state */ + DISPLAY_STATE_SCREEN_OFF, /**< Screen off state */ +} display_state_e; + +/** + * @brief Gets the current display state. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[out] state the display state + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_add_callback + * @see device_remove_callback + * @see #DEVICE_CALLBACK_DISPLAY_STATE + */ +int device_display_get_state(display_state_e *state); + +/** + * @brief Changes the display state by force. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] state the display state + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_power_request_lock() + * @see device_power_release_lock() + * @see device_add_callback + * @see device_remove_callback + * @see #DEVICE_CALLBACK_DISPLAY_STATE + * + * @par Example + * @code + * ... + * result = device_display_change_state(DISPLAY_STATE_SCREEN_OFF); + * if( result < 0 ) + * printf("[ERROR] return value result =%d, \n",result); + * else + * printf("[SUCCESS] return value result =%d \n",result); + * ... + * @endcode + */ +int device_display_change_state(display_state_e state); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_DISPLAY_H__ diff --git a/include/haptic.h b/include/haptic.h new file mode 100755 index 0000000..30d5cc5 --- /dev/null +++ b/include/haptic.h @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_HAPTIC_H__ +#define __TIZEN_SYSTEM_HAPTIC_H__ + +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_HAPTIC_MODULE + * @{ + */ + +/** + * @brief The haptic device handle. + */ +typedef void* haptic_device_h; + +/** + * @brief The haptic effect handle. + */ +typedef void* haptic_effect_h; + +/** + * @brief Gets the number of vibrators. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/haptic + * + * @param[in] device_number The number of vibrators + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_haptic_get_count(int *device_number); + +/** + * @brief Opens a haptic-vibration device. + * @details Internally, it makes a connection to the vibrator. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/haptic + * + * @remarks You must close the Haptic API using device_haptic_close(). + * + * @param[in] device_index The index of device what you want to vibrate + * @param[out] device_handle The handle of vibrator + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + * + * @see device_haptic_close() + */ +int device_haptic_open(int device_index, haptic_device_h *device_handle); + +/** + * @brief Closes a haptic-vibration device. + * @details Internally, it disconnects the connection to the vibrator. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/haptic + * + * @param[in] device_handle The device handle from device_haptic_open() + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + * + * @see device_haptic_open() + */ +int device_haptic_close(haptic_device_h device_handle); + +/** + * @brief Vibrates during the specified time with a constant intensity. + * @details This function can be used to start monotonous vibration for the specified time. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/haptic + * + * @remarks @a feedback level is reserved for auto changing to save variable in the settings. + * @remarks @a effect_handle effect_handle value can be @c 0(zero). + * + * @param[in] device_handle The device handle from device_haptic_open() + * @param[in] duration The play duration in milliseconds + * @param[in] feedback The amount of the intensity variation (@c 0 ~ @c 100) + * @param[out] effect_handle The pointer to the variable that will receive a handle to the playing effect + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + * + * @see device_haptic_stop() + */ + +int device_haptic_vibrate(haptic_device_h device_handle, + int duration, int feedback, haptic_effect_h *effect_handle); + +/** + * @brief Stops all vibration effects which are being played. + * @details This function can be used to stop all effects started by device_haptic_vibrate(). + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/haptic + * + * @param[in] device_handle The device handle from device_haptic_open() + * @param[in] effect_handle The effect handle from device_haptic_vibrate() + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + * + * @see device_haptic_vibrate() + */ +int device_haptic_stop(haptic_device_h device_handle, haptic_effect_h effect_handle); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_HAPTIC_H__ diff --git a/include/led.h b/include/led.h new file mode 100755 index 0000000..718a4bf --- /dev/null +++ b/include/led.h @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_LED_H__ +#define __TIZEN_SYSTEM_LED_H__ + +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_LED_MODULE + * @{ + */ + +/** + * @brief Gets the max brightness value of a LED that is located next to the camera. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/led + * + * @param[out] max_brightness The max brightness value of the LED + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_flash_get_max_brightness(int *max_brightness); + +/** + * @brief Gets the brightness value of a LED that is located next to the camera. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/led + * + * @param[out] brightness The brightness value of LED (@c 0 ~ MAX) + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_flash_get_brightness(int *brightness); + +/** + * @brief Sets the brightness value of a LED that is located next to the camera. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/led + * + * @param[in] brightness The brightness value of LED (@c 0 ~ MAX) + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_flash_set_brightness(int brightness); + +/** + * @brief Enumeration for custom LED flags. + * @since_tizen 2.3 + */ +typedef enum { + LED_CUSTOM_DUTY_ON = 1 << 0, /**< blink LED */ + LED_CUSTOM_DEFAULT = (LED_CUSTOM_DUTY_ON), /**< Default flag */ +} led_custom_flags; + +/** + * @brief Plays the custom effect of the service LED that is located to the front of a device. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/led + * + * @param[in] on Turn on time in milliseconds + * @param[in] off Turn off time in milliseconds + * @param[in] color The Color value \n + * The first byte means opaque and the other 3 bytes are RGB values. + * @param[in] flags The combination of enum #led_custom_flags + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_led_play_custom(int on, int off, unsigned int color, unsigned int flags); + +/** + * @brief Stops the custom effect of the service LED that is located to the front of a device. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/led + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * @retval #DEVICE_ERROR_NOT_SUPPORTED Not supported device + */ +int device_led_stop_custom(void); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_LED_H__ diff --git a/include/power.h b/include/power.h new file mode 100755 index 0000000..48d9483 --- /dev/null +++ b/include/power.h @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + + +#ifndef __TIZEN_SYSTEM_POWER_H__ +#define __TIZEN_SYSTEM_POWER_H__ + +#include +#include "device-error.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup CAPI_SYSTEM_DEVICE_POWER_MODULE + * @{ + */ + +/** + * @brief Enumeration for lock type. + * @details Each enum ensures that the suitable device is on + * until all the lock requests have been released or after a timeout. \n + * CPU Brightness \n + * POWER_LOCK_CPU ON OFF \n + * POWER_LOCK_DISPLAY ON ON(normal) \n + * POWER_LOCK_DISPLAY_DIM ON ON(dim) + * + * @since_tizen 2.3 + * + * @remarks An application can lock the specific type. + * @remarks These enums are mutually exclusive. + * @remarks You cannot combine with an enum below. + * + */ +typedef enum +{ + POWER_LOCK_CPU, /**< CPU lock */ + POWER_LOCK_DISPLAY, /**< Display normal lock */ + POWER_LOCK_DISPLAY_DIM, /**< Display dim lock */ +} power_lock_e; + +/** + * @brief Locks the given lock state for a specified time. + * @details After the given @a timeout_ms (in milliseconds), unlock the given lock state automatically. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @remarks If the process dies, then every lock will be removed. + * + * @param[in] type The power type to request lock + * @param[in] timeout_ms The positive number in milliseconds or @c 0 for permanent lock \n + * So you must release the permanent lock of power state with #device_power_release_lock() if @a timeout_ms is zero. + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_power_release_lock() + */ +int device_power_request_lock(power_lock_e type, int timeout_ms); + +/** + * @brief Releases the given lock state locked before. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] type The power type to release lock + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @see device_power_request_lock() + */ +int device_power_release_lock(power_lock_e type); + +/** + * @brief Changes the current power state to the normal/dim state. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/display + * + * @param[in] dim Set @c true to set the dim state, + * otherwise set @c false to not set the dim state + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #DEVICE_ERROR_NONE Successful + * @retval #DEVICE_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #DEVICE_ERROR_PERMISSION_DENIED Permission denied + * @retval #DEVICE_ERROR_OPERATION_FAILED Operation failed + * + * @post The device will be in #DISPLAY_STATE_NORMAL state. + */ +int device_power_wakeup(bool dim); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif // __TIZEN_SYSTEM_POWER_H__ diff --git a/packaging/capi-system-device.spec b/packaging/capi-system-device.spec index 62c3d1b..895b1ef 100644 --- a/packaging/capi-system-device.spec +++ b/packaging/capi-system-device.spec @@ -7,10 +7,13 @@ License: Apache-2.0 Source0: %{name}-%{version}.tar.gz Source1: capi-system-device.manifest BuildRequires: cmake -BuildRequires: pkgconfig(devman) +BuildRequires: pkgconfig(deviced) BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(capi-system-info) BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(vconf) +BuildRequires: pkgconfig(dbus-1) +BuildRequires: pkgconfig(dbus-glib-1) %description A Device library in TIZEN C API package. @@ -47,6 +50,7 @@ MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` %files devel %manifest %{name}.manifest -%{_includedir}/system/device.h +%{_includedir}/device/*.h +%{_includedir}/system/*.h %{_libdir}/pkgconfig/*.pc %{_libdir}/libcapi-system-device.so diff --git a/src/battery.c b/src/battery.c index c609c37..a8c34af 100644 --- a/src/battery.c +++ b/src/battery.c @@ -1,12 +1,11 @@ /* - * capi-system-device - * Copyright (c) 2012 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * - * Licensed under the Apache License, Version 2.0 (the License); + * 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 + * 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, @@ -17,394 +16,72 @@ #include +#include #include -#include +#include #include -#include "device.h" -#include "device_log.h" -#define CHECK_ERR(val) \ - do { \ - if (val == DEVMAN_ERROR_NOT_SUPPORTED) \ - return DEVICE_ERROR_NOT_SUPPORTED; \ - else if (val == DEVMAN_ERROR_OPERATION_FAILED) \ - return DEVICE_ERROR_OPERATION_FAILED; \ - } while(0) +#include "battery.h" +#include "common.h" +#include "dbus.h" -int device_battery_get_percent(int* percent) -{ - if (percent == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - int pct = device_get_battery_pct(); - CHECK_ERR(pct); - - *percent = pct; - return DEVICE_ERROR_NONE; -} +#define METHOD_GET_PERCENT "GetPercent" -int device_battery_get_detail(int* percent) +int device_battery_get_percent(int *percent) { - if (percent == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - int pct = device_get_battery_pct_raw(); - CHECK_ERR(pct); + int ret; - *percent = pct; - return DEVICE_ERROR_NONE; -} - -int device_battery_is_full(bool* full) -{ - if (full == NULL) + if (!percent) return DEVICE_ERROR_INVALID_PARAMETER; - int f = device_is_battery_full(); - CHECK_ERR(f); + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, + METHOD_GET_PERCENT, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); - *full = (f == 1) ? true : false; + *percent = ret; return DEVICE_ERROR_NONE; } int device_battery_is_charging(bool *charging) { - // VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW - int value, err; + int ret, val; - if (charging == NULL) + if (!charging) return DEVICE_ERROR_INVALID_PARAMETER; - err = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value); - if (err < 0) + ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &val); + if (ret < 0 || val < 0 || val > 1) return DEVICE_ERROR_OPERATION_FAILED; - if (value == 1) { - *charging = true; - } else if (value == 0) { - *charging = false; - } else { - return DEVICE_ERROR_OPERATION_FAILED; - } - - return DEVICE_ERROR_NONE; -} - -static device_battery_cb changed_callback = NULL; -static void* changed_callback_user_data = NULL; - -static void battery_changed_inside_cb(keynode_t* key, void* user_data) -{ - const char* keyname = vconf_keynode_get_name(key); - - if (keyname != NULL && changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY) == 0) { - int percent = 0; - if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &percent) == 0) { - changed_callback(percent, changed_callback_user_data); - } - } -} - -int device_battery_set_cb(device_battery_cb callback, void* user_data) -{ - // VCONFKEY_SYSMAN_BATTERY_CAPACITY - int err; - if (callback == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - changed_callback = callback; - changed_callback_user_data = user_data; - - err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb, NULL); - if (err < 0) - return DEVICE_ERROR_INVALID_PARAMETER; - - return DEVICE_ERROR_NONE; -} - -int device_battery_unset_cb(void) -{ - int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - - changed_callback = NULL; - changed_callback_user_data = NULL; - - return DEVICE_ERROR_NONE; -} - -int device_battery_get_warning_status(device_battery_warn_e *status) -{ - if (status == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - int value, err; - - err = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &value); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - - if (value == VCONFKEY_SYSMAN_BAT_POWER_OFF) { - *status = DEVICE_BATTERY_WARN_EMPTY; - } else if (value == VCONFKEY_SYSMAN_BAT_CRITICAL_LOW) { - *status = DEVICE_BATTERY_WARN_CRITICAL; - } else if (value == VCONFKEY_SYSMAN_BAT_WARNING_LOW) { - *status = DEVICE_BATTERY_WARN_LOW; - } else if (value == VCONFKEY_SYSMAN_BAT_NORMAL) { - *status = DEVICE_BATTERY_WARN_NORMAL; - } else if (value == VCONFKEY_SYSMAN_BAT_FULL) { - *status = DEVICE_BATTERY_WARN_FULL; - } else { - return DEVICE_ERROR_OPERATION_FAILED; - } - - return DEVICE_ERROR_NONE; -} - -static device_battery_warn_cb warn_changed_callback = NULL; -static void* warn_changed_callback_user_data = NULL; -static device_battery_level_cb level_changed_callback = NULL; -static void* level_changed_callback_user_data = NULL; - -static void battery_warn_changed_inside_cb(keynode_t* key, void* user_data) -{ - const char* keyname = vconf_keynode_get_name(key); - - if (keyname != NULL && warn_changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW) == 0) { - int bat_state = 0; - if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) == 0) { - warn_changed_callback(bat_state-1, warn_changed_callback_user_data); - } - } -} - -static void battery_level_changed_inside_cb(keynode_t* key, void* user_data) -{ - const char* keyname; - keyname = vconf_keynode_get_name(key); - - if (keyname != NULL && level_changed_callback != NULL && - strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS) == 0) { - int bat_state = 0; - if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &bat_state) == 0) { - level_changed_callback(bat_state, level_changed_callback_user_data); - } - } -} - -int device_battery_warning_set_cb(device_battery_warn_cb callback, void* user_data) -{ - // VCONFKEY_SYSMAN_BATTERY_STATUS_LOW - int err; - - if (callback == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - warn_changed_callback = callback; - warn_changed_callback_user_data = user_data; - - err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb, NULL); - if (err < 0) - return DEVICE_ERROR_INVALID_PARAMETER; - - return DEVICE_ERROR_NONE; -} - -int device_battery_warning_unset_cb(void) -{ - int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - - warn_changed_callback = NULL; - warn_changed_callback_user_data = NULL; - - return DEVICE_ERROR_NONE; -} - -static device_battery_remaining_time_changed_cb timetofull_changed_cb = NULL; -static device_battery_remaining_time_changed_cb timetoempty_changed_cb = NULL; -static void* timetofull_cb_user_data = NULL; -static void* timetoempty_cb_user_data = NULL; - -static void device_battery_time_timetofull_inside_cb(keynode_t* key, void* user_data) -{ - const char* keyname = vconf_keynode_get_name(key); - int time = -1, err= -1; - - if (keyname == NULL) - return; - - if (strcmp(keyname, VCONFKEY_PM_BATTERY_TIMETOFULL) == 0) { - if (timetofull_changed_cb != NULL) { - err = device_battery_get_remaining_time( - DEVICE_BATTERY_REMAINING_TIME_TO_FULLY_CHARGED, &time); - if ((err == DEVICE_ERROR_NONE) && (time >= 0)) - timetofull_changed_cb(time, timetofull_cb_user_data); - } - } -} - -static void device_battery_time_timetoempty_inside_cb(keynode_t* key, void* user_data) -{ - const char* keyname = vconf_keynode_get_name(key); - int time = -1, err= -1; - - if (keyname == NULL) - return; - - if (strcmp(keyname, VCONFKEY_PM_BATTERY_TIMETOEMPTY) == 0) { - if (timetoempty_changed_cb != NULL) { - err = device_battery_get_remaining_time( - DEVICE_BATTERY_REMAINING_TIME_TO_DISCHARGED, &time); - if ((err == DEVICE_ERROR_NONE) && (time >= 0)) - timetoempty_changed_cb(time, timetoempty_cb_user_data); - } - } -} - -int device_battery_get_remaining_time(device_battery_remaining_time_type_e type, int* time) -{ - bool charging = false; - int err = -1; - - err = device_battery_is_charging(&charging); - if (err != DEVICE_ERROR_NONE) - return DEVICE_ERROR_OPERATION_FAILED; - - switch(type) { - case DEVICE_BATTERY_REMAINING_TIME_TO_FULLY_CHARGED: - if (charging == false) { - return DEVICE_ERROR_OPERATION_FAILED; - } else { - err = vconf_get_int(VCONFKEY_PM_BATTERY_TIMETOFULL, time); - if (err < 0 || time < 0) { - return DEVICE_ERROR_OPERATION_FAILED; - } - } - break; - case DEVICE_BATTERY_REMAINING_TIME_TO_DISCHARGED: - if (charging == true) { - return DEVICE_ERROR_OPERATION_FAILED; - } else { - err = vconf_get_int(VCONFKEY_PM_BATTERY_TIMETOEMPTY, time); - if (err < 0 || time < 0) { - return DEVICE_ERROR_OPERATION_FAILED; - } - } - break; - default: - return DEVICE_ERROR_INVALID_PARAMETER; - } - return DEVICE_ERROR_NONE; -} - -int device_battery_set_remaining_time_changed_cb(device_battery_remaining_time_type_e type, - device_battery_remaining_time_changed_cb callback, void* user_data) -{ - int err; - - if (callback == NULL) - return DEVICE_ERROR_INVALID_PARAMETER; - - switch(type) { - case DEVICE_BATTERY_REMAINING_TIME_TO_FULLY_CHARGED: - timetofull_changed_cb = callback; - timetofull_cb_user_data = user_data; - err = vconf_notify_key_changed(VCONFKEY_PM_BATTERY_TIMETOFULL, - device_battery_time_timetofull_inside_cb, NULL); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - break; - case DEVICE_BATTERY_REMAINING_TIME_TO_DISCHARGED: - timetoempty_changed_cb = callback; - timetoempty_cb_user_data = user_data; - err = vconf_notify_key_changed(VCONFKEY_PM_BATTERY_TIMETOEMPTY, - device_battery_time_timetoempty_inside_cb, NULL); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - break; - default: - return DEVICE_ERROR_INVALID_PARAMETER; - } - return DEVICE_ERROR_NONE; -} - -int device_battery_unset_remaining_time_changed_cb(device_battery_remaining_time_type_e type) -{ - int err; - - switch(type) { - case DEVICE_BATTERY_REMAINING_TIME_TO_FULLY_CHARGED: - err = vconf_ignore_key_changed(VCONFKEY_PM_BATTERY_TIMETOFULL, - device_battery_time_timetofull_inside_cb); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - timetofull_changed_cb = NULL; - timetofull_cb_user_data = NULL; - break; - case DEVICE_BATTERY_REMAINING_TIME_TO_DISCHARGED: - err = vconf_ignore_key_changed(VCONFKEY_PM_BATTERY_TIMETOEMPTY, - device_battery_time_timetoempty_inside_cb); - if (err < 0) - return DEVICE_ERROR_OPERATION_FAILED; - timetoempty_changed_cb = NULL; - timetoempty_cb_user_data = NULL; - break; - default: - return DEVICE_ERROR_INVALID_PARAMETER; - } + *charging = val; return DEVICE_ERROR_NONE; } int device_battery_get_level_status(device_battery_level_e *status) { - int value, err; + int val, ret; - if (status == NULL) + if (!status) return DEVICE_ERROR_INVALID_PARAMETER; - - err = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &value); - if (err < 0) + ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &val); + if (ret < 0) return DEVICE_ERROR_OPERATION_FAILED; - if (value == VCONFKEY_SYSMAN_BAT_LEVEL_EMPTY) { + if (val == VCONFKEY_SYSMAN_BAT_LEVEL_EMPTY) *status = DEVICE_BATTERY_LEVEL_EMPTY; - } else if (value == VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL) { + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL) *status = DEVICE_BATTERY_LEVEL_CRITICAL; - } else if (value == VCONFKEY_SYSMAN_BAT_LEVEL_LOW) { + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_LOW) *status = DEVICE_BATTERY_LEVEL_LOW; - } else if (value == VCONFKEY_SYSMAN_BAT_LEVEL_HIGH) { + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_HIGH) *status = DEVICE_BATTERY_LEVEL_HIGH; - } else if (value == VCONFKEY_SYSMAN_BAT_LEVEL_FULL) { + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_FULL) *status = DEVICE_BATTERY_LEVEL_FULL; - } else { - return DEVICE_ERROR_OPERATION_FAILED; - } - - return DEVICE_ERROR_NONE; -} - -int device_battery_level_set_cb(device_battery_level_cb callback, void* user_data) -{ - int err; - - - if (callback == NULL) { - err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, - battery_level_changed_inside_cb); - } else { - - err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, - battery_level_changed_inside_cb, NULL); - } - if (err < 0) + else return DEVICE_ERROR_OPERATION_FAILED; - level_changed_callback = callback; - level_changed_callback_user_data = user_data; - return DEVICE_ERROR_NONE; } diff --git a/src/callback.c b/src/callback.c new file mode 100644 index 0000000..39dd5ef --- /dev/null +++ b/src/callback.c @@ -0,0 +1,236 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 +#include +#include +#include +#include + +#include "callback.h" +#include "battery.h" +#include "display.h" +#include "common.h" +#include "dbus.h" +#include "list.h" + +struct device_cb_info { + device_changed_cb cb; + void *data; +}; + +static dd_list *device_cb_list[DEVICE_CALLBACK_MAX]; + +static void battery_capacity_cb(keynode_t *key, void *data) +{ + static device_callback_e type = DEVICE_CALLBACK_BATTERY_CAPACITY; + struct device_cb_info *cb_info; + dd_list *elem; + int val; + + val = vconf_keynode_get_int(key); + + /* invoke the each callback with value */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) + cb_info->cb(type, (void*)val, cb_info->data); +} + +static void battery_charging_cb(keynode_t *key, void *data) +{ + static device_callback_e type = DEVICE_CALLBACK_BATTERY_CHARGING; + struct device_cb_info *cb_info; + dd_list *elem; + int val; + + val = vconf_keynode_get_int(key); + + /* invoke the each callback with value */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) + cb_info->cb(type, (void*)val, cb_info->data); +} + +static void battery_level_cb(keynode_t *key, void *data) +{ + static device_callback_e type = DEVICE_CALLBACK_BATTERY_LEVEL; + struct device_cb_info *cb_info; + dd_list *elem; + int val, status; + + val = vconf_keynode_get_int(key); + + if (val == VCONFKEY_SYSMAN_BAT_LEVEL_EMPTY) + status = DEVICE_BATTERY_LEVEL_EMPTY; + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL) + status = DEVICE_BATTERY_LEVEL_CRITICAL; + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_LOW) + status = DEVICE_BATTERY_LEVEL_LOW; + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_HIGH) + status = DEVICE_BATTERY_LEVEL_HIGH; + else if (val == VCONFKEY_SYSMAN_BAT_LEVEL_FULL) + status = DEVICE_BATTERY_LEVEL_FULL; + else + status = -1; + + /* invoke the each callback with value */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) + cb_info->cb(type, (void*)status, cb_info->data); +} + +static void display_changed_cb(keynode_t *key, void *data) +{ + static device_callback_e type = DEVICE_CALLBACK_DISPLAY_STATE; + struct device_cb_info *cb_info; + dd_list *elem; + display_state_e state; + int val; + + val = vconf_keynode_get_int(key); + + switch(val) { + case 1: state = DISPLAY_STATE_NORMAL; + break; + case 2: state = DISPLAY_STATE_SCREEN_DIM; + break; + case 3: state = DISPLAY_STATE_SCREEN_OFF; + break; + default: state = -1; + break; + } + + /* invoke the each callback with value */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) + cb_info->cb(type, (void*)state, cb_info->data); +} + +static int register_request(device_callback_e type) +{ + switch (type) { + case DEVICE_CALLBACK_BATTERY_CAPACITY: + return vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, + battery_capacity_cb, NULL); + case DEVICE_CALLBACK_BATTERY_LEVEL: + return vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, + battery_level_cb, NULL); + case DEVICE_CALLBACK_BATTERY_CHARGING: + return vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, + battery_charging_cb, NULL); + case DEVICE_CALLBACK_DISPLAY_STATE: + return vconf_notify_key_changed(VCONFKEY_PM_STATE, + display_changed_cb, NULL); + default: + break; + } + + return -EINVAL; +} + +static int release_request(device_callback_e type) +{ + switch (type) { + case DEVICE_CALLBACK_BATTERY_CAPACITY: + return vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, + battery_capacity_cb); + case DEVICE_CALLBACK_BATTERY_LEVEL: + return vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, + battery_level_cb); + case DEVICE_CALLBACK_BATTERY_CHARGING: + return vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, + battery_charging_cb); + case DEVICE_CALLBACK_DISPLAY_STATE: + return vconf_ignore_key_changed(VCONFKEY_PM_STATE, + display_changed_cb); + default: + break; + } + + return -EINVAL; +} + +int device_add_callback(device_callback_e type, device_changed_cb cb, void *data) +{ + struct device_cb_info *cb_info; + dd_list *elem; + int ret, n; + + if (type < 0 || type >= DEVICE_CALLBACK_MAX) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (!cb) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* check if it is the first request */ + n = DD_LIST_LENGTH(device_cb_list[type]); + if (n == 0) { + ret = register_request(type); + if (ret < 0) + return DEVICE_ERROR_OPERATION_FAILED; + } + + /* check for the same request */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) { + if (cb_info->cb == cb) + return DEVICE_ERROR_ALREADY_IN_PROGRESS; + } + + /* add device changed callback to list (local) */ + cb_info = malloc(sizeof(struct device_cb_info)); + if (!cb_info) + return DEVICE_ERROR_OPERATION_FAILED; + + cb_info->cb = cb; + cb_info->data = data; + + DD_LIST_APPEND(device_cb_list[type], cb_info); + + return DEVICE_ERROR_NONE; +} + +int device_remove_callback(device_callback_e type, device_changed_cb cb) +{ + struct device_cb_info *cb_info; + dd_list *elem; + int ret, n; + + if (type < 0 || type >= DEVICE_CALLBACK_MAX) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (!cb) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* search for the same element with callback */ + DD_LIST_FOREACH(device_cb_list[type], elem, cb_info) { + if (cb_info->cb == cb) + break; + } + + if (!cb_info) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* remove device callback from list (local) */ + DD_LIST_REMOVE(device_cb_list[type], cb_info); + free(cb_info); + + /* check if this callback is last element */ + n = DD_LIST_LENGTH(device_cb_list[type]); + if (n == 0) { + ret = release_request(type); + if (ret < 0) + return DEVICE_ERROR_OPERATION_FAILED; + } + + return DEVICE_ERROR_NONE; +} diff --git a/include/device_log.h b/src/common.h similarity index 51% rename from include/device_log.h rename to src/common.h index 8752926..dd01165 100644 --- a/include/device_log.h +++ b/src/common.h @@ -14,17 +14,37 @@ * limitations under the License. */ -#ifndef __DEVICE_LOG_H__ -#define __DEVICE_LOG_H__ +#ifndef __COMMON_H__ +#define __COMMON_H__ #ifdef FEATURE_DEVICE_DLOG #define LOG_TAG "SYSTEM_DEVICE" #include - #define DEVICE_LOG(fmt, args...) SLOGD(fmt, ##args) - #define DEVICE_ERROR(fmt, args...) SLOGE(fmt, ##args) + #define _D(fmt, args...) SLOGD(fmt, ##args) + #define _I(fmt, args...) SLOGI(fmt, ##args) + #define _E(fmt, args...) SLOGE(fmt, ##args) #else - #define DEVICE_LOG(x, ...) - #define DEVICE_ERROR(x, ...) + #define _D(x, ...) + #define _I(x, ...) + #define _E(x, ...) #endif -#endif /* __DEVICE_LOG_H__ */ +#ifndef __CONSTRUCTOR__ +#define __CONSTRUCTOR__ __attribute__ ((constructor)) +#endif + +#include "device-error.h" + +static inline int errno_to_device_error(int err) +{ + if (err == -ECOMM) + return DEVICE_ERROR_PERMISSION_DENIED; + else if (err == -ENODEV || err == -ENOENT) + return DEVICE_ERROR_NOT_SUPPORTED; + else if (err < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + return DEVICE_ERROR_NONE; +} + +#endif /* __COMMON_H__ */ diff --git a/src/cpu.c b/src/cpu.c index 5754026..ef4becc 100644 --- a/src/cpu.c +++ b/src/cpu.c @@ -21,7 +21,7 @@ #include #include #include "device.h" -#include "device_log.h" +#include "common.h" #define PROC_STAT "/proc/stat" diff --git a/src/dbus.c b/src/dbus.c new file mode 100644 index 0000000..bf54116 --- /dev/null +++ b/src/dbus.c @@ -0,0 +1,235 @@ +/* + * system-dbus + * + * 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 +#include +#include +#include +#include + +#include "common.h" +#include "dbus.h" + +#define DBUS_REPLY_TIMEOUT (-1) + +struct pending_call_data { + dbus_pending_cb func; + void *data; +}; + +static int append_variant(DBusMessageIter *iter, const char *sig, char *param[]) +{ + char *ch; + int i; + int int_type; + uint64_t int64_type; + + if (!sig || !param) + return 0; + + for (ch = (char*)sig, i = 0; *ch != '\0'; ++i, ++ch) { + switch (*ch) { + case 'i': + int_type = atoi(param[i]); + dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &int_type); + break; + case 'u': + int_type = strtoul(param[i], NULL, 10); + dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &int_type); + break; + case 't': + int64_type = atoll(param[i]); + dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &int64_type); + break; + case 's': + dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, ¶m[i]); + break; + default: + return -EINVAL; + } + } + + return 0; +} + +int dbus_method_sync(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[]) +{ + DBusConnection *conn; + DBusMessage *msg; + DBusMessageIter iter; + DBusMessage *reply; + DBusError err; + int ret, result; + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL); + if (!conn) { + _E("dbus_bus_get error"); + return -EPERM; + } + + msg = dbus_message_new_method_call(dest, path, interface, method); + if (!msg) { + _E("dbus_message_new_method_call(%s:%s-%s)", + path, interface, method); + return -EBADMSG; + } + + dbus_message_iter_init_append(msg, &iter); + ret = append_variant(&iter, sig, param); + if (ret < 0) { + _E("append_variant error(%d) %s %s:%s-%s", + ret, dest, path, interface, method); + dbus_message_unref(msg); + return ret; + } + + dbus_error_init(&err); + + reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_REPLY_TIMEOUT, &err); + dbus_message_unref(msg); + if (!reply) { + _E("dbus_connection_send error(%s:%s) %s %s:%s-%s", + err.name, err.message, dest, path, interface, method); + dbus_error_free(&err); + return -ECOMM; + } + + ret = dbus_message_get_args(reply, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID); + dbus_message_unref(reply); + if (!ret) { + _E("no message : [%s:%s] %s %s:%s-%s", + err.name, err.message, dest, path, interface, method); + dbus_error_free(&err); + return -ENOMSG; + } + + return result; +} + +static void cb_pending(DBusPendingCall *pending, void *user_data) +{ + DBusMessage *msg; + DBusError err; + struct pending_call_data *data = user_data; + int ret; + + ret = dbus_pending_call_get_completed(pending); + if (!ret) { + _I("dbus_pending_call_get_completed() fail"); + dbus_pending_call_unref(pending); + return; + } + + dbus_error_init(&err); + msg = dbus_pending_call_steal_reply(pending); + if (!msg) { + _E("no message : [%s:%s]", err.name, err.message); + + if (data->func) { + dbus_set_error(&err, "org.tizen.system.deviced.NoReply", + "There was no reply to this method call"); + data->func(data->data, NULL, &err); + dbus_error_free(&err); + } + return; + } + + ret = dbus_set_error_from_message(&err, msg); + if (ret) { + _E("error msg : [%s:%s]", err.name, err.message); + + if (data->func) + data->func(data->data, NULL, &err); + dbus_error_free(&err); + } else { + if (data->func) + data->func(data->data, msg, &err); + } + + dbus_message_unref(msg); + dbus_pending_call_unref(pending); +} + +int dbus_method_async_with_reply(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[], dbus_pending_cb cb, int timeout, void *data) +{ + DBusConnection *conn; + DBusMessage *msg; + DBusMessageIter iter; + DBusPendingCall *pending = NULL; + struct pending_call_data *pdata; + int ret; + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL); + if (!conn) { + _E("dbus_bus_get error"); + return -EPERM; + } + + /* this function should be invoked to receive dbus messages + * does nothing if it's already been done */ + dbus_connection_setup_with_g_main(conn, NULL); + + msg = dbus_message_new_method_call(dest, path, interface, method); + if (!msg) { + _E("dbus_message_new_method_call(%s:%s-%s)", + path, interface, method); + return -EBADMSG; + } + + dbus_message_iter_init_append(msg, &iter); + ret = append_variant(&iter, sig, param); + if (ret < 0) { + _E("append_variant error(%d)%s %s:%s-%s", + ret, dest, path, interface, method); + dbus_message_unref(msg); + return ret; + } + + ret = dbus_connection_send_with_reply(conn, msg, &pending, timeout); + if (!ret) { + dbus_message_unref(msg); + _E("dbus_connection_send error(%s %s:%s-%s)", + dest, path, interface, method); + return -ECOMM; + } + + dbus_message_unref(msg); + + if (cb && pending) { + pdata = malloc(sizeof(struct pending_call_data)); + if (!pdata) + return -ENOMEM; + + pdata->func = cb; + pdata->data = data; + + ret = dbus_pending_call_set_notify(pending, cb_pending, pdata, free); + if (!ret) { + free(pdata); + dbus_pending_call_cancel(pending); + return -ECOMM; + } + } + + return 0; +} diff --git a/src/dbus.h b/src/dbus.h new file mode 100644 index 0000000..1e3fead --- /dev/null +++ b/src/dbus.h @@ -0,0 +1,55 @@ +/* + * system-dbus + * + * 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. + */ + + +#ifndef __DBUS_H__ +#define __DBUS_H__ + +#include + +#define DEVICED_BUS_NAME "org.tizen.system.deviced" +#define DEVICED_OBJECT_PATH "/Org/Tizen/System/DeviceD" +#define DEVICED_INTERFACE_NAME DEVICED_BUS_NAME + +/* Display service: start/stop display(pm), get/set brightness operations about display */ +#define DEVICED_PATH_DISPLAY DEVICED_OBJECT_PATH"/Display" +#define DEVICED_INTERFACE_DISPLAY DEVICED_INTERFACE_NAME".display" + +/* Battery service */ +#define DEVICED_PATH_BATTERY DEVICED_OBJECT_PATH"/Battery" +#define DEVICED_INTERFACE_BATTERY DEVICED_INTERFACE_NAME".Battery" + +/* Haptic service: operatioins about haptic */ +#define DEVICED_PATH_HAPTIC DEVICED_OBJECT_PATH"/Haptic" +#define DEVICED_INTERFACE_HAPTIC DEVICED_INTERFACE_NAME".haptic" + +/* Led service: play/stop led operations about led */ +#define DEVICED_PATH_LED DEVICED_OBJECT_PATH"/Led" +#define DEVICED_INTERFACE_LED DEVICED_INTERFACE_NAME".Led" + +int dbus_method_sync(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[]); + +typedef void (*dbus_pending_cb)(void *data, DBusMessage *msg, DBusError *err); + +int dbus_method_async_with_reply(const char *dest, const char *path, + const char *interface, const char *method, + const char *sig, char *param[], dbus_pending_cb cb, int timeout, void *data); + +#endif diff --git a/src/device.c b/src/device.c index d4fb899..4fdb11e 100644 --- a/src/device.c +++ b/src/device.c @@ -1,12 +1,11 @@ /* - * capi-system-device - * Copyright (c) 2012 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * - * Licensed under the Apache License, Version 2.0 (the License); + * 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 + * 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, @@ -17,29 +16,30 @@ #include -#include +#include +#include +#include +#include +#include + #include "device.h" -#include "device_log.h" +#include "common.h" #define CHECK_ERR(val) \ do { \ - if (val == DEVMAN_ERROR_NOT_SUPPORTED) \ - return DEVICE_ERROR_NOT_SUPPORTED; \ - else if (val == DEVMAN_ERROR_OPERATION_FAILED) \ + if (val < 0) { \ + if (errno == ENODEV) \ + return DEVICE_ERROR_NOT_SUPPORTED; \ return DEVICE_ERROR_OPERATION_FAILED; \ + } \ } while(0) -static int _display[] = { - DEV_DISPLAY_0, - DEV_DISPLAY_1, -}; - int device_get_display_numbers(int* device_number) { if(device_number == NULL) return DEVICE_ERROR_INVALID_PARAMETER; - *device_number = device_get_display_count(); + *device_number = display_get_count(); CHECK_ERR(*device_number); return DEVICE_ERROR_NONE; @@ -47,7 +47,7 @@ int device_get_display_numbers(int* device_number) int device_get_brightness(int disp_idx, int* value) { - int val, disp, max_id, ret; + int val, max_id, ret; if(value == NULL) return DEVICE_ERROR_INVALID_PARAMETER; @@ -59,8 +59,7 @@ int device_get_brightness(int disp_idx, int* value) if(disp_idx < 0 || disp_idx >= max_id) return DEVICE_ERROR_INVALID_PARAMETER; - disp = _display[disp_idx]; - val = device_get_display_brt(disp); + val = display_get_brightness(); CHECK_ERR(val); *value = val; @@ -69,8 +68,7 @@ int device_get_brightness(int disp_idx, int* value) int device_set_brightness(int disp_idx, int new_value) { - int max_value, val; - int disp, max_id, ret; + int max_value, val, max_id, ret; if(new_value < 0) return DEVICE_ERROR_INVALID_PARAMETER; @@ -82,15 +80,14 @@ int device_set_brightness(int disp_idx, int new_value) if(disp_idx < 0 || disp_idx >= max_id) return DEVICE_ERROR_INVALID_PARAMETER; - disp = _display[disp_idx]; - ret = device_get_max_brightness(disp, &max_value); + ret = device_get_max_brightness(disp_idx, &max_value); if (ret != DEVICE_ERROR_NONE) return ret; if(new_value > max_value) return DEVICE_ERROR_INVALID_PARAMETER; - val = device_set_display_brt(disp, new_value); + val = display_set_brightness(new_value); CHECK_ERR(val); return DEVICE_ERROR_NONE; @@ -98,20 +95,20 @@ int device_set_brightness(int disp_idx, int new_value) int device_get_max_brightness(int disp_idx, int* max_value) { - int val, disp, max_id, ret; + int val, max_id, ret; if(max_value == NULL) return DEVICE_ERROR_INVALID_PARAMETER; ret = device_get_display_numbers(&max_id); + _E("max id : %d", max_id); if (ret != DEVICE_ERROR_NONE) return ret; if(disp_idx < 0 || disp_idx >= max_id) return DEVICE_ERROR_INVALID_PARAMETER; - - disp = _display[disp_idx]; - val = device_get_max_brt(disp); + + val = display_get_max_brightness(); CHECK_ERR(val); *max_value = val; @@ -120,7 +117,7 @@ int device_get_max_brightness(int disp_idx, int* max_value) int device_set_brightness_from_settings(int disp_idx) { - int max_id, disp, val, ret; + int max_id, val, ret; ret = device_get_display_numbers(&max_id); if (ret != DEVICE_ERROR_NONE) @@ -129,8 +126,7 @@ int device_set_brightness_from_settings(int disp_idx) if(disp_idx < 0 || disp_idx >= max_id) return DEVICE_ERROR_INVALID_PARAMETER; - disp = _display[disp_idx]; - val = device_release_brt_ctrl(disp); + val = display_release_brightness(); CHECK_ERR(val); return DEVICE_ERROR_NONE; @@ -138,8 +134,7 @@ int device_set_brightness_from_settings(int disp_idx) int device_set_brightness_to_settings(int disp_idx, int new_value) { - int max_value, val; - int disp, max_id, ret; + int max_value, val, max_id, ret; if(new_value < 0) return DEVICE_ERROR_INVALID_PARAMETER; @@ -151,61 +146,169 @@ int device_set_brightness_to_settings(int disp_idx, int new_value) if(disp_idx < 0 || disp_idx >= max_id) return DEVICE_ERROR_INVALID_PARAMETER; - disp = _display[disp_idx]; - ret = device_get_max_brightness(disp, &max_value); + ret = device_get_max_brightness(disp_idx, &max_value); if (ret != DEVICE_ERROR_NONE) return ret; if(new_value > max_value) return DEVICE_ERROR_INVALID_PARAMETER; - val = device_set_display_brt_with_settings(disp, new_value); + val = display_set_brightness_with_setting(new_value); CHECK_ERR(val); return DEVICE_ERROR_NONE; } -int device_flash_get_brightness(int *brightness) +int device_battery_get_detail(int *percent) { - int value; + _E("Deprecated api. Use device_battery_get_percent()"); + return DEVICE_ERROR_NOT_SUPPORTED; +} - if (brightness == NULL) +int device_battery_is_full(bool* full) +{ + if (full == NULL) return DEVICE_ERROR_INVALID_PARAMETER; - value = device_get_led_brt(); - CHECK_ERR(value); + int f = battery_is_full(); + CHECK_ERR(f); - *brightness = value; + *full = (f == 1) ? true : false; return DEVICE_ERROR_NONE; } -int device_flash_set_brightness(int brightness) +int device_battery_get_remaining_time(device_battery_remaining_time_type_e type, int *time) { - int max_value, value, ret; + _E("Deprecated api."); + return DEVICE_ERROR_NOT_SUPPORTED; +} - ret = device_flash_get_max_brightness(&max_value); - if (ret != DEVICE_ERROR_NONE) - return ret; +int device_battery_set_remaining_time_changed_cb(device_battery_remaining_time_type_e type, + device_battery_remaining_time_changed_cb callback, void* user_data) +{ + _E("Deprecated api."); + return DEVICE_ERROR_NOT_SUPPORTED; +} - if (brightness < 0 || brightness > max_value) +int device_battery_unset_remaining_time_changed_cb(device_battery_remaining_time_type_e type) +{ + _E("Deprecated api."); + return DEVICE_ERROR_NOT_SUPPORTED; +} + +static device_battery_cb changed_callback = NULL; +static void* changed_callback_user_data = NULL; + +static void battery_changed_inside_cb(keynode_t* key, void* user_data) +{ + const char* keyname = vconf_keynode_get_name(key); + + if (keyname != NULL && changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY) == 0) { + int percent = 0; + if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &percent) == 0) { + changed_callback(percent, changed_callback_user_data); + } + } +} + +int device_battery_set_cb(device_battery_cb callback, void* user_data) +{ + // VCONFKEY_SYSMAN_BATTERY_CAPACITY + int err; + if (callback == NULL) return DEVICE_ERROR_INVALID_PARAMETER; - value = device_set_led_brt(brightness); - CHECK_ERR(value); + changed_callback = callback; + changed_callback_user_data = user_data; + + err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb, NULL); + if (err < 0) + return DEVICE_ERROR_INVALID_PARAMETER; return DEVICE_ERROR_NONE; } -int device_flash_get_max_brightness(int *max_brightness) +int device_battery_unset_cb(void) { - int value; + int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb); + if (err < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + changed_callback = NULL; + changed_callback_user_data = NULL; - if (max_brightness == NULL) + return DEVICE_ERROR_NONE; +} + +int device_battery_get_warning_status(device_battery_warn_e *status) +{ + if (status == NULL) + return DEVICE_ERROR_INVALID_PARAMETER; + + int value, err; + + err = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &value); + if (err < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + if (value == VCONFKEY_SYSMAN_BAT_POWER_OFF) { + *status = DEVICE_BATTERY_WARN_EMPTY; + } else if (value == VCONFKEY_SYSMAN_BAT_CRITICAL_LOW) { + *status = DEVICE_BATTERY_WARN_CRITICAL; + } else if (value == VCONFKEY_SYSMAN_BAT_WARNING_LOW) { + *status = DEVICE_BATTERY_WARN_LOW; + } else if (value == VCONFKEY_SYSMAN_BAT_NORMAL) { + *status = DEVICE_BATTERY_WARN_NORMAL; + } else if (value == VCONFKEY_SYSMAN_BAT_FULL) { + *status = DEVICE_BATTERY_WARN_FULL; + } else { + return DEVICE_ERROR_OPERATION_FAILED; + } + + return DEVICE_ERROR_NONE; +} + +static device_battery_warn_cb warn_changed_callback = NULL; +static void* warn_changed_callback_user_data = NULL; + +static void battery_warn_changed_inside_cb(keynode_t* key, void* user_data) +{ + const char* keyname = vconf_keynode_get_name(key); + + if (keyname != NULL && warn_changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW) == 0) { + int bat_state = 0; + if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) == 0) { + warn_changed_callback(bat_state-1, warn_changed_callback_user_data); + } + } +} + +int device_battery_warning_set_cb(device_battery_warn_cb callback, void* user_data) +{ + // VCONFKEY_SYSMAN_BATTERY_STATUS_LOW + int err; + + if (callback == NULL) + return DEVICE_ERROR_INVALID_PARAMETER; + + warn_changed_callback = callback; + warn_changed_callback_user_data = user_data; + + err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb, NULL); + if (err < 0) return DEVICE_ERROR_INVALID_PARAMETER; - value = device_get_max_led(); - CHECK_ERR(value); + return DEVICE_ERROR_NONE; +} + +int device_battery_warning_unset_cb(void) +{ + int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb); + if (err < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + warn_changed_callback = NULL; + warn_changed_callback_user_data = NULL; - *max_brightness = value; return DEVICE_ERROR_NONE; } diff --git a/src/display.c b/src/display.c new file mode 100644 index 0000000..7cc728e --- /dev/null +++ b/src/display.c @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 +#include +#include + +#include "display.h" +#include "common.h" +#include "dbus.h" + +#define METHOD_GET_DISPLAY_COUNT "GetDisplayCount" +#define METHOD_GET_MAX_BRIGHTNESS "GetMaxBrightness" +#define METHOD_GET_BRIGHTNESS "GetBrightness" +#define METHOD_SET_BRIGHTNESS "SetBrightness" +#define METHOD_CHANGE_STATE "changestate" + +#define STR_LCD_OFF "lcdoff" +#define STR_LCD_DIM "lcddim" +#define STR_LCD_ON "lcdon" + +static int display_cnt = -1; +struct display { + int max; +} *display_arr; + +static int alloc_display(void) +{ + int i; + + if (display_cnt < 0) + return -ENODEV; + + display_arr = malloc(sizeof(struct display) * display_cnt); + if (!display_arr) + return -ENOMEM; + + for (i = 0; i < display_cnt; ++i) + display_arr[i].max = -1; + + return 0; +} + +int device_display_get_numbers(int *device_number) +{ + int ret; + + if (!device_number) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* if it is a first request */ + if (display_cnt < 0) { + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_GET_DISPLAY_COUNT, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + display_cnt = ret; + alloc_display(); + } + + *device_number = display_cnt; + _I("device_number : %d", *device_number); + return DEVICE_ERROR_NONE; +} + +int device_display_get_max_brightness(int display_index, int *max_brightness) +{ + int ret; + + if (!max_brightness) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (display_cnt < 0) + device_display_get_numbers(&display_cnt); + + if (display_index < 0 || display_index >= display_cnt) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (!display_arr && alloc_display() < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + if (display_arr[display_index].max < 0) { + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_GET_MAX_BRIGHTNESS, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + display_arr[display_index].max = ret; + } + + *max_brightness = display_arr[display_index].max; + return DEVICE_ERROR_NONE; +} + +int device_display_get_brightness(int display_index, int *brightness) +{ + int ret; + + if (!brightness) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (display_cnt < 0) + device_display_get_numbers(&display_cnt); + + if (display_index < 0 || display_index >= display_cnt) + return DEVICE_ERROR_INVALID_PARAMETER; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_GET_BRIGHTNESS, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + + *brightness = ret; + return DEVICE_ERROR_NONE; +} + +int device_display_set_brightness(int display_index, int brightness) +{ + char *arr[1]; + char str_val[32]; + int ret, max; + + if (display_cnt < 0) + device_display_get_numbers(&display_cnt); + + if (display_index < 0 || display_index >= display_cnt) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (display_arr[display_index].max < 0) + device_display_get_max_brightness(display_index, &max); + + if (brightness < 0 || brightness > display_arr[display_index].max) + return DEVICE_ERROR_INVALID_PARAMETER; + + snprintf(str_val, sizeof(str_val), "%d", brightness); + arr[0] = str_val; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_SET_BRIGHTNESS, "i", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} + +int device_display_get_state(display_state_e *state) +{ + int ret, val; + + if (!state) + return DEVICE_ERROR_INVALID_PARAMETER; + + ret = vconf_get_int(VCONFKEY_PM_STATE, &val); + if (ret < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + if (val == VCONFKEY_PM_STATE_NORMAL) + *state = DISPLAY_STATE_NORMAL; + else if (val == VCONFKEY_PM_STATE_LCDDIM) + *state = DISPLAY_STATE_SCREEN_DIM; + else if (val == VCONFKEY_PM_STATE_LCDOFF) + *state = DISPLAY_STATE_SCREEN_OFF; + else + return DEVICE_ERROR_OPERATION_FAILED; + + return DEVICE_ERROR_NONE; +} + +static char *get_state_str(display_state_e state) +{ + switch (state) { + case DISPLAY_STATE_NORMAL: + return STR_LCD_ON; + case DISPLAY_STATE_SCREEN_DIM: + return STR_LCD_DIM; + case DISPLAY_STATE_SCREEN_OFF: + return STR_LCD_OFF; + default: + break; + } + return NULL; +} + +int device_display_change_state(display_state_e state) +{ + char *str, *arr[1]; + int ret; + + if (state < DISPLAY_STATE_NORMAL || state > DISPLAY_STATE_SCREEN_OFF) + return DEVICE_ERROR_INVALID_PARAMETER; + + str = get_state_str(state); + if (!str) + return DEVICE_ERROR_INVALID_PARAMETER; + + arr[0] = str; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_CHANGE_STATE, "s", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} diff --git a/src/haptic.c b/src/haptic.c new file mode 100644 index 0000000..6d70a62 --- /dev/null +++ b/src/haptic.c @@ -0,0 +1,179 @@ +/* + * 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 +#include + +#include "haptic.h" +#include "common.h" +#include "dbus.h" + +#define METHOD_GET_COUNT "GetCount" +#define METHOD_OPEN_DEVICE "OpenDevice" +#define METHOD_CLOSE_DEVICE "CloseDevice" +#define METHOD_STOP_DEVICE "StopDevice" +#define METHOD_VIBRATE_MONOTONE "VibrateMonotone" + +enum feedback_e +{ + HAPTIC_FEEDBACK_MIN = 0, + HAPTIC_FEEDBACK_MAX = 100, +}; + +enum priority_e +{ + HAPTIC_PRIORITY_MIN = 0, + HAPTIC_PRIORITY_MIDDLE, + HAPTIC_PRIORITY_HIGH, +}; + +int device_haptic_get_count(int *device_number) +{ + int ret; + + if (!device_number) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* request to deviced to get haptic count */ + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_HAPTIC, DEVICED_INTERFACE_HAPTIC, + METHOD_GET_COUNT, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + + *device_number = ret; + return DEVICE_ERROR_NONE; +} + +int device_haptic_open(int device_index, haptic_device_h *device_handle) +{ + char str_index[32]; + char *arr[1]; + int ret, max; + + ret = device_haptic_get_count(&max); + if (ret < 0) + return ret; + + if (device_index < 0 || device_index >= max) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (!device_handle) + return DEVICE_ERROR_INVALID_PARAMETER; + + snprintf(str_index, sizeof(str_index), "%d", device_index); + arr[0] = str_index; + + /* request to deviced to open haptic device */ + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_HAPTIC, DEVICED_INTERFACE_HAPTIC, + METHOD_OPEN_DEVICE, "i", arr); + if (ret < 0) + return errno_to_device_error(ret); + + *device_handle = (haptic_device_h)ret; + return DEVICE_ERROR_NONE; +} + +int device_haptic_close(haptic_device_h device_handle) +{ + char str_handle[32]; + char *arr[1]; + int ret; + + if (!device_handle) + return DEVICE_ERROR_INVALID_PARAMETER; + + snprintf(str_handle, sizeof(str_handle), "%u", (unsigned int)device_handle); + arr[0] = str_handle; + + /* request to deviced to open haptic device */ + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_HAPTIC, DEVICED_INTERFACE_HAPTIC, + METHOD_CLOSE_DEVICE, "u", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} + +int device_haptic_vibrate(haptic_device_h device_handle, int duration, int feedback, haptic_effect_h *effect_handle) +{ + char str_handle[32]; + char str_duration[32]; + char str_feedback[32]; + char str_priority[32]; + char *arr[4]; + int ret, priority; + + if (!device_handle) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (duration < 0) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (feedback < HAPTIC_FEEDBACK_MIN || feedback > HAPTIC_FEEDBACK_MAX) + return DEVICE_ERROR_INVALID_PARAMETER; + + priority = HAPTIC_PRIORITY_MIN; + + snprintf(str_handle, sizeof(str_handle), "%u", (unsigned int)device_handle); + arr[0] = str_handle; + snprintf(str_duration, sizeof(str_duration), "%d", duration); + arr[1] = str_duration; + snprintf(str_feedback, sizeof(str_feedback), "%d", feedback); + arr[2] = str_feedback; + snprintf(str_priority, sizeof(str_priority), "%d", priority); + arr[3] = str_priority; + + /* request to deviced to vibrate haptic device */ + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_HAPTIC, DEVICED_INTERFACE_HAPTIC, + METHOD_VIBRATE_MONOTONE, "uiii", arr); + if (ret < 0) + return errno_to_device_error(ret); + + if (effect_handle) + *effect_handle = (haptic_effect_h)ret; + + return DEVICE_ERROR_NONE; +} + +int device_haptic_stop(haptic_device_h device_handle, haptic_effect_h effect_handle) +{ + char str_handle[32]; + char *arr[1]; + int ret; + + if (!device_handle) + return DEVICE_ERROR_INVALID_PARAMETER; + + /* TODO : support to stop haptic effect */ + snprintf(str_handle, sizeof(str_handle), "%u", (unsigned int)device_handle); + arr[0] = str_handle; + + /* request to deviced to open haptic device */ + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_HAPTIC, DEVICED_INTERFACE_HAPTIC, + METHOD_STOP_DEVICE, "u", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} diff --git a/src/led.c b/src/led.c new file mode 100644 index 0000000..c1718fb --- /dev/null +++ b/src/led.c @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 +#include +#include +#include + +#include "led.h" +#include "common.h" +#include "dbus.h" + +#define METHOD_GET_MAX_BRIGHTNESS "GetMaxBrightness" +#define METHOD_GET_BRIGHTNESS "GetBrightness" +#define METHOD_SET_BRIGHTNESS "SetBrightness" +#define METHOD_PLAY_CUSTOM "playcustom" +#define METHOD_STOP_CUSTOM "stopcustom" + +#define FRONT_LED_FEATURE "tizen.org/feature/led" +#define CAMERA_LED_FEATURE "tizen.org/feature/camera.back.flash" + +static bool support_front_led; +static bool support_camera_led; + +static void __CONSTRUCTOR__ init(void) +{ + int ret; + bool val; + + ret = system_info_get_platform_bool(FRONT_LED_FEATURE, &val); + if (ret == SYSTEM_INFO_ERROR_NONE && val) + support_front_led = true; + + ret = system_info_get_platform_bool(CAMERA_LED_FEATURE, &val); + if (ret == SYSTEM_INFO_ERROR_NONE && val) + support_camera_led = true; +} + +int device_flash_get_max_brightness(int *max_brightness) +{ + int ret; + + if (!support_camera_led) + return DEVICE_ERROR_NOT_SUPPORTED; + + if (!max_brightness) + return DEVICE_ERROR_INVALID_PARAMETER; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, + METHOD_GET_MAX_BRIGHTNESS, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + + *max_brightness = ret; + return DEVICE_ERROR_NONE; +} + +int device_flash_get_brightness(int *brightness) +{ + int ret; + + if (!support_camera_led) + return DEVICE_ERROR_NOT_SUPPORTED; + + if (!brightness) + return DEVICE_ERROR_INVALID_PARAMETER; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, + METHOD_GET_BRIGHTNESS, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + + *brightness = ret; + return DEVICE_ERROR_NONE; +} + +int device_flash_set_brightness(int brightness) +{ + char *arr[2]; + char buf_val[32]; + char buf_noti[32]; + int max, ret; + + if (!support_camera_led) + return DEVICE_ERROR_NOT_SUPPORTED; + + ret = device_flash_get_max_brightness(&max); + if (ret < 0) + return ret; + + if (brightness < 0 || brightness > max) + return DEVICE_ERROR_INVALID_PARAMETER; + + snprintf(buf_val, sizeof(buf_val), "%d", brightness); + arr[0] = buf_val; + snprintf(buf_noti, sizeof(buf_noti), "%d", 0); + arr[1] = buf_noti; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, + METHOD_SET_BRIGHTNESS, "ii", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} + +int device_led_play_custom(int on, int off, unsigned int color, unsigned int flags) +{ + char *arr[4]; + char str_on[32], str_off[32]; + char str_color[32], str_flags[32]; + int ret; + + if (!support_front_led) + return DEVICE_ERROR_NOT_SUPPORTED; + + if (on < 0 || off < 0) + return DEVICE_ERROR_INVALID_PARAMETER; + + snprintf(str_on, sizeof(str_on), "%d", on); + arr[0] = str_on; + snprintf(str_off, sizeof(str_off), "%d", off); + arr[1] = str_off; + snprintf(str_color, sizeof(str_color), "%lu", (long unsigned int)color); + arr[2] = str_color; + snprintf(str_flags, sizeof(str_flags), "%lu", (long unsigned int)flags); + arr[3] = str_flags; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, + METHOD_PLAY_CUSTOM, "iiuu", arr); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} + +int device_led_stop_custom(void) +{ + int ret; + + if (!support_front_led) + return DEVICE_ERROR_NOT_SUPPORTED; + + ret = dbus_method_sync(DEVICED_BUS_NAME, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, + METHOD_STOP_CUSTOM, NULL, NULL); + if (ret < 0) + return errno_to_device_error(ret); + + return DEVICE_ERROR_NONE; +} diff --git a/src/list.h b/src/list.h new file mode 100644 index 0000000..712ca70 --- /dev/null +++ b/src/list.h @@ -0,0 +1,83 @@ +/* + * deviced + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * 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. + */ + +#ifndef __LIST_H__ +#define __LIST_H__ + +#include + +#define EINA_LIST_APPEND(a, b) \ + a = eina_list_append(a, b) + +#define EINA_LIST_REMOVE(a, b) \ + a = eina_list_remove(a, b) + +#define EINA_LIST_REMOVE_LIST(a, b) \ + a = eina_list_remove_list(a, b) + +#define EINA_LIST_FREE_LIST(a) \ + a = eina_list_free(a) + +#define EINA_LIST_PROMOTE_LIST(a, b) \ + a = eina_list_promote_list(a, b) + +#ifdef EINA_LIST +#include +typedef Eina_List dd_list; +#define DD_LIST_PREPEND(a, b) \ + a = eina_list_prepend(a, b) +#define DD_LIST_APPEND(a, b) \ + a = eina_list_append(a, b) +#define DD_LIST_REMOVE(a, b) \ + a = eina_list_remove(a, b) +#define DD_LIST_LENGTH(a) \ + eina_list_count(a) +#define DD_LIST_NTH(a, b) \ + eina_list_nth(a, b) +#define DD_LIST_FREE_LIST(a) \ + a = eina_list_free(a) +#define DD_LIST_FOREACH(head, elem, node) \ + EINA_LIST_FOREACH(head, elem, node) +#define DD_LIST_FOREACH_SAFE(head, elem, elem_next, node) \ + EINA_LIST_FOREACH_SAFE(head, elem, elem_next, node) + +#else +#include +typedef GList dd_list; +#define DD_LIST_PREPEND(a, b) \ + a = g_list_prepend(a, (gpointer)b) +#define DD_LIST_APPEND(a, b) \ + a = g_list_append(a, (gpointer)b) +#define DD_LIST_REMOVE(a, b) \ + a = g_list_remove(a, (gpointer)b) +#define DD_LIST_LENGTH(a) \ + g_list_length(a) +#define DD_LIST_NTH(a, b) \ + g_list_nth_data(a, b) +#define DD_LIST_FREE_LIST(a) \ + g_list_free(a) +#define DD_LIST_FOREACH(head, elem, node) \ + for (elem = head, node = NULL; elem && ((node = elem->data) != NULL); elem = elem->next, node = NULL) +#define DD_LIST_FOREACH_SAFE(head, elem, elem_next, node) \ + for (elem = head, elem_next = g_list_next(elem), node = NULL; \ + elem && ((node = elem->data) != NULL); \ + elem = elem_next, elem_next = g_list_next(elem), node = NULL) + +#endif + +#endif diff --git a/src/memory.c b/src/memory.c index 04c0a7d..b4f42a0 100644 --- a/src/memory.c +++ b/src/memory.c @@ -21,7 +21,7 @@ #include #include #include "device.h" -#include "device_log.h" +#include "common.h" #define PROC_MEMORY "/proc/meminfo" diff --git a/src/power.c b/src/power.c new file mode 100644 index 0000000..8fc1831 --- /dev/null +++ b/src/power.c @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 +#include +#include +#include + +#include "power.h" +#include "display.h" +#include "common.h" +#include "dbus.h" + +/** + * Parameters for device_power_request_lock() + */ +#define STAY_CUR_STATE 0x1 +#define GOTO_STATE_NOW 0x2 +#define HOLD_KEY_BLOCK 0x4 +#define STANDBY_MODE 0x8 + +/** + * Parameters for device_power_request_unlock() + */ +#define PM_SLEEP_MARGIN 0x0 /**< keep guard time for unlock */ +#define PM_RESET_TIMER 0x1 /**< reset timer for unlock */ +#define PM_KEEP_TIMER 0x2 /**< keep timer for unlock */ + +#define METHOD_LOCK_STATE "lockstate" +#define METHOD_UNLOCK_STATE "unlockstate" +#define METHOD_CHANGE_STATE "changestate" + +#define STR_STAYCURSTATE "staycurstate" +#define STR_GOTOSTATENOW "gotostatenow" + +#define STR_HOLDKEYBLOCK "holdkeyblock" +#define STR_STANDBYMODE "standbymode" +#define STR_NULL "NULL" + +#define STR_SLEEP_MARGIN "sleepmargin" +#define STR_RESET_TIMER "resettimer" +#define STR_KEEP_TIMER "keeptimer" + +#define STR_LCD_OFF "lcdoff" +#define STR_LCD_DIM "lcddim" +#define STR_LCD_ON "lcdon" + +static char *get_state_str(display_state_e state) +{ + switch (state) { + case DISPLAY_STATE_NORMAL: + return STR_LCD_ON; + case DISPLAY_STATE_SCREEN_DIM: + return STR_LCD_DIM; + case DISPLAY_STATE_SCREEN_OFF: + return STR_LCD_OFF; + default: + break; + } + return NULL; +} + +static void lock_cb(void *data, DBusMessage *msg, DBusError *unused) +{ + DBusError err; + int ret, val; + + if (!msg) + return; + + dbus_error_init(&err); + ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &val, DBUS_TYPE_INVALID); + if (!ret) { + _E("no message [%s:%s]", err.name, err.message); + dbus_error_free(&err); + return; + } + + _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_LOCK_STATE, val); +} + +static int lock_state(display_state_e state, unsigned int flag, int timeout_ms) +{ + char *arr[4]; + char str_timeout[32]; + + arr[0] = get_state_str(state); + if (!arr[0]) + return -EINVAL; + + if (flag & GOTO_STATE_NOW) + arr[1] = STR_GOTOSTATENOW; + else + arr[1] = STR_STAYCURSTATE; + + if (flag & HOLD_KEY_BLOCK) + arr[2] = STR_HOLDKEYBLOCK; + else if (flag & STANDBY_MODE) + arr[2] = STR_STANDBYMODE; + else + arr[2] = STR_NULL; + + snprintf(str_timeout, sizeof(str_timeout), "%d", timeout_ms); + arr[3] = str_timeout; + + return dbus_method_async_with_reply(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_LOCK_STATE, "sssi", arr, lock_cb, -1, NULL); +} + +static void unlock_cb(void *data, DBusMessage *msg, DBusError *unused) +{ + DBusError err; + int ret, val; + + if (!msg) + return; + + dbus_error_init(&err); + ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &val, DBUS_TYPE_INVALID); + if (!ret) { + _E("no message [%s:%s]", err.name, err.message); + dbus_error_free(&err); + return; + } + + _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_UNLOCK_STATE, val); +} + +static int unlock_state(display_state_e state, unsigned int flag) +{ + char *arr[2]; + + arr[0] = get_state_str(state); + if (!arr[0]) + return -EINVAL; + + if (flag == PM_SLEEP_MARGIN) + arr[1] = STR_SLEEP_MARGIN; + else if (flag == PM_RESET_TIMER) + arr[1] = STR_RESET_TIMER; + else if (flag == PM_KEEP_TIMER) + arr[1] = STR_KEEP_TIMER; + else + return -EINVAL; + + return dbus_method_async_with_reply(DEVICED_BUS_NAME, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, + METHOD_UNLOCK_STATE, "ss", arr, unlock_cb, -1, NULL); +} + +int device_power_request_lock(power_lock_e type, int timeout_ms) +{ + int ret; + + if (timeout_ms < 0) + return DEVICE_ERROR_INVALID_PARAMETER; + + if (type == POWER_LOCK_CPU) + ret = lock_state(DISPLAY_STATE_SCREEN_OFF, STAY_CUR_STATE, timeout_ms); + else if (type == POWER_LOCK_DISPLAY) + ret = lock_state(DISPLAY_STATE_NORMAL, STAY_CUR_STATE, timeout_ms); + else if (type == POWER_LOCK_DISPLAY_DIM) + ret = lock_state(DISPLAY_STATE_SCREEN_DIM, STAY_CUR_STATE, timeout_ms); + else + return DEVICE_ERROR_INVALID_PARAMETER; + + if (ret == -ECOMM) + return DEVICE_ERROR_PERMISSION_DENIED; + else if (ret < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + return DEVICE_ERROR_NONE; +} + +int device_power_release_lock(power_lock_e type) +{ + int ret; + + if (type == POWER_LOCK_CPU) + ret = unlock_state(DISPLAY_STATE_SCREEN_OFF, PM_SLEEP_MARGIN); + else if (type == POWER_LOCK_DISPLAY) + ret = unlock_state(DISPLAY_STATE_NORMAL, PM_KEEP_TIMER); + else if (type == POWER_LOCK_DISPLAY_DIM) + ret = unlock_state(DISPLAY_STATE_SCREEN_DIM, PM_KEEP_TIMER); + else + return DEVICE_ERROR_INVALID_PARAMETER; + + if (ret == -ECOMM) + return DEVICE_ERROR_PERMISSION_DENIED; + else if (ret < 0) + return DEVICE_ERROR_OPERATION_FAILED; + + return DEVICE_ERROR_NONE; +} + +int device_power_wakeup(bool dim) +{ + if (dim) + return device_display_change_state(DISPLAY_STATE_SCREEN_DIM); + + return device_display_change_state(DISPLAY_STATE_NORMAL); +} -- 2.7.4