From 47178f4934128e4a4f22d7a050c72d987c280555 Mon Sep 17 00:00:00 2001 From: chakradhar Date: Tue, 17 Dec 2019 10:58:26 +0530 Subject: [PATCH] Gesture repository Change-Id: I79f46496ffcd6dee4a9bdd6966b73034d433c148 --- CMakeLists.txt | 59 +++++++ LICENSE | 203 ++++++++++++++++++++++++ capi-context-gesture.pc.in | 13 ++ doc/gesture_recognition_doc.h | 149 ++++++++++++++++++ include/gesture_recognition.h | 269 ++++++++++++++++++++++++++++++++ packaging/capi-context-gesture.manifest | 5 + packaging/capi-context-gesture.spec | 70 +++++++++ src/Gesture.cpp | 157 +++++++++++++++++++ src/GestureSensor.cpp | 101 ++++++++++++ src/GestureSensor.h | 61 ++++++++ src/ISensorListener.h | 31 ++++ src/SensorAdapter.cpp | 135 ++++++++++++++++ src/SensorAdapter.h | 55 +++++++ src/TypesInternal.cpp | 35 +++++ src/TypesInternal.h | 88 +++++++++++ 15 files changed, 1431 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 capi-context-gesture.pc.in create mode 100644 doc/gesture_recognition_doc.h create mode 100644 include/gesture_recognition.h create mode 100644 packaging/capi-context-gesture.manifest create mode 100644 packaging/capi-context-gesture.spec create mode 100644 src/Gesture.cpp create mode 100644 src/GestureSensor.cpp create mode 100644 src/GestureSensor.h create mode 100644 src/ISensorListener.h create mode 100644 src/SensorAdapter.cpp create mode 100644 src/SensorAdapter.h create mode 100644 src/TypesInternal.cpp create mode 100644 src/TypesInternal.h diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..214b460 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,59 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(capi-context-gesture) +INCLUDE(GNUInstallDirs) + +SET(target ${PROJECT_NAME}) + +# Source Lists +FILE(GLOB SRCS src/*.cpp) + +SET(inc_subdir "context-service") +SET(dependency "glib-2.0 dlog capi-base-common capi-system-info sensor") + +# Options +INCLUDE(FindPkgConfig) +INCLUDE_DIRECTORIES( + ${CMAKE_CURRENT_SOURCE_DIR}/include +) + +ADD_DEFINITIONS(-O2 -Wall -fPIC -flto -fdata-sections -ffunction-sections -fvisibility=hidden) +ADD_DEFINITIONS(-fdiagnostics-color) +SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIC -Wl,--as-needed -Wl,--gc-sections -Wl,--print-gc-sections") +SET(CMAKE_VERBOSE_MAKEFILE OFF) + +# Build +pkg_check_modules(pkgs REQUIRED ${dependency}) + +FOREACH(flag ${pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +ADD_LIBRARY(${target} SHARED ${SRCS}) +TARGET_LINK_LIBRARIES(${target} ${pkgs_LDFLAGS}) +SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS}) +SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_DEFINITIONS "LOG_TAG=\"CAPI-GESTURE\"") +SET_TARGET_PROPERTIES(${target} PROPERTIES SOVERSION ${MAJORVER}) +SET_TARGET_PROPERTIES(${target} PROPERTIES VERSION ${FULLVER}) + +# Install +INSTALL(TARGETS ${target} DESTINATION ${CMAKE_INSTALL_LIBDIR}) +INSTALL( + DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${inc_subdir} + FILES_MATCHING PATTERN "*.h" +) + +SET(VERSION ${FULLVER}) +SET(PC_PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(PC_NAME ${PROJECT_NAME}) +SET(PC_LIBDIR "${CMAKE_INSTALL_LIBDIR}") +SET(PC_INCLUDE "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/${inc_subdir}") +SET(PC_DESCRIPTION "Tizen C Native Gesture Recognition API") +SET(PC_REQUIRED ${dependency}) +SET(PC_LDFLAGS -l${target}) + +CONFIGURE_FILE( + ${PROJECT_NAME}.pc.in + ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc + @ONLY +) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6ce6ec7 --- /dev/null +++ b/LICENSE @@ -0,0 +1,203 @@ +Copyright (c) 2014 - 2017 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright (c) [yyyy] [name of copyright owner] + + 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. diff --git a/capi-context-gesture.pc.in b/capi-context-gesture.pc.in new file mode 100644 index 0000000..71c14c4 --- /dev/null +++ b/capi-context-gesture.pc.in @@ -0,0 +1,13 @@ +#Package Information for pkg-config + +prefix=@PC_PREFIX@ +exec_prefix=@PC_PREFIX@ +libdir=@PC_LIBDIR@ +includedir=@PC_INCLUDE@ + +Name: @PC_NAME@ +Description: @PC_DESCRIPTION@ +Version: @VERSION@ +Requires: @PC_REQUIRED@ +Libs: -L${libdir} @PC_LDFLAGS@ +Cflags: -I${includedir} diff --git a/doc/gesture_recognition_doc.h b/doc/gesture_recognition_doc.h new file mode 100644 index 0000000..48c913f --- /dev/null +++ b/doc/gesture_recognition_doc.h @@ -0,0 +1,149 @@ +/* + * gesture + * + * Copyright (c) 2014 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. + * + */ + +/** + * @ingroup CAPI_CONTEXT_FRAMEWORK + * @defgroup CAPI_CONTEXT_GESTURE_MODULE Gesture Recognition + * + * @brief The gesture recognition API allows applications to be notified and + * react when the user performs a gesture. + * + * @section CAPI_CONTEXT_GESTURE_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_CONTEXT_GESTURE_MODULE_OVERVIEW Overview + * + * + * The gesture recognition API allows to register callback functions to be called + * when the user performs meaningful gestures listed in #gesture_type_e, for example, + * shaking the device. + * + * Regardless of the gesture types, + * the overall process of using the gesture recognition API is as follows. + * + * If necessary, applications can check whether a gesture type is supported in the current device in advance. + * Note that, some gestures may not be supported in some devices, if the devices do not have necessary sensors. + + \code + bool supported = false; + gesture_is_supported(GESTURE_SHAKE, &supported); + + if (!supported) { + // Not supported in the current device. + } + \endcode + + * If the gesture type is supported, to use the recognition engine, + * an @c handle for the gesture recognition needs to be initialized first. + + \code + gesture_h handle; + + result = gesture_create(&handle); + + if (result != GESTURE_ERROR_NONE) { + // An error occurred. + } + \endcode + + * With the @c handle initialized, a callback function, + * which will be called when a specified gesture is detected, + * is registered by using gesture_start_recognition(). + + \code + result = gesture_start_recognition(handle, GESTURE_SHAKE, GESTURE_OPTION_DEFAULT, gesture_cb, NULL); + + if (result != GESTURE_ERROR_NONE) { + // An error occurred. Do necessary error handling here. + } + \endcode + + * Then the callback function @c gesture_cb will be called whenever the shake gesture is detected. + * + * Note that, calling gesture_start_recognition() twice on the same handle returns #GESTURE_ERROR_ALREADY_STARTED. + * If it needs to recognize another gesture using the same handle, + * the started recognition session should be stopped and restarted with the new gesture type. + * Otherwise, the application needs to created multiple handles, one handle for each gesture needed. + * + * An example callback function is as follows. + + \code + void gesture_cb(gesture_type_e type, const gesture_data_h data, double timestamp, gesture_error_e error, void *user_data) + { + int result; + gesture_event_e event; + + if (error != GESTURE_ERROR_NONE) { + // An error occurred. Do necessary error handling here. + return; + } + + if (type == GESTURE_SHAKE) { + // More than one gestures can be started using the same callback function. + + result = gesture_get_event(data, &event); + + if (result != GESTURE_ERROR_NONE) { + // An error occurred. Do necessary error handling here. + return; + } + + if (event == GESTURE_SHAKE_DETECTED) { + // Shake gesture is started + + } else if (event == GESTURE_SHAKE_FINISHED) { + // Shake gesture is stopped + } + } + } + \endcode + + * As we started gesture recognition with #GESTURE_SHAKE, + * gesture_get_event() returns either #GESTURE_SHAKE_DETECTED or #GESTURE_SHAKE_FINISHED + * as it has two different states, the gesture is started, or finished. + * Most of the gesture types, however, simply provide #GESTURE_EVENT_DETECTED. + * In such cases, #GESTURE_EVENT_NONE may not be delivered at all. + * + * If #GESTURE_TILT is started, within the callback function, + * gesture_get_tilt() can be used to extract the tilting degrees. + * + * Finally, if the application does not need to be notified the gesture event, + * it can be stopped as follows. + + \code + gesture_stop_recognition(handle); + + // If the handle will not be used anymore, its resources needs be released explicitly. + gesture_release(handle); + \endcode + + * @section CAPI_CONTEXT_GESTURE_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/sensor.gesture_recognition\n + * - http://tizen.org/feature/sensor.wrist_up + * + * It is recommended to design feature related code in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ diff --git a/include/gesture_recognition.h b/include/gesture_recognition.h new file mode 100644 index 0000000..4b9ae4b --- /dev/null +++ b/include/gesture_recognition.h @@ -0,0 +1,269 @@ +/* + * gesture + * + * Copyright (c) 2014 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 __TIZEN_GESTURE_H__ +#define __TIZEN_GESTURE_H__ + +/** + * @addtogroup CAPI_CONTEXT_GESTURE_MODULE + * @{ + */ + +#include + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +/** + * @brief The gesture recognizer controlling handle. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef struct _gesture_handle_s* gesture_h; + +/** + * @brief Delivery through gesture_recognition_cb() of gesture data handle. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef struct _gesture_data_s* gesture_data_h; + +/** + * @brief Enumeration for error codes. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef enum { + GESTURE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + GESTURE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid function parameter */ + GESTURE_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Function not implemented */ + GESTURE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + GESTURE_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + GESTURE_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + GESTURE_ERROR_ALREADY_STARTED = TIZEN_ERROR_CONTEXT | 0x01, /**< Recognition is already started */ + GESTURE_ERROR_NOT_STARTED = TIZEN_ERROR_CONTEXT | 0x02, /**< Recognition is not started */ + GESTURE_ERROR_OPERATION_FAILED = TIZEN_ERROR_CONTEXT | 0x04, /**< Operation failed because of a system error */ +} gesture_error_e; + +/** + * @brief Enumeration for gesture types. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef enum { + GESTURE_DOUBLE_TAP = 1, /**< The mobile device is tapped twice */ + GESTURE_MOVE_TO_EAR, /**< The mobile device is moved near to an ear */ + GESTURE_NO_MOVE, /**< The mobile device is being stopped for a while */ + GESTURE_PICK_UP, /**< The mobile device is picked up */ + GESTURE_SHAKE, /**< The mobile device is quickly moved back and forth */ + GESTURE_SNAP, /**< The mobile device is moved along an axis and back */ + GESTURE_TILT, /**< The mobile device is tilted */ + GESTURE_TURN_FACE_DOWN, /**< The mobile device is flipped from face to back */ + GESTURE_WRIST_UP, /**< The wearable device is moved and faced up */ +} gesture_type_e; + +/** + * @brief Enumeration for gesture recognition option. + * @details If the default option is used, the system tries to reduce power consumption. + * For example, the recognition engine may stop detecting gestures if the display is turned off. + * Using #GESTURE_OPTION_ALWAYS_ON disables such power-saving functionalities. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef enum { + GESTURE_OPTION_DEFAULT = 0, /**< Running in the default setting */ + GESTURE_OPTION_ALWAYS_ON = 1, /**< Trying to detect gestures always */ +} gesture_option_e; + +/** + * @brief Enumeration for gesture event types. + * @details With regards to type of the gesture, gesture_get_event() returns one of the followings. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef enum { + GESTURE_EVENT_NONE = 0, /**< Detected nothing */ + GESTURE_EVENT_DETECTED = 1, /**< Detected the gesture */ + + GESTURE_SHAKE_DETECTED = 1, /**< Shake gesture started */ + GESTURE_SHAKE_FINISHED = 2, /**< Shake gesture stopped */ + + GESTURE_SNAP_X_NEGATIVE = 1, /**< Detected -X snap */ + GESTURE_SNAP_X_POSITIVE = 2, /**< Detected +X snap */ + GESTURE_SNAP_Y_NEGATIVE = 3, /**< Detected -Y snap */ + GESTURE_SNAP_Y_POSITIVE = 4, /**< Detected +Y snap */ + GESTURE_SNAP_Z_NEGATIVE = 5, /**< Detected -Z snap */ + GESTURE_SNAP_Z_POSITIVE = 6, /**< Detected +Z snap */ +} gesture_event_e; + +/** + * @brief Called when a gesture is detected. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] gesture Gesture type detected + * @param[in] data Detailed information of the detected gesture.@n + * gesture_get_event() or gesture_get_tilt() + * can be used to extract the information from @c data. + * @param[in] timestamp The time when the gesture is detected. Epoch time in seconds. + * @param[in] error An error value. It can be one of the following error values:@n + * #GESTURE_ERROR_NONE, if the operation succeeded.@n + * #GESTURE_ERROR_NOT_SUPPORTED, if the gesture is not supported in the current profile.@n + * #GESTURE_ERROR_OPERATION_FAILED, if the operation failed because of a system error.@n + * #GESTURE_ERROR_PERMISSION_DENIED, if the application has no permission to use this. + * @param[in] user_data The user data had passed to gesture_start_recognition() + * + * @pre gesture_start_recognition() + */ +typedef void(* gesture_recognition_cb)(gesture_type_e gesture, const gesture_data_h data, double timestamp, gesture_error_e error, void *user_data); + +/** + * @brief Check whether the gesture is supported or not. + * @details Check if the given gesture type is supported in the current device. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] gesture Gesture type to be checked + * @param[out] supported @c true if the gesture is recognizable in the current device,@n + * @c false otherwise + * + * @return @c 0 if the @c gesture is supported, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Supported + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED The @c gesture is not supported + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + * @retval #GESTURE_ERROR_PERMISSION_DENIED Does not have permission to use this + */ +int gesture_is_supported(gesture_type_e gesture, bool* supported); + +/** + * @brief Initializes a gesture handle. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[out] handle Gesture handle to be initialized + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error, e.g., out of memory + * + * @see gesture_release() + */ +int gesture_create(gesture_h *handle); + +/** + * @brief Releases the resources occupied by the gesture handle. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] handle Gesture handle to be released + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + * + * @pre gesture_create() + */ +int gesture_release(gesture_h handle); + +/** + * @brief Starts to recognize a gesture. + * @details Sets a callback function to be invoked when the gesture is detected, + * and starts to monitor occurrences of the gesture. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] handle Gesture handle to be used to control the gesture event + * @param[in] gesture Gesture type to be monitored + * @param[in] option Detection option + * @param[in] callback Callback function to receive gesture events + * @param[in] user_data User data to be passed to the callback function + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_ALREADY_STARTED The @c handle is being used already + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + * @retval #GESTURE_ERROR_PERMISSION_DENIED Does not have permission to use this + * + * @pre gesture_create() + * @post gesture_recognition_cb() + * @see gesture_stop_recognition() + */ +int gesture_start_recognition(gesture_h handle, gesture_type_e gesture, gesture_option_e option, gesture_recognition_cb callback, void *user_data); + +/** + * @brief Stops recognizing the gesture registered to the gesture handle. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] handle Gesture handle to release its callback function registered + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_NOT_STARTED Nothing is started using the @c handle + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + */ +int gesture_stop_recognition(gesture_h handle); + +/** + * @brief Gets the gesture event from the gesture data received. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] data Gesture data received through a callback function + * @param[out] event Gesture event data + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + */ +int gesture_get_event(const gesture_data_h data, gesture_event_e *event); + +/** + * @brief Gets the tilting degrees from #GESTURE_TILT data received. + * + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + * + * @param[in] data Tilt gesture data received through a callback function + * @param[out] x Tilting degree on X-axis + * @param[out] y Tilting degree on Y-axis + * + * @return @c 0 on success, otherwise a negative error value + * @retval #GESTURE_ERROR_NONE Successful + * @retval #GESTURE_ERROR_INVALID_PARAMETER Invalid parameter used + * @retval #GESTURE_ERROR_NOT_SUPPORTED Gesture recognition is not supported + * @retval #GESTURE_ERROR_OPERATION_FAILED Operation failed because of a system error + */ +int gesture_get_tilt(const gesture_data_h data, int *x, int *y); + +#ifdef __cplusplus +} +#endif // __cplusplus + +/** +* @} +*/ + +#endif // __TIZEN_GESTURE_H__ diff --git a/packaging/capi-context-gesture.manifest b/packaging/capi-context-gesture.manifest new file mode 100644 index 0000000..97e8c31 --- /dev/null +++ b/packaging/capi-context-gesture.manifest @@ -0,0 +1,5 @@ + + + + + diff --git a/packaging/capi-context-gesture.spec b/packaging/capi-context-gesture.spec new file mode 100644 index 0000000..22a8b9c --- /dev/null +++ b/packaging/capi-context-gesture.spec @@ -0,0 +1,70 @@ +Name: capi-context-gesture +Summary: Tizen Native Gesture Recognition API +Version: 2.0.2 +Release: 1 +Group: Service/Context +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz + +BuildRequires: cmake +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(capi-system-info) +BuildRequires: pkgconfig(sensor) + +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + +# Backward compatibility +Provides: gesture +Provides: libcore-context-manager.so.1 + +%description +Tizen Native Gesture Recognition API + +%prep +%setup -q + +%build +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` + +export CXXFLAGS+=" -Wextra -Wcast-align -Wshadow -Wwrite-strings -Wswitch-default -Wno-unused-parameter" +export CXXFLAGS+=" -Wno-empty-body -fomit-frame-pointer -fno-optimize-sibling-calls" +export CXXFLAGS+=" -fno-strict-aliasing -fno-unroll-loops -fsigned-char -fstrict-overflow" +export CXXFLAGS+=" -Wnon-virtual-dtor" + +%cmake . -DMAJORVER=${MAJORVER} -DFULLVER=%{version} +make %{?_smp_mflags} + +%install +%make_install + +# For backward compatibility +ln -s %{name}.pc %{buildroot}/%{_libdir}/pkgconfig/gesture.pc +ln -s %{name}.pc %{buildroot}/%{_libdir}/pkgconfig/libcore-context-manager.pc +ln -s lib%{name}.so.%{version} %{buildroot}/%{_libdir}/libcore-context-manager.so.1 + +%post +/sbin/ldconfig + +%postun +/sbin/ldconfig + +%files +%manifest packaging/%{name}.manifest +%{_libdir}/*.so.* +%license LICENSE + +%package devel +Summary: Tizen Native Gesture Recognition API (Development) +Group: Framework/context +Requires: %{name} = %{version}-%{release} + +%description devel +Tizen Native Gesture Recognition API (Development) + +%files devel +%{_includedir}/*/*.h +%{_libdir}/*.so +%{_libdir}/pkgconfig/*.pc diff --git a/src/Gesture.cpp b/src/Gesture.cpp new file mode 100644 index 0000000..1b74537 --- /dev/null +++ b/src/Gesture.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2016 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 "GestureSensor.h" + +#define FEATURE_GESTURE "tizen.org/feature/sensor.gesture_recognition" + +#define GESTURE_FIRST GESTURE_DOUBLE_TAP +#define GESTURE_LAST GESTURE_WRIST_UP +#define IS_VALID_GESTURE(X) (GESTURE_FIRST <= (X) && (X) <= GESTURE_LAST) + +using namespace gesture; + +struct _gesture_handle_s { + GestureSensor *sensor; +}; + +EXPORT_API int gesture_is_supported(gesture_type_e gesture, bool* supported) +{ + if (supported) + *supported = false; + + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(supported); + IF_FAIL_RETURN(IS_VALID_GESTURE(gesture), ERR_INVALID_PARAMETER); + + *supported = GestureSensor::isSupported(gesture); + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_create(gesture_h *handle) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(handle); + + _gesture_handle_s *hdl = static_cast(malloc(sizeof(_gesture_handle_s))); + IF_FAIL_RETURN_TAG(hdl, ERR_OPERATION_FAILED, _E, "Memory allocation failed"); + + hdl->sensor = new(std::nothrow) GestureSensor(); + if (hdl->sensor == NULL) { + _E("Memory allocation failed"); + free(hdl); + return ERR_OPERATION_FAILED; + } + + *handle = hdl; + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_release(gesture_h handle) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(handle); + + delete handle->sensor; + free(handle); + + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_start_recognition(gesture_h handle, gesture_type_e gesture, gesture_option_e option, gesture_recognition_cb callback, void *user_data) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(handle); + ASSERT_NOT_NULL(callback); + IF_FAIL_RETURN(IS_VALID_GESTURE(gesture), ERR_INVALID_PARAMETER); + + if (option == GESTURE_OPTION_DEFAULT) { + handle->sensor->setPowerSave(true); + } else if (option == GESTURE_OPTION_ALWAYS_ON) { + handle->sensor->setPowerSave(false); + } else { + return ERR_INVALID_PARAMETER; + } + + if (!handle->sensor->setGesture(gesture)) { + return GESTURE_ERROR_NOT_SUPPORTED; + } + + handle->sensor->setCallback(callback); + handle->sensor->setUserData(user_data); + + if (!handle->sensor->start()) { + return ERR_OPERATION_FAILED; + } + + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_stop_recognition(gesture_h handle) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(handle); + + IF_FAIL_RETURN(handle->sensor->stop(), GESTURE_ERROR_NOT_STARTED); + + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_get_event(const gesture_data_h data, gesture_event_e *event) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(data); + ASSERT_NOT_NULL(event); + + if (data->gesture == GESTURE_TILT) + return GESTURE_ERROR_NOT_SUPPORTED; + + *event = static_cast(data->event); + + return ERR_NONE; + //LCOV_EXCL_STOP +} + +EXPORT_API int gesture_get_tilt(const gesture_data_h data, int *x, int *y) +{ + ASSERT_SUPPORTED(FEATURE_GESTURE); + //LCOV_EXCL_START + ASSERT_NOT_NULL(data); + ASSERT_NOT_NULL(x); + ASSERT_NOT_NULL(y); + + if (data->gesture != GESTURE_TILT) + return ERR_NOT_SUPPORTED; + + *x = data->tilt_x; + *y = data->tilt_y; + + return ERR_NONE; + //LCOV_EXCL_STOP +} diff --git a/src/GestureSensor.cpp b/src/GestureSensor.cpp new file mode 100644 index 0000000..b4f6617 --- /dev/null +++ b/src/GestureSensor.cpp @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2016 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 "GestureSensor.h" + +using namespace gesture; + +//LCOV_EXCL_START +GestureSensor::GestureSensor() : + __gestureType(static_cast(UNDEFINED)), + __callback(NULL), + __userData(NULL), + __sensorAdapter(this) +{ +} + +GestureSensor::~GestureSensor() +{ +} + +bool GestureSensor::setGesture(gesture_type_e type) +{ + sensor_type_t sensor = __toSensor(type); + IF_FAIL_RETURN(sensor != UNKNOWN_SENSOR, false); + + __gestureType = type; + __sensorAdapter.setSensor(sensor); + return true; +} + +void GestureSensor::setPowerSave(bool ps) +{ + __sensorAdapter.setPowerSave(ps); +} + +void GestureSensor::setCallback(gesture_recognition_cb cb) +{ + __callback = cb; +} + +void GestureSensor::setUserData(void* data) +{ + __userData = data; +} + +bool GestureSensor::start() +{ + return __sensorAdapter.start(); +} + +bool GestureSensor::stop() +{ + return __sensorAdapter.stop(); +} + +bool GestureSensor::isSupported(gesture_type_e type) +{ + sensor_type_t sensor = __toSensor(type); + IF_FAIL_RETURN(sensor != UNKNOWN_SENSOR, false); + + return SensorAdapter::isSupported(sensor); +} + +void GestureSensor::onEvent(double timestamp, float* values, int accuracy) +{ + _gesture_data_s data; + data.gesture = __gestureType; + + /* TODO: This is the default form. + For each sensor, this part needs to adapt accordingly */ + data.event = static_cast(values[0]); + + __callback(__gestureType, &data, timestamp, static_cast(ERR_NONE), __userData); +} + +sensor_type_t GestureSensor::__toSensor(gesture_type_e type) +{ + switch (type) { + case GESTURE_PICK_UP: + return GESTURE_MOVEMENT_SENSOR; + case GESTURE_WRIST_UP: + return GESTURE_WRIST_UP_SENSOR; + default: + return UNKNOWN_SENSOR; + } +} +//LCOV_EXCL_STOP diff --git a/src/GestureSensor.h b/src/GestureSensor.h new file mode 100644 index 0000000..0599538 --- /dev/null +++ b/src/GestureSensor.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016 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 __GESTURE_SENSOR_H__ +#define __GESTURE_SENSOR_H__ + +#include +#include "SensorAdapter.h" + +struct _gesture_data_s { + int gesture; + int event; + int tilt_x; + int tilt_y; +}; + +namespace gesture { + + class GestureSensor : public ISensorListener { + public: + GestureSensor(); + ~GestureSensor(); + + bool setGesture(gesture_type_e type); + void setPowerSave(bool ps); + void setCallback(gesture_recognition_cb cb); + void setUserData(void* data); + + bool start(); + bool stop(); + + static bool isSupported(gesture_type_e type); + + private: + void onEvent(double timestamp, float* values, int accuracy); + + static sensor_type_t __toSensor(gesture_type_e type); + + gesture_type_e __gestureType; + gesture_recognition_cb __callback; + void *__userData; + SensorAdapter __sensorAdapter; + }; + +} + +#endif /* __GESTURE_SENSOR_H__ */ diff --git a/src/ISensorListener.h b/src/ISensorListener.h new file mode 100644 index 0000000..eeee8a5 --- /dev/null +++ b/src/ISensorListener.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2016 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 __I_SENSOR_LISTENER_H__ +#define __I_SENSOR_LISTENER_H__ + +namespace gesture { + + class ISensorListener { + public: + virtual ~ISensorListener() {} + virtual void onEvent(double timestamp, float* values, int accuracy) = 0; + }; + +} + +#endif /* __I_SENSOR_LISTENER_H__ */ diff --git a/src/SensorAdapter.cpp b/src/SensorAdapter.cpp new file mode 100644 index 0000000..07aee57 --- /dev/null +++ b/src/SensorAdapter.cpp @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2016 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 "SensorAdapter.h" + +#define SENSOR_EVENT(X) (((int)(X) << 16) | 0x01) + +using namespace gesture; + +SensorAdapter::SensorAdapter(ISensorListener* listener) : + __sensorHandle(-1), + __sensorType(UNKNOWN_SENSOR), + __powerSave(true), + __listener(listener) +{ +} + +SensorAdapter::~SensorAdapter() +{ + stop(); +} + +//LCOV_EXCL_START +void SensorAdapter::setSensor(sensor_type_t type) +{ + __sensorType = type; +} + +void SensorAdapter::setPowerSave(bool ps) +{ + __powerSave = ps; + + if (__sensorHandle < 0) + return; + + sensord_set_attribute_int(__sensorHandle, SENSORD_ATTRIBUTE_PAUSE_POLICY, + __powerSave ? SENSORD_PAUSE_ALL : SENSORD_PAUSE_NONE); +} + +void SensorAdapter::setAttribute(int key, int value) +{ + IF_FAIL_VOID_TAG(__sensorHandle >= 0, _W, "Sensor not started"); + sensord_set_attribute_int(__sensorHandle, key, value); +} + +bool SensorAdapter::start() +{ + int err; + sensor_t sensor; + + err = sensord_get_default_sensor(__sensorType, &sensor); + IF_FAIL_RETURN_TAG(err == 0, false, _E, "Getting sensor failed (%d)", err); + + __sensorHandle = sensord_connect(sensor); + IF_FAIL_RETURN_TAG(__sensorHandle >= 0, false, _E, "Connection failed"); + + if (!sensord_register_event(__sensorHandle, SENSOR_EVENT(__sensorType), 0, 0, __eventCb, this)) { + _E("Event registration failed"); + sensord_disconnect(__sensorHandle); + __sensorHandle = -1; + return false; + } + + if (!sensord_start(__sensorHandle, __powerSave ? SENSOR_OPTION_DEFAULT : SENSOR_OPTION_ALWAYS_ON)) { + _E("Starting failed"); + sensord_unregister_event(__sensorHandle, SENSOR_EVENT(__sensorType)); + sensord_disconnect(__sensorHandle); + __sensorHandle = -1; + return false; + } + + return true; +} + +bool SensorAdapter::stop() +{ + IF_FAIL_RETURN(__sensorHandle >= 0, false); + + sensord_stop(__sensorHandle); + sensord_unregister_event(__sensorHandle, SENSOR_EVENT(__sensorType)); + sensord_disconnect(__sensorHandle); + __sensorHandle = -1; + + return true; +} + +bool SensorAdapter::isSupported(sensor_type_t type) +{ + sensor_t sensor = sensord_get_sensor(type); + return (sensor != NULL); +} + +double SensorAdapter::__getEpoch(unsigned long long monotonic) +{ + struct timespec ts; + struct timeval tv; + double timeDiff; + double timestamp; + + clock_gettime(CLOCK_MONOTONIC, &ts); + timeDiff = (ts.tv_sec * 1000000000.0 + ts.tv_nsec) / 1000000.0 - monotonic / 1000.0; + + gettimeofday(&tv, NULL); + timestamp = tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0 - timeDiff; + return timestamp; +} + +void SensorAdapter::__onEvent(sensor_data_t *eventData) +{ + double timestamp = __getEpoch(eventData->timestamp); + __listener->onEvent(timestamp / 1000.0, eventData->values, eventData->accuracy); +} + +void SensorAdapter::__eventCb(sensor_t sensor, unsigned int eventType, sensor_data_t *eventData, void *cbData) +{ + SensorAdapter *instance = static_cast(cbData); + instance->__onEvent(eventData); +} +//LCOV_EXCL_STOP diff --git a/src/SensorAdapter.h b/src/SensorAdapter.h new file mode 100644 index 0000000..7ce9fc4 --- /dev/null +++ b/src/SensorAdapter.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2016 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 __GESTURE_SENSOR_ADAPTER_H__ +#define __GESTURE_SENSOR_ADAPTER_H__ + +#include +#include "TypesInternal.h" +#include "ISensorListener.h" + +namespace gesture { + + class SensorAdapter { + public: + SensorAdapter(ISensorListener* listener); + ~SensorAdapter(); + + void setSensor(sensor_type_t type); + void setPowerSave(bool ps); + void setAttribute(int key, int value); + + bool start(); + bool stop(); + + static bool isSupported(sensor_type_t type); + + private: + double __getEpoch(unsigned long long monotonic); + void __onEvent(sensor_data_t* eventData); + + static void __eventCb(sensor_t sensor, unsigned int eventType, sensor_data_t *eventData, void *cbData); + + int __sensorHandle; + sensor_type_t __sensorType; + bool __powerSave; + ISensorListener *__listener; + }; + +} + +#endif /* __GESTURE_SENSOR_ADAPTER_H__ */ diff --git a/src/TypesInternal.cpp b/src/TypesInternal.cpp new file mode 100644 index 0000000..d4d9175 --- /dev/null +++ b/src/TypesInternal.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2016 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 "TypesInternal.h" + +int gesture::isSupported(const char *feature) +{ + bool supported = false; + int ret = system_info_get_platform_bool(feature, &supported); + + if (ret == ERR_NONE && !supported) { + _W("Not Supported: %s", feature); + return ERR_NOT_SUPPORTED; + } else if (ret != ERR_NONE) { + _E("Getting system info failed: %#x", ret); + return ERR_OPERATION_FAILED; + } + + return ERR_NONE; +} diff --git a/src/TypesInternal.h b/src/TypesInternal.h new file mode 100644 index 0000000..04cf1fb --- /dev/null +++ b/src/TypesInternal.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2016 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 _GESTURE_TYPES_INTERNAL_H_ +#define _GESTURE_TYPES_INTERNAL_H_ + +#include +#include +#include + +#define UNDEFINED -1 + +#define ERR_NONE TIZEN_ERROR_NONE +#define ERR_INVALID_PARAMETER TIZEN_ERROR_INVALID_PARAMETER +#define ERR_INVALID_OPERATION TIZEN_ERROR_INVALID_OPERATION +#define ERR_OUT_OF_MEMORY TIZEN_ERROR_OUT_OF_MEMORY +#define ERR_PERMISSION_DENIED TIZEN_ERROR_PERMISSION_DENIED +#define ERR_NOT_SUPPORTED TIZEN_ERROR_NOT_SUPPORTED +#define ERR_NO_DATA TIZEN_ERROR_NO_DATA +#define ERR_ALREADY_STARTED (TIZEN_ERROR_CONTEXT | 0x01) +#define ERR_NOT_STARTED (TIZEN_ERROR_CONTEXT | 0x02) +#define ERR_OUT_OF_RANGE (TIZEN_ERROR_CONTEXT | 0x03) +#define ERR_OPERATION_FAILED (TIZEN_ERROR_CONTEXT | 0x04) +#define ERR_RULE_ENABLED (TIZEN_ERROR_CONTEXT | 0x05) +#define ERR_RULE_NOT_ENABLED (TIZEN_ERROR_CONTEXT | 0x06) +#define ERR_INVALID_RULE (TIZEN_ERROR_CONTEXT | 0x07) +#define ERR_RULE_NOT_EXIST (TIZEN_ERROR_CONTEXT | 0x08) +#define ERR_INVALID_DATA ERR_INVALID_RULE +#define ERR_DATA_EXIST (TIZEN_ERROR_CONTEXT | 0X09) + +/* Logging and Error Handling */ +#define _I SLOGI +#define _D SLOGD +#define _W SLOGW +#define _E SLOGE +#define _SI SECURE_SLOGI +#define _SD SECURE_SLOGD +#define _SW SECURE_LOGW +#define _SE SECURE_SLOGE + +#define IF_FAIL_RETURN_TAG(cond, ret, tag, fmt, arg...) \ + do { if (!(cond)) { tag(fmt, ##arg); return ret; } } while (0) + +#define IF_FAIL_RETURN(cond, ret) \ + do { if (!(cond)) { return ret; } } while (0) + +#define IF_FAIL_VOID_TAG(cond, tag, fmt, arg...) \ + do { if (!(cond)) { tag(fmt, ##arg); return; } } while (0) + +#define IF_FAIL_VOID(cond) \ + do { if (!(cond)) { return; } } while (0) + +#define IF_FAIL_CATCH_TAG(cond, tag, fmt, arg...) \ + do { if (!(cond)) { tag(fmt, ##arg); goto CATCH; } } while (0) + +#define IF_FAIL_CATCH(cond) \ + do { if (!(cond)) { goto CATCH; } } while (0) + +#define IS_FAILED(X) ((X) != ERR_NONE) + +#define ASSERT_ALLOC(X) IF_FAIL_RETURN_TAG(X, ERR_OUT_OF_MEMORY, _E, "Memory allocation failed") +#define ASSERT_NOT_NULL(X) IF_FAIL_RETURN_TAG(X, ERR_INVALID_PARAMETER, _E, "Parameter null") + +#define ASSERT_SUPPORTED(feature) \ + do { \ + int __result = gesture::isSupported(feature); \ + if (__result != ERR_NONE) return __result; \ + } while (0) + +namespace gesture { + int isSupported(const char *feature); +} + +#endif /* _GESTURE_TYPES_INTERNAL_H_ */ -- 2.7.4