--- /dev/null
+Taesoo Jun <steve.jun@samsung.com>
+Jonghoon Han <jonghoon.han@samsung.com>
+JuHyun Kim <jh8212.kim@samsung.com>
+
--- /dev/null
+cmake_minimum_required(VERSION 2.6)
+project(sensor CXX)
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(EXEC_PREFIX "\${prefix}")
+SET(LIBDIR "\${prefix}/lib")
+SET(INCLUDEDIR "\${prefix}/include")
+SET(VERSION_MAJOR 1)
+SET(VERSION "${VERSION_MAJOR}.1.0")
+
+include(FindPkgConfig)
+pkg_check_modules(rpkgs REQUIRED sf_common vconf glib-2.0)
+add_definitions(${rpkgs_CFLAGS})
+
+#add_definitions(-Wall -O3 -omit-frame-pointer -lm)
+#add_definitions(-Wall -g -lma -DUSE_FILE_DEBUG)
+add_definitions(-Wall -g -lma -D_DEBUG)
+#add_definitions(-fvisibility=hidden -lm -DUSE_DLOG_LOG)
+#add_definitions(-fvisibility=hidden -lm)
+
+FIND_PROGRAM(UNAME NAMES uname)
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" STREQUAL "arm")
+# ADD_DEFINITIONS("-DTARGET -DHWREV_CHECK -DUSE_MPU3050_GYRO")
+ ADD_DEFINITIONS("-DTARGET -DHWREV_CHECK")
+ MESSAGE("add -DTARGET")
+ELSE("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DSIMULATOR")
+ MESSAGE("add -DSIMULATOR")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+add_library(${PROJECT_NAME} SHARED
+ src/client.cpp
+)
+
+#add_dependencies(${PROJECT_NAME} sf_common)
+# to install pkgconfig setup file.
+
+target_link_libraries(${PROJECT_NAME} ${rpkgs_LDFLAGS} ${GLES_LDFLAGS})
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${VERSION_MAJOR})
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VERSION ${VERSION})
+
+configure_file(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc @ONLY)
+
+#install(DIRECTORY include/ DESTINATION include/ FILES_MATCHING PATTERN "*.h")
+install(TARGETS ${PROJECT_NAME} DESTINATION lib COMPONENT RuntimeLibraries)
+
+install(FILES include/sensor.h DESTINATION include/sensor/)
+install(FILES include/sensor_accel.h DESTINATION include/sensor/)
+install(FILES include/sensor_geomag.h DESTINATION include/sensor/)
+install(FILES include/sensor_proxi.h DESTINATION include/sensor/)
+install(FILES include/sensor_motion.h DESTINATION include/sensor/)
+install(FILES include/sensor_light.h DESTINATION include/sensor/)
+install(FILES include/sensor_gyro.h DESTINATION include/sensor/)
+
+
+
+install(FILES ${PROJECT_NAME}.pc DESTINATION lib/pkgconfig)
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
--- /dev/null
+#!/bin/sh
+
+export TET_INSTALL_PATH=/home/kim/sbs-install/ # local tetware path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -c -p ./
+tcc -b -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+#!/bin/sh
+export TET_INSTALL_PATH=/mnt/nfs/tetware
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+
+export TET_ROOT=$TET_TARGET_PATH
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -e -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+# TET reserved codes
+0 "PASS"
+1 "FAIL"
+2 "UNRESOLVED"
+3 "NOTINUSE"
+4 "UNSUPPORTED"
+5 "UNTESTED"
+6 "UNINITIATED"
+7 "NORESULT"
+
+# Test suite additional codes
+33 "INSPECT"
--- /dev/null
+all
+ ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+ :include:/unit/tslist
--- /dev/null
+TET_OUTPUT_CAPTURE=False
+TET_BUILD_TOOL=make
+TET_PASS_TC_NAME=True
--- /dev/null
+TET_OUTPUT_CAPTURE=False
+TET_CLEAN_TOOL=make clean
--- /dev/null
+TET_OUTPUT_CAPTURE=False
--- /dev/null
+CC ?= gcc
+
+TARGETS = utc_SensorFW_sf_get_properties_func \
+ utc_SensorFW_sf_is_sensor_event_available_func \
+ utc_SensorFW_sf_connect_func \
+ utc_SensorFW_sf_disconnect_func \
+ utc_SensorFW_sf_start_func \
+ utc_SensorFW_sf_stop_func \
+ utc_SensorFW_sf_register_event_func \
+ utc_SensorFW_sf_unregister_event_func \
+ utc_SensorFW_sf_get_data_func \
+ utc_SensorFW_sf_check_rotation_func \
+ utc_SensorFW_sf_read_raw_data_func
+
+PKGS = sf_common sensor
+
+LDFLAGS = `pkg-config --libs $(PKGS)`
+LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
+
+CFLAGS = -I. `pkg-config --cflags $(PKGS)`
+CFLAGS += -I$(TET_ROOT)/inc/tet3
+CFLAGS += -Wall
+
+all: $(TARGETS)
+
+$(TARGETS): %: %.c
+ $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+clean:
+ rm -f $(TARGETS)
--- /dev/null
+#!/bin/sh
+
+TMPSTR=$0
+SCRIPT=${TMPSTR##*/}
+
+if [ $# -lt 2 ]; then
+ echo "Usage) $SCRIPT module_name api_name"
+ exit 1
+fi
+
+MODULE=$1
+API=$2
+TEMPLATE=utc_MODULE_API_func.c.in
+TESTCASE=utc_${MODULE}_${API}_func
+
+sed -e '
+ s^@API@^'"$API"'^g
+ s^@MODULE@^'"$MODULE"'^g
+ ' $TEMPLATE > $TESTCASE.c
+
+if [ ! -e "$TESTCASE.c" ]; then
+ echo "Failed"
+ exit 1
+fi
+echo "Testcase file is $TESTCASE.c"
+echo "Done"
+echo "please put \"$TESTCASE\" as Target in Makefile"
+echo "please put \"/unit/$TESTCASE\" in tslist"
--- /dev/null
+/unit/utc_SensorFW_sf_is_sensor_event_available_func
+/unit/utc_SensorFW_sf_get_properties_func
+/unit/utc_SensorFW_sf_connect_func
+/unit/utc_SensorFW_sf_disconnect_func
+/unit/utc_SensorFW_sf_start_func
+/unit/utc_SensorFW_sf_stop_func
+/unit/utc_SensorFW_sf_register_event_func
+/unit/utc_SensorFW_sf_unregister_event_func
+/unit/utc_SensorFW_sf_get_data_func
+/unit/utc_SensorFW_sf_check_rotation_func
+/unit/utc_SensorFW_sf_read_raw_data_func
--- /dev/null
+#include <tet_api.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_@MODULE@_@API@_func_01(void);
+static void utc_@MODULE@_@API@_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_@MODULE@_@API@_func_01, POSITIVE_TC_IDX },
+ { utc_@MODULE@_@API@_func_02, NEGATIVE_TC_IDX },
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of @API@()
+ */
+static void utc_@MODULE@_@API@_func_01(void)
+{
+ int r = 0;
+
+/*
+ r = @API@(...);
+*/
+ if (r) {
+ tet_infoline("@API@() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init @API@()
+ */
+static void utc_@MODULE@_@API@_func_02(void)
+{
+ int r = 0;
+
+/*
+ r = @API@(...);
+*/
+ if (r) {
+ tet_infoline("@API@() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+int handle = 0;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_check_rotation_func_01(void);
+static void utc_SensorFW_sf_check_rotation_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_check_rotation_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_check_rotation_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of sf_check_rotation()
+ */
+static void utc_SensorFW_sf_check_rotation_func_01(void)
+{
+ int r = 0;
+ unsigned long event;
+
+ r = sf_check_rotation(&event);
+
+ if (r < 0) {
+ tet_infoline("sf_check_rotation() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_check_rotation()
+ */
+static void utc_SensorFW_sf_check_rotation_func_02(void)
+{
+ int r = 0;
+
+ r = sf_check_rotation(NULL);
+
+ if (r > 0) {
+ tet_infoline("sf_check_rotation() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_connect_func_01(void);
+static void utc_SensorFW_sf_connect_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_connect_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_connect_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of sf_connect()
+ */
+static void utc_SensorFW_sf_connect_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_connect(ACCELEROMETER_SENSOR);
+
+ if (r < 0) {
+ tet_infoline("sf_connect() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_connect()
+ */
+static void utc_SensorFW_sf_connect_func_02(void)
+{
+ int r = 0;
+
+
+ r = sf_connect(100);
+
+ if (r > 0 ) {
+ tet_infoline("sf_connect() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+
+int handle;
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_disconnect_func_01(void);
+static void utc_SensorFW_sf_disconnect_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_disconnect_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_disconnect_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+}
+
+static void cleanup(void)
+{
+ sf_disconnect(handle);
+}
+
+
+/**
+ * @brief Positive test case of sf_disconnect()
+ */
+static void utc_SensorFW_sf_disconnect_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_disconnect(handle);
+
+ if (r != 0) {
+ tet_infoline("sf_disconnect() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_disconnect()
+ */
+static void utc_SensorFW_sf_disconnect_func_02(void)
+{
+ int r = 0;
+
+
+ r = sf_disconnect(100);
+
+ if (r == 0) {
+ tet_infoline("sf_disconnect() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+#include <stdlib.h>
+
+int handle = 0;
+sensor_data_t* values;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_get_data_func_01(void);
+static void utc_SensorFW_sf_get_data_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_get_data_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_get_data_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+ sf_start(handle,0);
+
+}
+
+static void cleanup(void)
+{
+ sf_stop(handle);
+ sf_disconnect(handle);
+}
+
+/**
+ * @brief Positive test case of sf_get_data()
+ */
+static void utc_SensorFW_sf_get_data_func_01(void)
+{
+ int r = 0;
+
+ values = (sensor_data_t*)malloc(sizeof(sensor_data_t));
+
+ r = sf_get_data(handle, ACCELEROMETER_BASE_DATA_SET, values);
+
+ if (r < 0) {
+ tet_infoline("sf_get_data() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_get_data()
+ */
+static void utc_SensorFW_sf_get_data_func_02(void)
+{
+ int r = 0;
+
+// values = (sensor_data_t*)malloc(sizeof(sensor_data_t));
+
+ r = sf_get_data(300, NULL, values);
+
+ printf("n r = %d\n", r);
+
+ if (r > 0) {
+ tet_infoline("sf_get_data() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+sensor_properties_t accel_property;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_get_properties_func_01(void);
+static void utc_SensorFW_sf_get_properties_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_get_properties_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_get_properties_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of sf_get_properties()
+ */
+static void utc_SensorFW_sf_get_properties_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_get_properties(ACCELEROMETER_SENSOR, &accel_property);
+
+ if (r < 0) {
+ tet_infoline("sf_get_properties() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_get_properties()
+ */
+static void utc_SensorFW_sf_get_properties_func_02(void)
+{
+ int r = 0;
+
+ r = sf_get_properties(ACCELEROMETER_SENSOR, NULL);
+
+ if (r > 0) {
+ tet_infoline("sf_get_properties() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_is_sensor_event_available_func_01(void);
+static void utc_SensorFW_sf_is_sensor_event_available_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_is_sensor_event_available_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_is_sensor_event_available_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of sf_is_sensor_event_available()
+ */
+static void utc_SensorFW_sf_is_sensor_event_available_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_is_sensor_event_available(ACCELEROMETER_SENSOR, 0);
+
+ if (r < 0) {
+ tet_infoline("sf_is_sensor_event_available() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_is_sensor_event_available()
+ */
+static void utc_SensorFW_sf_is_sensor_event_available_func_02(void)
+{
+ int r = 0;
+
+
+ r = sf_is_sensor_event_available(UNKNOWN_SENSOR, 0);
+
+ if (r > 0) {
+ tet_infoline("sf_is_sensor_event_available() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_read_raw_data_func_01(void);
+static void utc_SensorFW_sf_read_raw_data_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_read_raw_data_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_read_raw_data_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+}
+
+static void cleanup(void)
+{
+}
+
+/**
+ * @brief Positive test case of sf_read_raw_data()
+ */
+static void utc_SensorFW_sf_read_raw_data_func_01(void)
+{
+ int r = 0;
+
+ float values[3];
+ size_t values_size;
+
+ values_size = sizeof(values);
+
+ r = sf_read_raw_data(ACCELEROMETER_SENSOR , values, &values_size);
+
+ if (r < 0) {
+ tet_infoline("sf_read_raw_data() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_read_raw_data()
+ */
+static void utc_SensorFW_sf_read_raw_data_func_02(void)
+{
+ int r = 0;
+
+ float values[3];
+ size_t values_size;
+ values_size = sizeof(values);;
+
+ r = sf_read_raw_data(UNKNOWN_SENSOR , values, &values_size);
+
+ if (r > 0) {
+ tet_infoline("sf_read_raw_data() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+int handle = 0;
+
+void my_callback_func(unsigned int event_type, sensor_event_data_t *event , void *data)
+{
+}
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_register_event_func_01(void);
+static void utc_SensorFW_sf_register_event_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_register_event_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_register_event_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+
+}
+
+static void cleanup(void)
+{
+ sf_disconnect(handle);
+}
+
+/**
+ * @brief Positive test case of sf_register_event()
+ */
+static void utc_SensorFW_sf_register_event_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_register_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL, my_callback_func,NULL);
+
+ if (r < 0) {
+ tet_infoline("sf_register_event() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_register_event()
+ */
+static void utc_SensorFW_sf_register_event_func_02(void)
+{
+ int r = 0;
+
+ r = sf_register_event(400, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL, my_callback_func,NULL);
+
+ if (r > 0) {
+ tet_infoline("sf_register_event() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+int handle = 0;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_start_func_01(void);
+static void utc_SensorFW_sf_start_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_start_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_start_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+}
+
+static void cleanup(void)
+{
+ sf_disconnect(handle);
+}
+
+/**
+ * @brief Positive test case of sf_start()
+ */
+static void utc_SensorFW_sf_start_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_start(handle, 0);
+
+ if (r < 0) {
+ tet_infoline("sf_start() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_start()
+ */
+static void utc_SensorFW_sf_start_func_02(void)
+{
+ int r = 0;
+
+ r = sf_start(-1, 0);
+
+ if (r > 0) {
+ tet_infoline("sf_start() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+int handle = 0;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_stop_func_01(void);
+static void utc_SensorFW_sf_stop_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_stop_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_stop_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+ sf_start(handle, 0);
+}
+
+static void cleanup(void)
+{
+ sf_stop(handle);
+ sf_disconnect(handle);
+}
+
+/**
+ * @brief Positive test case of sf_stop()
+ */
+static void utc_SensorFW_sf_stop_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_stop(handle);
+
+ if (r < 0) {
+ tet_infoline("sf_stop() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_stop()
+ */
+static void utc_SensorFW_sf_stop_func_02(void)
+{
+ int r = 0;
+
+
+ r = sf_stop(-1);
+
+ if (r > 0) {
+ tet_infoline("sf_stop() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#include <tet_api.h>
+#include <sensor.h>
+
+int handle = 0;
+
+void my_callback_func(unsigned int event_type, sensor_event_data_t *event , void *data)
+{
+}
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_SensorFW_sf_unregister_event_func_01(void);
+static void utc_SensorFW_sf_unregister_event_func_02(void);
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+struct tet_testlist tet_testlist[] = {
+ { utc_SensorFW_sf_unregister_event_func_01, POSITIVE_TC_IDX },
+ { utc_SensorFW_sf_unregister_event_func_02, NEGATIVE_TC_IDX },
+ { NULL, 0},
+};
+
+static void startup(void)
+{
+ handle = sf_connect(ACCELEROMETER_SENSOR);
+ sf_register_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL, my_callback_func,NULL);
+
+}
+
+static void cleanup(void)
+{
+ sf_disconnect(handle);
+}
+/**
+ * @brief Positive test case of sf_unregister_event()
+ */
+static void utc_SensorFW_sf_unregister_event_func_01(void)
+{
+ int r = 0;
+
+
+ r = sf_unregister_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK);
+
+ if (r < 0) {
+ tet_infoline("sf_unregister_event() failed in positive test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
+
+/**
+ * @brief Negative test case of ug_init sf_unregister_event()
+ */
+static void utc_SensorFW_sf_unregister_event_func_02(void)
+{
+ int r = 0;
+
+ r = sf_unregister_event(handle, NULL);
+
+ if (r > 0) {
+ tet_infoline("sf_unregister_event() failed in negative test case");
+ tet_result(TET_FAIL);
+ return;
+ }
+ tet_result(TET_PASS);
+}
--- /dev/null
+#!/bin/bash +x
+#
+# Written by nicesj.park <nicesj.park@samsung.com>
+
+BASE="."
+CWD=`dirname $0`
+cd "$CWD"
+
+. ../../../../setup.conf || exit 1
+
+echo "Current working directory is \"$CWD\""
+if ! [ -d $BASE ]; then
+ echo "This is not proper package"
+ exit 1;
+fi
+
+cd $BASE
+
+. ${TPLDIR}/cmake.tpl
+run
--- /dev/null
+libslp-sensor (0.5.6-41) unstable; urgency=low
+
+ * version sync
+ * Git:165.213.180.114:pkgs/l/libslp-sensor
+ * Tag:libslp-sensor_0.5.6-41
+
+ -- JuHyun Kim <jh8212.kim@samsung.com> Thu, 15 Dec 2011 10:54:47 +0900
+
+libslp-sensor (0.0.1-1) unstable; urgency=low
+
+ * Initial Release.
+ * Git:165.213.180.114:pkgs/l/libslp-sensor
+ * Tag:libslp-sensor_0.0.0-1
+
+ -- JuHyun Kim <jh8212.kim@samsung.com> Wed, 07 Dec 2011 12:51:28 +0900
--- /dev/null
+Source: libslp-sensor
+Section: libs
+Priority: extra
+Maintainer: Jonghoon Han <jonghoon.han@samsung.com>, Juhyun Kim <jh8212.kim@samsung.com>, Taesoo Jun <steve.jun@samsung.com>
+Build-Depends: debhelper (>= 5), autotools-dev, libsf-common-dev, libslp-setting-dev, libglib2.0-dev
+Standards-Version: 0.1.0
+Homepage: N/A
+
+Package: libslp-sensor-dev
+XB-Public-Package: yes
+Architecture: any
+Depends: libslp-sensor-0 (= ${Source-Version})
+Description: Sensor framework client library
+ Sensor framework client library.
+
+Package: libslp-sensor-0
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, libsf-common-0
+Description: Sensor framework client library
+ Sensor framework client library.
+
+Package: libslp-sensor-dbg
+Section: debug
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, libslp-sensor-0(= ${Source-Version})
+Description:Sensor framework client library(unstripped)
+ Easy Sensor framework client library for SLP(not recommended)
--- /dev/null
+Source: <yoursource>
+Section: unknown
+Priority: extra
+Maintainer: unknown <unknown@samsung.com>
+Build-Depends: debhelper (>= 5), autotools-dev
+Standards-Version: 0.1.0
+
+Package: <yourpkg>-dev
+Section: libs
+Architecture: any
+Depends: <yourpkg> (= ${Source-Version})
+Description: <Fill description>
+
+Package: <yourpkg>
+Section: libs
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: <Fill description>
--- /dev/null
+usr/bin
+usr/sbin
--- /dev/null
+CMakeLists.txt
--- /dev/null
+@PREFIX@/lib/*.so*
--- /dev/null
+#!/bin/sh
+#if [ ${USER} == "root" ];then
+ # change file owner
+ # 1.libraries
+ #chown root:root /usr/lib/libsensor.so
+#fi
+# change file permissions
+# 1.libraries
+#chmod 644 /usr/lib/libsensor.so
+
--- /dev/null
+@PREFIX@/include/sensor/sensor.h
+@PREFIX@/include/sensor/sensor_accel.h
+@PREFIX@/include/sensor/sensor_geomag.h
+@PREFIX@/include/sensor/sensor_proxi.h
+@PREFIX@/include/sensor/sensor_motion.h
+@PREFIX@/include/sensor/sensor_light.h
+@PREFIX@/include/sensor/sensor_gyro.h
+@PREFIX@/lib/pkgconfig/*.pc
+
+
--- /dev/null
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+CFLAGS ?= -Wall -g
+CXXFLAGS ?= -Wall -g
+LDFLAGS ?=
+PREFIX ?= /usr
+DATADIR ?= /opt
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+ CFLAGS += -O0
+ CXXFLAGS += -O0
+else
+ CFLAGS += -O2
+ CXXFLAGS += -O2
+endif
+
+LDFLAGS += -Wl,--rpath=$(PREFIX)/lib -Wl,--as-needed
+
+configure: configure-stamp
+configure-stamp:
+ dh_testdir
+ # Add here commands to configure the package.
+ CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" LDFLAGS="$(LDFLAGS)" cmake . -DCMAKE_INSTALL_PREFIX=$(PREFIX)
+
+ touch configure-stamp
+
+build: build-stamp
+
+build-stamp: configure-stamp
+ dh_testdir
+ dh_buildinfo generate cat
+
+ # Add here commands to compile the package.
+ $(MAKE)
+ #docbook-to-man debian/wavplayer.sgml > wavplayer.1
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ cat $$f > $${f%.in}; \
+ sed -i -e "s#@PREFIX@#$(PREFIX)#g" $${f%.in}; \
+ sed -i -e "s#@DATADIR@#$(DATADIR)#g" $${f%.in}; \
+ done
+
+
+ touch $@
+
+clean:
+ dh_testdir
+ dh_testroot
+ rm -f build-stamp configure-stamp
+
+ # Add here commands to clean up after the build process.
+ -$(MAKE) clean
+ rm -rf CMakeCache.txt
+ rm -rf CMakeFiles
+ rm -rf cmake_install.cmake
+ rm -rf Makefile
+ rm -rf install_manifest.txt
+ rm -rf *.so
+ rm -rf *.pc
+ rm -rf $(CURDIR)/debian/buildinfo
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ rm -f $${f%.in}; \
+ done
+
+ dh_clean
+
+install: build
+ dh_testdir
+ dh_testroot
+ dh_clean -k
+ dh_installdirs
+
+ # Add here commands to install the package into debian/wavplayer.
+ $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
+
+
+# Build architecture-independent files here.
+binary-indep: build install
+# We have nothing to do by default.
+
+# Build architecture-dependent files here.
+binary-arch: build install
+ dh_testdir
+ dh_testroot
+ dh_installchangelogs
+ dh_installdocs
+ dh_buildinfo install
+ dh_installexamples
+ dh_install --sourcedir=debian/tmp
+# dh_installmenu
+# dh_installdebconf
+# dh_installlogrotate
+# dh_installemacsen
+# dh_installpam
+# dh_installmime
+# dh_python
+# dh_installinit
+# dh_installcron
+# dh_installinfo
+ dh_installman
+ dh_link
+ dh_strip --dbg-package=libslp-sensor-dbg
+ dh_compress
+ dh_fixperms
+# dh_perl
+ dh_makeshlibs -plibslp-sensor-0
+ dh_installdeb
+ dh_shlibdeps
+ dh_gencontrol
+ dh_md5sums
+ dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install configure
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 SLP_PG
+ * @defgroup SENSOR_FRAMEWORK_PG SensorFW
+@{
+
+
+<h1 class="pg">Introduction</h1>
+<h2 class="pg">Purpose</h2>
+
+The purpose of this document is to describe how applications can use the Sensor Framework APIs to perform different operations on different supported sensors through the sensor-server. This document gives programming guidelines to application engineers.
+
+
+
+<h2 class="pg">Scope</h2>
+
+The scope of this document is limited to Sensor framework library API usage.
+
+<h2 class="pg">Abbreviations</h2>
+
+<table>
+ <tr>
+ <td>
+ API
+ </td>
+ <td>
+ Application Programming Interface
+ </td>
+ </tr>
+ <tr>
+ <td>
+ TCP
+ </td>
+ <td>
+ Transmission Control Protocol
+ </td>
+ </tr>
+</table>
+
+<h1 class="pg">Sensor Framework Overview</h1>
+
+<h2 class="pg">What is sensor framework</h2>
+
+Sensor devices are used widely in mobile devices to enhance user experience. Most modern mobile OS have a framework which manages sensor hardware on the platform and provides convenient APIs for applications.
+
+<b>Sensors Framework</b> is a middleware, which provides a sensor server for creating plug-ins and a medium through which the client applications are connected with the sensor hardware to exchange sensor data. The sensor plug-ins retrieve data from sensor hardware and enable the client applications to use the data for specific requirements.
+
+The following sensor types are supported by the sensor framework provided that the device supports them:
+
+
+<b>Accelerometer</b> sensor<br>
+<b>Geomagnetic</b> sensor<br>
+<b>Proximity</b> sensor<br>
+<b>Light</b> sensor<br>
+<b>Gyroscope</b> sensor<br>
+
+@}
+@defgroup SENSOR_Architecture 1.Architecture
+@ingroup SENSOR_FRAMEWORK_PG
+@{
+
+<h2 class="pg">Sensor Framework Architecture</h2>
+
+Sensor framework is basically a client-server architecture. It is mainly composed of two parts:
+- <b>Sensor Server</b>: Sensor server is a daemon, which uniquely talks to sensor drivers in the system and dispatches sensor data to applications. Sensor server takes care of interacting with sensor driver in hardware initialization, driver configuration and data fetching, to manage all sensors on platform.
+
+- <b>Sensor API Library</b> (also called as <b>client</b> library): Applications wanting to access sensor services should communicate with the daemon through the sensor API library. An API library allows application to access sensor service. As shown in the diagram applications/middleware frameworks can have the sensor-framework client library in their process context.
+
+Unix Socket is used as IPC for communication between API library and daemon, including data transportation and command exchange.
+
+
+The client library provides different functionality to the application like attaching an application to a sensor, getting data from it, getting updates if a value is changed etc. It contains API's designed to fulfill these features.
+
+@image html SLP_SensorFW_PG_image1.png
+@}
+@defgroup SENSOR_Feature 2.Feature
+@ingroup SENSOR_FRAMEWORK_PG
+@{
+
+<h2 class="pg">Sensor Framework Features</h2>
+<b>Sensor framework client features</b>
+-# Available in shared library form.
+-# Provides set of APIs for accessing data from sensors.
+-# Provide unique access control mechanism through client server architecture.
+-# Provision to get processed/raw data from sensors.
+-# Provides functionality for application to register its own callback for the case of a sensor value change.
+-# Provides information about a sensor like maximum/minimum polling time.
+-# Direct knowledge of rotation status with raw data access.
+
+<b>Sensor framework server features</b>
+-# The actual implementation of the features supported by sensor-framework library is done in the sensor-server.
+-# Sensor-server checks the devices periodically and if there is an event that meets any conditions that are being monitored, the event is reported to applications which have registered for it.
+-# Sensor framework maintains a separate thread for every connection request which is called a "ipc worker".
+-# IPC Workers extract the work to be done in the form of command packets.
+-# These command packets are maintained in a command queue in server.
+-# This queue is further fed to a command executer which extracts the command from the packets.
+-# As per the command, the server allocates a plug-in worker which interacts with the device-driver interfaces.
+-# Server has predefined information about the sensor.
+
+@}
+<h1 class="pg">Sensor Framework Functions</h1>
+
+@defgroup Use_Cases1 Getting Information about available sensors
+@ingroup SENSOR_UC Use Cases
+@{
+
+<h2 class="pg">Getting Information about available sensors</h2>
+
+<b>API : sf_is_sensor_event_available</b><br>
+<b>Parameter In</b> : sensor_type_t desired_sensor_type , unsigned int desired_event_type<br>
+<b>Parameter Return</b> : int <br>
+<b>Functionality</b> : This API checks the availability of the sensor type and event type specified by the input parameters. Some of the supported sensor types are ACCELEROMETER_SENSOR_TYPE, GEOMAGNETIC_SENSOR_TYPE etc. This API will return 0 when the event is available and negative value when it is not available.<br>
+
+
+<b>API : sf_get_properties</b><br>
+<b>Parameter In</b> : sensor_type_t sensor_type <br>
+<b>Parameter Out</b> : sensor_properties_t *sensor_properties<br>
+<b>Parameter Return</b> : int <br>
+<b>Functionality</b> This API retrieves the properties of a sensor type, such as unit of sensor data, max/min range of sensor data and sensor resolution to the output parameter sensor_properties.<br>
+
+
+
+
+Sample Code (Showing how to get basic information about available sensors)
+
+@code
+#include <stdio.h>
+#include <sensor.h>
+#include <malloc.h>
+int main()
+{
+ printf("\n Sensor test : Start of the program \n");
+ int ret_val=0;
+ sensor_properties_t *sensor_properties;
+ sensor_type_t sensor_type = ACCELEROMETER_SENSOR;
+ int event_type = ACCELEROMETER_EVENT_ROTATION_CHECK;
+
+ //Check whether the sensor type and the event is available
+
+ ret_val = sf_is_sensor_event_available (sensor_type,event_type);
+ printf("\n Sensor Error : Return value is %d \n",ret_val);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor test : sensor %d is not present\n ",
+ sensor_type);
+ return -1;
+ }
+ printf("\n Sensor test : Sensor type is available and valid \n");
+
+ //Get the sensor properties
+ sensor_properties = (sensor_properties_t *)malloc(sizeof(sensor_properties_t));
+
+ ret_val = sf_get_properties (sensor_type, sensor_properties);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sensor_property get FAILED with code %d",ret_val);
+ return -1;
+ }
+ printf("\nSensor test : sensor_properties are \n unit ID : %d \n max range : %f \n
+ min range : %f \n sensor_resolution : %f \n ",
+ sensor_properties->sensor_unit_idx, sensor_properties->sensor_min_range,
+ sensor_properties->sensor_max_range, sensor_properties->sensor_resolution);
+
+ if(sensor_properties)
+ free(sensor_properties);
+
+ return 0;
+@endcode
+
+
+@}
+@defgroup Use_Cases2 Connecting and disconnecting a sensor
+@ingroup SENSOR_UC Use Cases
+@{
+
+
+<h2 class="pg">Connecting and disconnecting a sensor</h2>
+
+<b>Accelerometer sensor:</b><br>
+The accelerometer sensor is used to measure the acceleration of the device. The three dimensional coordinate system is used to illustrate direction of the acceleration as shown in figure 2 below. The X- and Y- axis defines a plane where Z-axis direction is perpendicular to the XY plane. When a phone is moving along an axis, the acceleration is positive if movement is towards positive direction and negative if movement is on negative direction. E.g. when a phone is moving along x-axis to the direction of -x, the acceleration is negative.
+
+<b>Geomagnetic sensor:</b><br>
+Geomagnetic sensor indicates the strength of the geomagnetic flux density in the X, Y and Z axes. This sensor is used to finds the orientation or attitude of a body is a description of how it is aligned to the space it is in.
+
+<b>Proximity sensor:</b><br>
+A proximity sensor is a sensor able to detect the presence of nearby objects without any physical contact. i.e. It indicates if the device is close or not close to the user.
+A proximity sensor often emits an electromagnetic or electrostatic field, or a beam of electromagnetic radiation (infrared, for instance), and looks for changes in the field or return signal. The object being sensed is often referred to as the proximity sensor's target
+
+<b>Light sensor</b><br>
+Light sensor measures the amount of light that it receives or the surrounding light conditions. The ambient light state is measured as a step value, where 0 is very dark and 10 is bright sunlight. A number of predefined brightness level constants are specified in the data class reference.
+
+<b>Gyroscope sensor:</b><br>
+A gyroscope is a device used primarily for navigation and measurement of angular velocity. Gyroscopes, also called angular rate sensors, measure how quickly an object rotates. This rate of rotation can be measured along any of the three axes X, Y and Z. 3-axis gyroscopes are often implemented with a 3-axis accelerometer to provide a full 6 degree-of-freedom (DoF) motion tracking system.
+
+@image html SLP_SensorFW_PG_image2.png
+
+<b>API : sf_connect</b><br>
+<b>Parameter In</b>: sensor_type_t sensor_type<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API connects a sensor type to respective sensor. The application calls this API with the type of the sensor (e.g. ACCELEROMETER_SENSOR) on the basis that the server takes the decision of which plug-in is to be connected. Once the sensor is connected, the application can proceed with data processing.
+This API returns a positive handle which should be used by application to communicate on sensor type.
+<br>
+<b>API : sf_disconnect</b><br>
+<b>Parameter In</b>: int handle<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API disconnects an attached sensor from an application. Application must use the handle retuned after attaching the sensor. After detaching, the corresponding handle will be released.<br>
+
+@}
+@defgroup Use_Cases3 Processing data after connecting to a sensor
+@ingroup SENSOR_UC Use Cases
+@{
+
+<h2 class="pg">Processing data after connecting to a sensor</h2>
+Once the application is connected to a sensor, data processing can be done using these API's
+
+<b>API : sf_start</b><br>
+<b>Parameter In</b>: Int handle, int option <br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API sends a start command to the sensor server. This informs the server that the client side is ready to handle data and start processing. The option input parameter should be set to '0' for current usage.<br>
+
+
+<b>API : sf_get_data</b><br>
+<b>Parameter In</b>: int handle, int data_id<br>
+<b>Parameter Out</b>:sensor_data_t* values<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API gets the processed data (sensor information) from a sensor through the sensor server. The data is loaded in the values output parameter.<br>
+
+
+<b>API : sf_stop</b><br>
+<b>Parameter In</b>: int handle<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API sends a stop command to the Sensor server indicating that the data processing has stopped from the application side for this time.<br>
+
+@}
+@defgroup Use_Cases4 Processing data without connecting to a sensor
+@ingroup SENSOR_UC Use Cases
+@{
+
+<h2 class="pg">Processing data without connecting to a sensor</h2>
+
+<b>API : sf_read_raw_data</b><br>
+<b>Parameter In</b>: sensor_type_t sensor_type<br>
+<b>Parameter Out</b>: float values[] , size_t *values_size<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API gets raw data from a sensor without connecting to the sensor-server. This doesn't need a connection handle. The type of sensor is supplied and return data is stored in the output parameter values [].<br>
+
+
+
+<b>API : sf_check_rotation</b><br>
+<b>Parameter Out</b>: unsigned long *state<br>
+<b>Parameter Return</b>: int <br>
+<b>Functionality</b>: This API used to get the current rotation state. (i.e. ROTATION_EVENT_0, ROTATION_EVENT_90, ROTATION_EVENT_180 & ROTATION_EVENT_270 ). This API will directly access the sensor without connecting the process with the sensor-server. Result will be stored in the output parameter state.<br>
+
+
+
+
+Sample Code (Showing how to connect to server and get data (processed/raw))
+
+@code
+#include <stdio.h>
+#include <sensor.h>
+#include <malloc.h>
+
+int main()
+{
+ printf("\n Sensor test : Start of the program \n");
+
+ int ret_val=0;
+ int my_handle = 0;
+ int get_data_id =ACCELEROMETER_BASE_DATA_SET;
+
+ float raw_data[3];
+ size_t size = 3;
+
+ unsigned long rotaion_state = 0;
+ sensor_data_t *sensor_data = (sensor_data_t*)malloc(sizeof(sensor_data_t));
+ sensor_properties_t *sensor_properties = NULL;
+
+ sensor_type_t sensor_type = ACCELEROMETER_SENSOR;
+ int event_type = ACCELEROMETER_EVENT_ROTATION_CHECK;
+
+ //Check whether the Accelerometer sensor type and the event is available
+ ret_val = sf_is_sensor_event_available (sensor_type,event_type);
+
+ printf("\n Sensor Error : Return value is %d \n",ret_val);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor test : sensor %d is not present\n ", sensor_type);
+ return -1;
+ }
+ printf("\n Sensor test : Sensor type is available and valid \n");
+
+ //Get the sensor properties
+ sensor_properties = (sensor_properties_t *)malloc(sizeof(sensor_properties_t));
+
+ ret_val = sf_get_properties (sensor_type, sensor_properties);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sf_get_property get FAILED with code %d",ret_val);
+ return -1;
+ }
+ printf("\nSensor test : sensor_properties are \n unit ID : %d \n max range : %f \n
+ min range : %f \n sensor_resolution : %f \n ",
+ sensor_properties->sensor_unit_idx, sensor_properties->sensor_min_range,
+ sensor_properties->sensor_max_range, sensor_properties->sensor_resolution);
+
+
+ //Connect to the sensor through server .
+ my_handle = sf_connect(sensor_type);
+ if(my_handle < 0)
+ {
+ printf("\n Sensor Error : sf_connect FAILED with code %d",my_handle);
+ return -1;
+ }
+
+ printf("\n Sensor test : sf_connect : handle is %d",my_handle);
+
+
+ //Start the communication
+ ret_val = sf_start(my_handle,0);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sensor_start FAILED with code %d",ret_val);
+ return -1;
+ }
+
+
+ //Get the processed data from server
+ ret_val = sf_get_data(my_handle,get_data_id,sensor_data);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sensor_get_data FAILED with code %d",ret_val);
+ return -1;
+ }
+ printf("\n Sensor Test: Gathered Data : \n X : %f \n Y : %f \n Z : %f \n Accuracy : %d \n
+ Unit ID : %d \n Time Stamp : %lld", sensor_data->values[0], sensor_data->values[1],
+ sensor_data->values[2], sensor_data->data_accuracy, sensor_data->data_unit_idx,
+ sensor_data->time_stamp);
+
+
+ //Get the Raw Data(Bypass server)
+ ret_val = sf_read_raw_data(sensor_type,(float *)raw_data, &size);
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sensor_get_data FAILED with code %d",ret_val);
+ return -1;
+ }
+
+ printf("\n Seneor test : My raw data is x= %f y= %f and z= %f \n",
+ raw_data[0], raw_data[1], raw_data[2]);
+
+
+ //Get the rotation/orientation
+ ret_val = sf_check_rotation(&rotaion_state);
+
+ if(ret_val != 0)
+ {
+ printf("\n Sensor Error : sf_check_rotation FAILED with code %d",ret_val);
+ return -1;
+ }
+
+ switch(rotaion_state)
+ {
+ case ROTATION_EVENT_0 :
+ printf("\n Sensor test : Rotation ROTATION_EVENT_0 \n");
+ break;
+ case ROTATION_EVENT_90:
+ printf("\n Sensor test : Rotation is ROTATION_EVENT_90 \n");
+ break;
+ case ROTATION_EVENT_180 :
+ printf("\n Sensor test : Rotation is ROTATION_EVENT_180 \n");
+ break;
+ case ROTATION_EVENT_270 :
+ printf("\n Sensor test : Rotation ROTATION_EVENT_270 \n");
+ break;
+ default :
+ printf("\n Sensor test : Rotation is ROTATION_UNKNOWN \n");
+
+ }
+
+ if(sensor_properties)
+ free(sensor_properties);
+
+ if(sensor_data)
+ free(sensor_data);
+
+ return 0;
+}
+@endcode
+
+
+@}
+@defgroup Use_Cases5 Subscribing and unsubscribing a Callback function for sensor events
+@ingroup SENSOR_UC Use Cases
+@{
+
+<h2 class="pg">Subscribing and unsubscribing a Callback function for sensor events</h2>
+
+<b>API : sf_register_event</b><br>
+<b>Parameter In</b> : int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data<br>
+<b>Parameter Return</b> : int <br>
+<b>Functionality</b> : This API registers a user defined callback function with a connected sensor for a particular event. This callback function will be called when there is a change in the state of respective sensor. cb_data will be the parameter used during the callback call. Callback interval can be adjusted using the event_condition_t argument.<br>
+
+
+
+<b>API : sf_unregister_event</b><br>
+<b>Parameter In</b> : int handle, unsigned int event_type<br>
+<b>Parameter Return</b> : int <br>
+<b>Functionality</b> : This API de-registers a user defined callback function with a sensor registered with the specified handle. After unsubscribing, no event will be sent to the application.<br>
+
+
+Sample code (This is an example showing how rotation event can be handled easily just by using these sensor framework API's)
+
+
+
+@code
+#include <stdio.h>
+#include <glib.h>
+#include <sensor.h>
+
+static GMainLoop *mainloop;
+
+void my_callback_func(unsigned int event_type, sensor_event_data_t *event, void *data)
+{
+ int *my_event_data;
+
+ if (event_type != ACCELEROMETER_EVENT_ROTATION_CHECK) {
+ printf("my_callback_func received data fail\n");
+ return;
+ }
+ my_event_data = (int *)(event);
+
+ switch( *my_event_data ) {
+ case ROTATION_EVENT_0:
+ printf("my_callback_func received data ROTATION_EVENT_0\n");
+ break;
+ case ROTATION_EVENT_90:
+ printf("my_callback_func received data ROTATION_EVENT_90\n");
+ break;
+ case ROTATION_EVENT_180:
+ printf("my_callback_func received data ROTATION_EVENT_180\n");
+ break;
+ case ROTATION_EVENT_270:
+ printf("my_callback_func received data ROTATION_EVENT_270\n");
+ break;
+
+ default:
+ printf("my_callback_func received data unexpected\n");
+ break;
+ }
+
+}
+
+static void sig_quit(int signo)
+{
+ if (mainloop)
+ {
+ g_main_loop_quit(mainloop);
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ int handle;
+ int state;
+
+ signal(SIGINT, sig_quit);
+ signal(SIGTERM, sig_quit);
+ signal(SIGQUIT, sig_quit);
+
+ mainloop = g_main_loop_new(NULL, FALSE);
+
+ handle = sf_connect( ACCELEROMETER_SENSOR );
+ if (handle<0) {
+ printf("sensor attach fail\n");
+ return -1;
+
+ }
+
+
+ state = sf_register_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL , my_callback_func,NULL);
+ if (state<0) {
+ printf("sensor_register_cb fail\n");
+
+ }
+
+ printf("Start SF\n");
+ state = sf_start(handle, 0);
+ if (state<0) {
+ printf("SLP_sensor_start fail\n");
+
+ }
+ printf("Start SF done\n");
+
+ g_main_loop_run(mainloop);
+ g_main_loop_unref(mainloop);
+
+ state = sf_unregister_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK );
+ if (handle<0) {
+ printf("t sensor_unregister_cb fail\n");
+ }
+ sf_stop(handle);
+ sf_disconnect(handle);
+ return 0;
+}
+@endcode
+
+
+
+@}
+@defgroup Reference
+@ingroup SENSOR_FRAMEWORK_PG
+@{
+
+<sub class="ref">Also see</sub> [ @ref SENSOR_FRAMEWORK API reference]
+
+<h1 class="pg">Appendixes</h1>
+
+<h2 class="pg">API Overview</h2>
+
+
+
+<table>
+ <tr>
+ <th>S No</th>
+ <th>API NAME</th>
+ <th>In parameter</th>
+ <th>Functionality</th>
+ </tr>
+ <tr>
+ <td>1</td>
+ <td>sf_is_sensor_event_available</td>
+ <td>sensor_type_t desired_sensor_type , unsigned int desired_event_type</td>
+ <td>This checks the availability of the sensor type and event type specified by the input parameters.</td>
+ </tr>
+ <tr>
+ <td>2</td>
+ <td>sf_get_properties</td>
+ <td>sensor_type_t sensor_type, sensor_properties_t *return_properties</td>
+ <td>This API retrieves the properties of a sensor type like data unit ID, max range, min range and resolution</td>
+ </tr>
+ <tr>
+ <td>3</td>
+ <td>sf_connect</td>
+ <td>sensor_type_t sensor_type</td>
+ <td>This API attaches/connects to a supplied type of sensor and returns an handle</td>
+ </tr>
+ <tr>
+ <td>4</td>
+ <td>sf_disconnect</td>
+ <td>sensor_type_t sensor_type</td>
+ <td>This API detaches/disconnects the handle from the sensor</td>
+ </tr>
+ <tr>
+ <td>5</td>
+ <td>sf_start</td>
+ <td>Int handle</td>
+ <td>This API sends start command to the sensor</td>
+ </tr>
+ <tr>
+ <td>6</td>
+ <td>sf_stop</td>
+ <td>Int handle</td>
+ <td>This API sends stop command to the sensor</td>
+ </tr>
+ <tr>
+ <td>7</td>
+ <td>sf_register_event</td>
+ <td>int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data</td>
+ <td>This API registers a user callback function with sensor . Whenever there is a change in the sensor state on a predefined event, this callback will be called</td>
+ </tr>
+ <tr>
+ <td>8</td>
+ <td>sf_unregister_event</td>
+ <td>int handle, unsigned int event_type</td>
+ <td>This API de-registers the user callback function for the change in stage of a predefined event</td>
+ </tr>
+ <tr>
+ <td>9</td>
+ <td>sf_get_data</td>
+ <td>int handle , unsigned int data_id , sensor_data_t* values</td>
+ <td>This API gets tje data (processed)from a sensor through the sensor server</td>
+ </tr>
+ <tr>
+ <td>10</td>
+ <td>sf_check_rotation</td>
+ <td>unsigned long *curr_state</td>
+ <td>This API gets the current rotation value such as ROTATION_LANDSCAPE_LEFT , ROTATION_PORTRAIT_TOP etc</td>
+ </tr>
+ <tr>
+ <td>11</td>
+ <td>sf_read_raw_data</td>
+ <td>sensor_type_t sensor_type , float values[] , size_t *values_size</td>
+ <td>This API reads raw data without connecting the process with the sensor</td>
+ </tr>
+</table>
+
+
+
+<h2 class="pg">Data structures</h2>
+Few reference sample codes are attached for application developer to well understand the System Framework Module.
+
+<b>Sensor Type:</b>
+@code
+typedef enum {
+ UNKNOWN_SENSOR = 0x0000,
+ ACCELEROMETER_SENSOR = 0x0001,
+ GEOMAGNETIC_SENSOR = 0x0002,
+ LIGHT_SENSOR = 0x0004,
+ PROXIMITY_SENSOR = 0x0008,
+ THERMOMETER_SENSOR = 0x0010,
+ GYROSCOPE_SENSOR = 0x0020,
+ PRESSURE_SENSOR = 0x0040
+} sensor_type_t;
+@endcode
+
+<b>Event Condition:</b>
+@code
+typedef enum {
+ CONDITION_NO_OP,
+ CONDITION_EQUAL,
+ CONDITION_GREAT_THAN,
+ CONDITION_LESS_THAN,
+} condition_op_t;
+
+typedef struct {
+ condition_op_t cond_op;
+ float cond_value1;
+} event_conditon_t;
+@endcode
+
+<b>Sensor Event Data:</b>
+@code
+typedef struct {
+ size_t event_data_size;
+ void *event_data;
+} sensor_event_data_t;
+@endcode
+
+
+<b>Call back function:</b>
+@code
+typedef void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *);
+
+<b>Sensor Data:</b>
+@code
+typedef struct {
+ int data_accuracy;
+ int data_unit_idx;
+ unsigned long long time_stamp;
+ int values_num;
+ float values[12];
+} sensor_data_t;
+@endcode
+
+
+<b>Sensor Properties:</b>
+@code
+typedef struct {
+ int sensor_unit_idx;
+ float sensor_min_range;
+ float sensor_max_range;
+ float sensor_resolution;
+} sensor_properties_t;
+@endcode
+
+
+<b>Sensor data unit index:</b>
+@code
+enum sensor_data_unit_idx {
+ SENSOR_UNDEFINED_UNIT,
+ SENSOR_UNIT_METRE_PER_SECOND_SQUARED,
+ SENSOR_UNIT_MICRO_TESLA,
+ SENSOR_UNIT_DEGREE,
+ SENSOR_UNIT_LUX,
+ SENSOR_UNIT_CENTIMETER,
+ SENSOR_UNIT_LEVEL_1_TO_10,
+ SENSOR_UNIT_STATE_ON_OFF,
+ SENSOR_UNIT_DEGREE_PER_SECOND,
+ SENSOR_UNIT_IDX_END
+};
+@endcode
+
+
+<b>Accelerometer Data ID:</b>
+@code
+enum accelerometer_data_id {
+ ACCELEROMETER_BASE_DATA_SET = (ACCELEROMETER_SENSOR<<16) | 0x0001,
+};
+@endcode
+
+
+<b>Accelerometer Event Type:</b>
+@code
+enum accelerometer_evet_type {
+ ACCELEROMETER_EVENT_ROTATION_CHECK
+ = (ACCELEROMETER_SENSOR<<16) |0x0001,
+ ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME
+ = (ACCELEROMETER_SENSOR<<16) |0x0002,
+ ACCELEROMETER_EVENT_CALIBRATION_NEEDED
+ = (ACCELEROMETER_SENSOR<<16) |0x0004,
+};
+@endcode
+
+
+<b>Accelerometer Rotate state:</b>
+@code
+enum accelerometer_rotate_state {
+ ROTATION_UNKNOWN = 0,
+ ROTATION_LANDSCAPE_LEFT = 1,
+ ROTATION_PORTRAIT_TOP = 2,
+ ROTATION_PORTRAIT_BTM = 3,
+ ROTATION_LANDSCAPE_RIGHT = 4,
+ ROTATION_EVENT_0 = 2,
+ ROTATION_EVENT_90 = 1,
+ ROTATION_EVENT_180 = 3,
+ ROTATION_EVENT_270 = 4,
+};
+@endcode
+
+
+<b>Geo Magnetic Data ID:</b>
+@code
+enum geomag_data_id {
+ GEOMAGNETIC_BASE_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0001,
+ GEOMAGNETIC_RAW_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0002,
+};
+@endcode
+
+
+<b>Geo Magnetic Event Type:</b>
+@code
+enum geomag_evet_type {
+ GEOMAGNETIC_EVENT_CALIBRATION_NEEDED = (GEOMAGNETIC_SENSOR<<16) |0x0001,
+ GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0002,
+ GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0004,
+};
+@endcode
+
+
+<b>Gyro Data ID:</b>
+@code
+enum gyro_data_id {
+ GYRO_BASE_DATA_SET = (GYROSCOPE_SENSOR<<16) | 0x0001,
+};
+@endcode
+
+
+<b>Gyro Event Type:</b>
+@code
+enum gyro_evet_type {
+ GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME = (GYROSCOPE_SENSOR<<16) |0x0001,
+};
+@endcode
+
+
+<b>Light Data ID:</b>
+@code
+enum light_data_id {
+ LIGHT_BASE_DATA_SET = (LIGHT_SENSOR<<16) | 0x0001,
+};
+@endcode
+
+
+<b>Light Event Type:</b>
+@code
+enum light_evet_type {
+ LIGHT_EVENT_CHANGE_LEVEL = (LIGHT_SENSOR<<16) |0x0001,
+ LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME = (LIGHT_SENSOR<<16) |0x0002,
+};
+@endcode
+
+
+<b>Proximity Data ID:</b>
+@code
+enum proxi_data_id {
+ PROXIMITY_BASE_DATA_SET = (PROXIMITY_SENSOR<<16) | 0x0001,
+};
+@endcode
+
+
+<b>Proximity Event Type:</b>
+@code
+enum proxi_evet_type {
+ PROXIMITY_EVENT_CHANGE_STATE = (PROXIMITY_SENSOR<<16) |0x0001,
+ PROXIMITY_EVENT_STATE_REPORT_ON_TIME = (PROXIMITY_SENSOR<<16) |0x0002,
+};
+@endcode
+
+
+<b>Proximity Change State:</b>
+@code
+enum proxi_change_state {
+ PROXIMITY_STATE_FAR = 0,
+ PROXIMITY_STATE_NEAR = 1,
+};
+@endcode
+
+
+
+*/
+/**
+*@}
+*/
+
+/**
+ * @defgroup SENSOR_UC Use Cases
+ * @ingroup SENSOR_FRAMEWORK_PG
+*/
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_COMMON_H__
+#define __SAMSUNG_LINUX_SENSOR_COMMON_H__
+
+#ifndef DEPRECATED
+#define DEPRECATED __attribute__((deprecated))
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <sys/types.h>
+
+/**
+ * @defgroup SENSOR_FRAMEWORK SensorFW
+ * To support the unified API for the various sensors
+ */
+
+/**
+ * @defgroup SENSOR_FRAMEWORK_COMMON Sensor Framework Common API
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the sensors.
+ * @{
+ */
+
+/**
+ * @file sensor.h
+ * @brief Sensor Framework common API header file
+ * for supporting application layer and communicate between App and Sensor Framework
+ * server.
+ *
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @version 1.0
+*/
+
+
+typedef enum {
+ UNKNOWN_SENSOR = 0x0000,
+ ACCELEROMETER_SENSOR = 0x0001,
+ GEOMAGNETIC_SENSOR = 0x0002,
+ LIGHT_SENSOR = 0x0004,
+ PROXIMITY_SENSOR = 0x0008,
+ THERMOMETER_SENSOR = 0x0010,
+ GYROSCOPE_SENSOR = 0x0020,
+ PRESSURE_SENSOR = 0x0040,
+ MOTION_SENSOR = 0x0080,
+} sensor_type_t;
+
+/*header for each sensor type*/
+#include <sensor_accel.h>
+#include <sensor_geomag.h>
+#include <sensor_light.h>
+#include <sensor_proxi.h>
+#include <sensor_motion.h>
+#include <sensor_gyro.h>
+
+typedef enum {
+ CONDITION_NO_OP,
+ CONDITION_EQUAL,
+ CONDITION_GREAT_THAN,
+ CONDITION_LESS_THAN,
+} condition_op_t;
+
+typedef struct {
+ condition_op_t cond_op;
+ float cond_value1;
+} event_condition_t;
+
+
+typedef struct {
+ size_t event_data_size;
+ void *event_data;
+} sensor_event_data_t;
+
+typedef void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *); /**/
+
+enum sensor_data_unit_idx {
+ SENSOR_UNDEFINED_UNIT,
+ SENSOR_UNIT_METRE_PER_SECOND_SQUARED,
+ SENSOR_UNIT_MICRO_TESLA,
+ SENSOR_UNIT_DEGREE,
+ SENSOR_UNIT_LUX,
+ SENSOR_UNIT_CENTIMETER,
+ SENSOR_UNIT_LEVEL_1_TO_10,
+ SENSOR_UNIT_STATE_ON_OFF,
+ SENSOR_UNIT_DEGREE_PER_SECOND,
+
+ SENSOR_UNIT_IDX_END
+};
+
+enum sensor_data_accuracy {
+ SENSOR_ACCURACY_UNDEFINED = -1,
+ SENSOR_ACCURACY_BAD = 0,
+ SENSOR_ACCURACY_NORMAL =1,
+ SENSOR_ACCURACY_GOOD = 2,
+ SENSOR_ACCURACY_VERYGOOD = 3
+};
+
+typedef struct {
+ int data_accuracy;
+ int data_unit_idx;
+ unsigned long long time_stamp;
+ int values_num;
+ float values[12];
+} sensor_data_t;
+
+typedef struct {
+ int x;
+ int y;
+} sensor_panning_data_t;
+
+
+typedef struct {
+ int sensor_unit_idx;
+ float sensor_min_range;
+ float sensor_max_range;
+ float sensor_resolution;
+} sensor_properties_t;
+
+
+/**
+ * @fn int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type )
+ * @brief This API loads the in parameter available list with the type of sensor available for operation . Some of the supported types are ACCELEROMETER_SENSOR_TYPE, GEOMAGNETIC_SENSOR_TYPE etc. This API will return 0 when it is available and negative value when it does not available.
+ * @param[in] desired_sensor_type your desired sensor type to check
+ * @param[in] desired_event_type your desired event type to check , if you want to check only sensor-available , set "0" value
+ * @return if it succeed, it return zero value(available) , otherwise negative value return (not available)
+ */
+int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type );
+
+
+/**
+ * @fn int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties)
+ * @brief This API loads the properties of sensor type like unit of sensor data, max/min range of sensor data etc to the output parameter sensor_properties.
+ * @param[in] sensor_type your desired sensor type
+ * @param[out] return_properties property information of your desired sensor
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties);
+
+
+/**
+ * @fn int sf_connect(sensor_type_t sensor_type)
+ * @brief This API connects a sensor type to respective sensor. The application calls with the type of the sensor (ex. ACCELEROMETER_SENSOR) and on basis of that server takes decision of which plug-in to be connected. Once sensor connected application can proceed for data processing. This API returns a positive handle which should be used by application to communicate on sensor type.
+ * @param[in] sensor_type your desired sensor type
+ * @return if it succeed, it return handle value( >=0 ) , otherwise negative value return
+ */
+int sf_connect(sensor_type_t sensor_type);
+
+
+/**
+ * @fn int sf_disconnect(int handle)
+ * @brief This API disconnects an attached sensor from an application. Application must use the handle retuned after attaching the sensor. After detaching, the corresponding handle will be released.
+ * @param[in] handle received handle value by sf_connect()
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_disconnect(int handle);
+
+
+/**
+ * @fn int sf_start(int handle , int option)
+ * @brief This API sends a start command to sensor server. This intimates server that the client side is ready to handle data and start processing. The parameter option should be '0' for current usages.
+ * @param[in] handle received handle value by sf_connect()
+ * @param[in] option just set a "0" value (not support current , reserved for future
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_start(int handle , int option);
+
+
+/**
+ * @fn int sf_stop(int handle)
+ * @brief This API sends a stop command to the Sensor server indicating that the data processing is stopped from application side for this time.
+ * @param[in] handle received handle value by sf_connect()
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_stop(int handle);
+
+/**
+ * @fn int sf_register_event(int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data )
+ * @brief This API registers a user defined callback function with a connected sensor for a particular event. This callback function will be called when there is a change in the state of respective sensor. cb_data will be the parameter used during the callback call. Callback interval can be adjusted using even_contion_t argument.
+ * @param[in] handle received handle value by sf_connect()
+ * @param[in] event_type your desired event_type to register it
+ * @param[in] event_condition input event_condition for special event. if you want to register without event_condition, just use a NULL value
+ * @param[in] cb your define callback function
+ * @param[in] cb_data your option data that will be send when your define callback function called. if you don't have any option data, just use a NULL value
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_register_event(int handle , unsigned int event_type , event_condition_t *event_condition , sensor_callback_func_t cb , void *cb_data );
+
+
+/**
+ * @fn int sf_unregister_event(int handle, unsigned int event_type)
+ * @brief This API de-registers a user defined callback function with a sensor registered with the specified handle. After unsubscribe, no event will be sent to the application.
+ * @param[in] handle received handle value by sf_connect()
+ * @param[in] event_type your desired event_type that you want to unregister event
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_unregister_event(int handle, unsigned int event_type);
+
+
+/**
+ * @fn int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values)
+ * @brief This API gets raw data from a sensor with connecting the sensor-server. The type of sensor is supplied and return data is stored in the output parameter values [].
+ * @param[in] handle received handle value by sf_connect()
+ * @param[in] data_id predefined data_ID as every sensor in own header - sensor_xxx.h , enum xxx_data_id {}
+ * @param[out] values return values
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values);
+
+
+/**
+ * @fn int sf_check_rotation( unsigned long *curr_state)
+ * @brief This API used to get the current rotation state. (i.e. ROTATION_EVENT_0, ROTATION_EVENT_90, ROTATION_EVENT_180 & ROTATION_EVENT_270 ). This API will directly access the sensor without connection process with the sensor-server. Result will be stored in the output parameter state.
+ * @param[out] curr_state it will return enum accelerometer_rotate_state value
+ * @return if it succeed, it return zero value , otherwise negative value return
+ */
+int sf_check_rotation( unsigned long *curr_state);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_ACCEL_H__
+#define __SAMSUNG_LINUX_SENSOR_ACCEL_H__
+
+
+//! Pre-defined events for the accelometer sensor
+//! Sensor Plugin developer can add more event to their own headers
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup SENSOR_ACCEL Accelerometer Sensor
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the Accelerometer sensor.
+ * @{
+ */
+
+/**
+ * @file sensor_accel.h
+ * @brief This file contains the prototypes of the Accelerometer sensor API
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @date 2010-01-24
+ * @version 0.1
+ */
+
+
+enum accelerometer_data_id {
+ ACCELEROMETER_BASE_DATA_SET = (ACCELEROMETER_SENSOR<<16) | 0x0001,
+ ACCELEROMETER_ORIENTATION_DATA_SET = (ACCELEROMETER_SENSOR<<16) | 0x0002,
+};
+
+enum accelerometer_event_type {
+ ACCELEROMETER_EVENT_ROTATION_CHECK = (ACCELEROMETER_SENSOR<<16) | 0x0001,
+ ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR<<16) | 0x0002,
+ ACCELEROMETER_EVENT_CALIBRATION_NEEDED = (ACCELEROMETER_SENSOR<<16) | 0x0004,
+ ACCELEROMETER_EVENT_SET_HORIZON = (ACCELEROMETER_SENSOR<<16) | 0x0008,
+ ACCELEROMETER_EVENT_SET_WAKEUP = (ACCELEROMETER_SENSOR<<16) | 0x0010,
+ ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR<<16) | 0x0011,
+};
+
+
+enum accelerometer_rotate_state {
+ ROTATION_UNKNOWN = 0,
+ ROTATION_LANDSCAPE_LEFT = 1,
+ ROTATION_PORTRAIT_TOP = 2,
+ ROTATION_PORTRAIT_BTM = 3,
+ ROTATION_LANDSCAPE_RIGHT = 4,
+ ROTATION_EVENT_0 = 2, /*CCW base*/
+ ROTATION_EVENT_90 = 1, /*CCW base*/
+ ROTATION_EVENT_180 = 3, /*CCW base*/
+ ROTATION_EVENT_270 = 4, /*CCW base*/
+};
+
+
+struct rotation_event {
+ enum accelerometer_rotate_state rotation;
+ enum accelerometer_rotate_state rm[2];
+};
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_GEOMAG_H__
+#define __SAMSUNG_LINUX_SENSOR_GEOMAG_H__
+
+//! Pre-defined events for the geomagnetic sensor
+//! Sensor Plugin developer can add more event to their own headers
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup SENSOR_GEOMAG Geomagnetic Sensor
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the Geomagnatic sensor.
+ * @{
+ */
+
+/**
+ * @file sensor_geomag.h
+ * @brief This file contains the prototypes of the Geomagnatic sensor API
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @date 2010-01-24
+ * @version 0.1
+ */
+
+
+
+enum geomag_data_id {
+ GEOMAGNETIC_BASE_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0001,
+ GEOMAGNETIC_RAW_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0002,
+};
+
+
+enum geomag_evet_type {
+ GEOMAGNETIC_EVENT_CALIBRATION_NEEDED = (GEOMAGNETIC_SENSOR<<16) |0x0001,
+ GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0002,
+ GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0004,
+};
+
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_GYRO_H__
+#define __SAMSUNG_LINUX_SENSOR_GYRO_H__
+
+//! Pre-defined events for the gyroscope sensor
+//! Sensor Plugin developer can add more event to their own headers
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup SENSOR_GYRO Gyro Sensor
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the gyro sensor.
+ * @{
+ */
+
+/**
+ * @file sensor_gyro.h
+ * @brief This file contains the prototypes of the gyro sensor API
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @date 2010-01-24
+ * @version 0.1
+ */
+
+
+enum gyro_data_id {
+ GYRO_BASE_DATA_SET = (GYROSCOPE_SENSOR<<16) | 0x0001,
+};
+
+
+enum gyro_evet_type {
+ GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME = (GYROSCOPE_SENSOR<<16) |0x0001,
+};
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_LIGHT_H__
+#define __SAMSUNG_LINUX_SENSOR_LIGHT_H__
+
+//! Pre-defined events for the light sensor
+//! Sensor Plugin developer can add more event to their own headers
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup SENSOR_LIGHT Light Sensor
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the light sensor.
+ * @{
+ */
+
+/**
+ * @file sensor_light.h
+ * @brief This file contains the prototypes of the light sensor API
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @date 2010-01-24
+ * @version 0.1
+ */
+
+
+enum light_data_id {
+ LIGHT_BASE_DATA_SET = (LIGHT_SENSOR<<16) | 0x0001,
+};
+
+
+enum light_evet_type {
+ LIGHT_EVENT_CHANGE_LEVEL = (LIGHT_SENSOR<<16) |0x0001,
+ LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME = (LIGHT_SENSOR<<16) |0x0002,
+};
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_MOTION_H__
+#define __SAMSUNG_LINUX_SENSOR_MOTION_H__
+
+
+//! Pre-defined events for the motion sensor
+//! Sensor Plugin developer can add more event to their own headers
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+enum motion_evet_type {
+ MOTION_ENGINE_EVENT_SNAP = (MOTION_SENSOR<<16) |0x0001,
+ MOTION_ENGINE_EVENT_SHAKE = (MOTION_SENSOR<<16) |0x0002,
+ MOTION_ENGINE_EVENT_DOUBLETAP = (MOTION_SENSOR<<16) |0x0004,
+ MOTION_ENGINE_EVENT_PANNING = (MOTION_SENSOR<<16) |0x0008,
+ MOTION_ENGINE_EVENT_TOP_TO_BOTTOM = (MOTION_SENSOR<<16) |0x0010,
+};
+
+enum motion_snap_event {
+ MOTION_ENGIEN_SNAP_NONE,
+ MOTION_ENGIEN_NEGATIVE_SNAP_X,
+ MOTION_ENGIEN_POSITIVE_SNAP_X,
+ MOTION_ENGIEN_NEGATIVE_SNAP_Y,
+ MOTION_ENGIEN_POSITIVE_SNAP_Y,
+ MOTION_ENGIEN_NEGATIVE_SNAP_Z,
+ MOTION_ENGIEN_POSITIVE_SNAP_Z,
+ MOTION_ENGIEN_SNAP_LEFT = MOTION_ENGIEN_NEGATIVE_SNAP_X,
+ MOTION_ENGIEN_SNAP_RIGHT = MOTION_ENGIEN_POSITIVE_SNAP_X,
+
+};
+
+enum motion_shake_event {
+ MOTION_ENGIEN_SHAKE_NONE,
+ MOTION_ENGIEN_SHAKE_DETECTION,
+ MOTION_ENGIEN_SHAKE_CONTINUING,
+ MOTION_ENGIEN_SHAKE_FINISH,
+ MOTION_ENGINE_SHAKE_BREAK,
+};
+
+enum motion_doubletap_event {
+ MOTION_ENGIEN_DOUBLTAP_NONE,
+ MOTION_ENGIEN_DOUBLTAP_DETECTION,
+};
+
+enum motion_top_to_bottom_event {
+ MOTION_ENGIEN_TOP_TO_BOTTOM_NONE,
+ MOTION_ENGIEN_TOP_TO_BOTTOM_WAIT,
+ MOTION_ENGIEN_TOP_TO_BOTTOM_DETECTION,
+};
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+//! End of a file
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 __SAMSUNG_LINUX_SENSOR_PROXI_H__
+#define __SAMSUNG_LINUX_SENSOR_PROXI_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup SENSOR_PROXY Proximity Sensor
+ * @ingroup SENSOR_FRAMEWORK
+ *
+ * These APIs are used to control the Proxymaty sensor.
+ * @{
+ */
+
+/**
+ * @file sensor_proxi.h
+ * @brief This file contains the prototypes of the proximaty sensor API
+ * @author JuHyun Kim(jh8212.kim@samsung.com)
+ * @date 2010-01-24
+ * @version 0.1
+ */
+
+
+enum proxi_data_id {
+ PROXIMITY_BASE_DATA_SET = (PROXIMITY_SENSOR<<16) | 0x0001,
+};
+
+enum proxi_evet_type {
+ PROXIMITY_EVENT_CHANGE_STATE = (PROXIMITY_SENSOR<<16) |0x0001,
+ PROXIMITY_EVENT_STATE_REPORT_ON_TIME = (PROXIMITY_SENSOR<<16) |0x0002,
+};
+
+enum proxi_change_state {
+ PROXIMITY_STATE_FAR = 0,
+ PROXIMITY_STATE_NEAR = 1,
+};
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+//! End of a file
--- /dev/null
+
+Name: sensor
+Summary: Sensor framework client library
+Version: 0.5.6
+Release: 1
+Group: TO_BE/FILLED_IN
+License: TO BE FILLED IN
+Source0: sensor-%{version}.tar.gz
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
+BuildRequires: cmake
+BuildRequires: vconf-keys-devel
+BuildRequires: pkgconfig(sf_common)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(glib-2.0)
+
+
+%description
+Sensor framework client library
+
+
+
+%package devel
+Summary: Sensor framework library (devel)
+Group: System/Sensor Framework
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+Sensor framework client library (devel)
+
+
+%prep
+%setup -q -n %{name}-%{version}
+
+
+%build
+cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix}
+
+
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+
+
+
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+
+
+
+
+%files
+%defattr(-,root,root,-)
+%doc COPYING
+%{_libdir}/libsensor.so.*
+
+
+%files devel
+%defattr(-,root,root,-)
+%{_includedir}/sensor/*.h
+%{_libdir}/libsensor.so
+%{_libdir}/pkgconfig/sensor.pc
+
--- /dev/null
+==============================================================
+Package: src
+==============================================================
+1: You don't have either of COPYING and LICENSE. After adding one of them, re-do the sanity checking.
+==============================================================
+
+
+==============================================================
+Package: include
+==============================================================
+1: You don't have either of COPYING and LICENSE. After adding one of them, re-do the sanity checking.
+==============================================================
+
+
+==============================================================
+Package: image
+==============================================================
+1: You don't have either of COPYING and LICENSE. After adding one of them, re-do the sanity checking.
+==============================================================
+
+
+==============================================================
+Package: .git
+==============================================================
+1: You don't have either of COPYING and LICENSE. After adding one of them, re-do the sanity checking.
+==============================================================
+
+
+==============================================================
+Package: debian
+==============================================================
+1: You don't have either of COPYING and LICENSE. After adding one of them, re-do the sanity checking.
+==============================================================
+
+
--- /dev/null
+# Package Information for pkg-config
+
+prefix=@PREFIX@
+exec_prefix=@EXEC_PREFIX@
+libdir=@LIBDIR@
+includedir=@INCLUDEDIR@/sensor
+
+Name: libsensor
+Description: Sensor framework client library
+Version: @VERSION@
+Requires:
+Libs: -L${libdir} -lsensor
+Cflags: -I${includedir}
--- /dev/null
+/*
+ * libslp-sensor
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JuHyun Kim <jh8212.kim@samsung.com>
+ *
+ * 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <pthread.h>
+#include <math.h>
+#include <sys/time.h>
+#include <time.h>
+
+#include <cobject_type.h>
+
+#include <csync.h>
+#include <cmutex.h>
+#include <clist.h>
+#include <cworker.h>
+#include <csock.h>
+
+#include <cpacket.h>
+
+#include <common.h>
+#include <sf_common.h>
+
+#include <vconf.h>
+#include <glib.h>
+#include <sensor.h>
+#include <errno.h>
+
+extern int errno;
+
+#ifndef EXTAPI
+#define EXTAPI __attribute__((visibility("default")))
+#endif
+
+#define MAX_BIND_SLOT 16
+#define MAX_CB_SLOT_PER_BIND 16
+#define MAX_CB_BIND_SLOT 64
+
+#define PITCH_MIN 35
+#define PITCH_MAX 145
+
+#define MAX_CHANNEL_NAME_LEN 50
+#define BASE_GATHERING_INTERVAL 100
+
+#define ACCEL_SENSOR_BASE_CHANNEL_NAME "accel_datastream"
+#define GEOMAG_SENSOR_BASE_CHANNEL_NAME "geomag_datastream"
+#define LIGHT_SENSOR_BASE_CHANNEL_NAME "lumin_datastream"
+#define PROXI_SENSOR_BASE_CHANNEL_NAME "proxi_datastream"
+#define MOTION_ENGINE_BASE_CHANNEL_NAME "motion_datastream"
+#define GYRO_SENSOR_BASE_CHANNEL_NAME "gyro_datastream"
+
+#define ROTATION_0 0
+#define ROTATION_90 90
+#define ROTATION_180 180
+#define ROTATION_270 270
+#define ROTATION_360 360
+#define ROTATION_THD 45
+
+#define RADIAN_VALUE (57.2957)
+
+
+
+const char *STR_SF_CLIENT_IPC_SOCKET = "/tmp/sf_socket";
+const char *LCD_TYPE_KEY = "memory/sensor/lcd_type";
+
+static cmutex _lock;
+
+enum _sensor_current_state {
+ SENSOR_STATE_UNKNOWN = -1,
+ SENSOR_STATE_STOPPED = 0,
+ SENSOR_STATE_STARTED = 1,
+};
+
+struct sf_bind_table_t {
+ csock *ipc;
+ sensor_type_t sensor_type;
+ int cb_event_max_num; /*limit by MAX_BIND_PER_CB_SLOT*/
+ int cb_slot_num[MAX_CB_SLOT_PER_BIND];
+ int my_handle;
+ int sensor_state;
+};
+
+struct cb_bind_table_t {
+ char call_back_key[MAX_KEY_LEN];
+ void *client_data;
+ void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *);
+ unsigned int cb_event_type;
+ int my_cb_handle;
+ int my_sf_handle;
+
+ unsigned int request_count;
+ unsigned int request_data_id;
+ void *collected_data;
+ unsigned int current_collected_idx;
+
+ GSource *source;
+ guint gsource_interval;
+ guint gID;
+};
+
+static struct rotation_event rotation_mode[] =
+{
+ {
+ ROTATION_UNKNOWN,
+ {
+ ROTATION_UNKNOWN,
+ ROTATION_UNKNOWN
+ },
+ },
+ {
+ ROTATION_EVENT_90,
+ {
+ ROTATION_LANDSCAPE_LEFT,
+ ROTATION_PORTRAIT_BTM
+ },
+ },
+ {
+ ROTATION_EVENT_0,
+ {
+ ROTATION_PORTRAIT_TOP,
+ ROTATION_LANDSCAPE_LEFT
+ },
+ },
+ {
+ ROTATION_EVENT_180,
+ {
+ ROTATION_PORTRAIT_BTM,
+ ROTATION_LANDSCAPE_RIGHT
+ },
+ },
+ {
+ ROTATION_EVENT_270,
+ {
+ ROTATION_LANDSCAPE_RIGHT,
+ ROTATION_PORTRAIT_TOP
+ },
+ },
+};
+
+
+static sf_bind_table_t g_bind_table[MAX_BIND_SLOT];
+
+static cb_bind_table_t g_cb_table[MAX_CB_BIND_SLOT];
+
+inline static int acquire_handle(void)
+{
+ register int i;
+ _lock.lock();
+ for (i = 0; i < MAX_BIND_SLOT; i ++) {
+ if (g_bind_table[i].ipc == NULL) break;
+ }
+ _lock.unlock();
+
+ return i;
+}
+
+
+inline static int cb_acquire_handle(void)
+{
+ register int i;
+ _lock.lock();
+ for (i = 0; i < MAX_CB_BIND_SLOT; i ++) {
+ if (g_cb_table[i].sensor_callback_func_t == NULL) break;
+ }
+ _lock.unlock();
+
+ return i;
+}
+
+
+inline static void release_handle(int i)
+{
+ register int j;
+
+ _lock.lock();
+ delete g_bind_table[i].ipc;
+ g_bind_table[i].ipc = NULL;
+ g_bind_table[i].sensor_type = UNKNOWN_SENSOR;
+
+ g_bind_table[i].my_handle = -1;
+ g_bind_table[i].sensor_state = SENSOR_STATE_UNKNOWN;
+
+ for (j=0; j<g_bind_table[i].cb_event_max_num; j++) {
+ if ( (j<MAX_CB_SLOT_PER_BIND) && (g_bind_table[i].cb_slot_num[j] > -1) ) {
+ g_cb_table[g_bind_table[i].cb_slot_num[j]].client_data= NULL;
+ g_cb_table[g_bind_table[i].cb_slot_num[j]].sensor_callback_func_t = NULL;
+ g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type = 0x00;
+ g_cb_table[g_bind_table[i].cb_slot_num[j]].my_cb_handle = -1;
+ g_bind_table[i].cb_slot_num[j] = -1;
+ }
+ }
+
+ g_bind_table[i].cb_event_max_num = 0;
+
+ _lock.unlock();
+}
+
+inline static void cb_release_handle(int i)
+{
+ _lock.lock();
+ g_cb_table[i].client_data= NULL;
+ g_cb_table[i].sensor_callback_func_t = NULL;
+ g_cb_table[i].cb_event_type = 0x00;
+ g_cb_table[i].my_cb_handle = -1;
+ g_cb_table[i].my_sf_handle = -1;
+
+ g_cb_table[i].request_count = 0;
+ g_cb_table[i].request_data_id = 0;
+
+ if ( g_cb_table[i].collected_data )
+ free (g_cb_table[i].collected_data);
+
+ g_cb_table[i].collected_data = NULL;
+ g_cb_table[i].current_collected_idx = 0;
+
+ g_cb_table[i].source = NULL;
+ g_cb_table[i].gsource_interval = 0;
+ g_cb_table[i].gID = 0;
+
+ _lock.unlock();
+}
+
+static void sensor_changed_cb (keynode_t *node, void *data)
+{
+ int *cb_handle = (int*)(data);
+ int val;
+ sensor_event_data_t cb_data;
+ sensor_panning_data_t panning_data;
+
+ if (g_cb_table[*cb_handle].sensor_callback_func_t) {
+
+ if ( vconf_keynode_get_type(node) != VCONF_TYPE_INT ) {
+ ERR("Err invaild key_type , incomming key_type : %d , key_name : %s , key_value : %d",
+ vconf_keynode_get_type(node), vconf_keynode_get_name(node),vconf_keynode_get_int(node));
+ return;
+ }
+
+ val = vconf_keynode_get_int(node);
+
+ if(g_cb_table[*cb_handle].cb_event_type == MOTION_ENGINE_EVENT_PANNING)
+ {
+ if(val != 0)
+ {
+ panning_data.x = (short)(val >> 16);
+ panning_data.y = (short)(val & 0x0000FFFF);
+ cb_data.event_data_size = sizeof(sensor_panning_data_t);
+ cb_data.event_data = (void *)&panning_data;
+ g_cb_table[*cb_handle].sensor_callback_func_t(g_cb_table[*cb_handle].cb_event_type, &cb_data , g_cb_table[*cb_handle].client_data);
+ }
+ }
+ else if ( val<0 ) {
+ ERR("vconf_keynode_get_int fail for key : %s , handle_num : %d , get_value : %d\n", g_cb_table[*cb_handle].call_back_key,*cb_handle , val);
+ } else {
+ switch (g_cb_table[*cb_handle].cb_event_type) {
+ case ACCELEROMETER_EVENT_ROTATION_CHECK :
+ /* fall through */
+ case ACCELEROMETER_EVENT_SET_HORIZON :
+ /* fall through */
+ case ACCELEROMETER_EVENT_SET_WAKEUP :
+ /* fall through */
+ case GEOMAGNETIC_EVENT_CALIBRATION_NEEDED :
+ /* fall through */
+ case LIGHT_EVENT_CHANGE_LEVEL :
+ /* fall through */
+ case PROXIMITY_EVENT_CHANGE_STATE:
+ /* fall through */
+ case MOTION_ENGINE_EVENT_SNAP:
+ /* fall through */
+ case MOTION_ENGINE_EVENT_SHAKE:
+ /* fall through */
+ case MOTION_ENGINE_EVENT_DOUBLETAP:
+ /* fall through */
+ case MOTION_ENGINE_EVENT_TOP_TO_BOTTOM:
+ /* fall through */
+ cb_data.event_data_size = sizeof(val);
+ cb_data.event_data = (void *)&val ;
+ break;
+ default :
+ ERR("Undefined cb_event_type");
+ return ;
+ break;
+ }
+
+
+ g_cb_table[*cb_handle].sensor_callback_func_t(g_cb_table[*cb_handle].cb_event_type , &cb_data , g_cb_table[*cb_handle].client_data);
+ }
+
+ } else {
+ ERR("Empty Callback func in cb_handle : %d\n", *cb_handle);
+ }
+
+}
+
+static gboolean sensor_timeout_handler(gpointer data)
+{
+ int *cb_handle = (int*)(data);
+ int state;
+ sensor_event_data_t cb_data;
+
+ if ( g_bind_table[g_cb_table[*cb_handle].my_sf_handle].sensor_state != SENSOR_STATE_STARTED ) {
+ ERR("Check sensor_state, current sensor state : %d",g_bind_table[g_cb_table[*cb_handle].my_sf_handle].sensor_state);
+ return TRUE;
+ }
+
+ DBG("sensor_timeout_handler started , cb_handle value : %d\n", *cb_handle);
+
+ if (g_cb_table[*cb_handle].sensor_callback_func_t) {
+
+ if ( ((g_cb_table[*cb_handle].request_data_id & 0xFFFF) > 0) && ((g_cb_table[*cb_handle].request_data_id & 0xFFFF) < 10) ) {
+ sensor_data_t *base_data_values;
+ base_data_values =(sensor_data_t *)g_cb_table[*cb_handle].collected_data;
+
+ if ( !base_data_values ) {
+ ERR("ERR get saved_gather_data stuct fail in sensor_timeout_handler \n");
+ return FALSE;
+ }
+ state = sf_get_data(g_cb_table[*cb_handle].my_sf_handle, g_cb_table[*cb_handle].request_data_id, base_data_values);
+
+ if ( state < 0 ) {
+ ERR("ERR sensor_get_struct_data fail in sensor_timeout_handler : %d\n",state);
+ return TRUE;
+ }
+
+ cb_data.event_data_size = sizeof (sensor_data_t);
+ cb_data.event_data = g_cb_table[*cb_handle].collected_data;
+
+ g_cb_table[*cb_handle].sensor_callback_func_t( g_cb_table[*cb_handle].cb_event_type , &cb_data , g_cb_table[*cb_handle].client_data);
+
+
+ } else {
+ ERR("Does not support data_type");
+ return TRUE;
+ }
+
+
+ } else {
+ ERR("Empty Callback func in cb_handle : %d\n", *cb_handle);
+ }
+
+ return TRUE;
+}
+
+///////////////////////////////////for internal ///////////////////////////////////
+static int server_get_properties(int handle , sensor_properties_t *return_properties )
+{
+ cpacket packet(sizeof(cmd_return_property_t) + sizeof(base_property_struct)+ 4);
+ cmd_get_property_t *cmd_payload;
+ INFO("server_get_properties called with handle : %d \n", handle);
+ if (handle < 0) {
+ ERR("Invalid handle\n");
+ errno = EINVAL;
+ return -1;
+ }
+
+ cmd_payload = (cmd_get_property_t*)packet.data();
+ if (!cmd_payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_GET_PROPERTY);
+ packet.set_payload_size(sizeof(cmd_get_property_t));
+
+ cmd_payload->get_level = ((unsigned int)g_bind_table[handle].sensor_type<<16) | 0x0001;
+
+
+ INFO("Send CMD_GET_PROPERTY command\n");
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Faield to send a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.cmd() == CMD_GET_PROPERTY) {
+ cmd_return_property_t *return_payload;
+ return_payload = (cmd_return_property_t*)packet.data();
+ if (return_payload->state < 0) {
+ ERR("sever get property fail , return state : %d\n",return_payload->state);
+ errno = EBADE;
+ return -2;
+ } else {
+ base_property_struct *base_return_property;
+ base_return_property = (base_property_struct *)return_payload->property_struct;
+
+ return_properties->sensor_unit_idx = base_return_property->sensor_unit_idx ;
+ return_properties->sensor_min_range= base_return_property->sensor_min_range;
+ return_properties->sensor_max_range= base_return_property->sensor_max_range;
+ return_properties->sensor_resolution = base_return_property->sensor_resolution;
+ }
+ } else {
+ ERR("unexpected server cmd\n");
+ errno = EBADE;
+ return -2;
+ }
+ }
+
+ return 0;
+}
+
+
+
+///////////////////////////////////for external ///////////////////////////////////
+
+EXTAPI int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type )
+{
+ int handle;
+ cpacket packet(sizeof(cmd_reg_t)+4);
+ cmd_reg_t *payload;
+
+ handle = sf_connect(desired_sensor_type);
+ if ( handle < 0 ) {
+ errno = ENODEV;
+ return -2;
+ }
+
+ if ( desired_event_type != 0 ) {
+
+ payload = (cmd_reg_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_REG);
+ packet.set_payload_size(sizeof(cmd_reg_t));
+ payload->type = REG_CHK;
+ payload->event_type = desired_event_type;
+
+ INFO("Send CMD_REG command\n");
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Faield to send a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.cmd() == CMD_DONE) {
+ cmd_done_t *payload;
+ payload = (cmd_done_t*)packet.data();
+ if (payload->value == -1) {
+ ERR("sever check fail\n");
+ errno = ENODEV;
+ return -2;
+ }
+ } else {
+ ERR("unexpected server cmd\n");
+ errno = ECOMM;
+ return -2;
+ }
+ }
+
+ }
+
+ sf_disconnect(handle);
+
+ return 0;
+}
+
+
+EXTAPI int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties)
+{
+ int handle;
+ int state = -1;
+
+ retvm_if( (!return_properties ) , -1 , "Invalid return properties pointer : %p", return_properties);
+
+ handle = sf_connect(sensor_type);
+ if ( handle < 0 ) {
+ ERR("Sensor connet fail !! for : %x \n", sensor_type);
+ return -1;
+ } else {
+ state = server_get_properties( handle , return_properties );
+ if ( state < 0 ) {
+ ERR("server_get_properties fail , state : %d \n",state);
+ }
+ sf_disconnect(handle);
+ }
+
+ return state;
+}
+
+EXTAPI int sf_connect(sensor_type_t sensor_type)
+{
+ register int i, j;
+ cpacket packet(sizeof(cmd_hello_t)+MAX_CHANNEL_NAME_LEN+4); //need to check real payload size !!!
+ cmd_hello_t *payload;
+ cmd_done_t *return_payload;
+
+ pid_t cpid;
+ size_t channel_name_length;
+
+ const char *sf_channel_name = NULL;
+
+ cpid = getpid();
+
+ INFO("Sensor_attach_channel from pid : %d , to sensor_type : %x",cpid ,sensor_type);
+
+ i = acquire_handle();
+ if (i == MAX_BIND_SLOT) {
+ ERR("MAX_BIND_SLOT, Too many slot required");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ INFO("Empty slot : %d\n", i);
+
+ switch (sensor_type) {
+ case ACCELEROMETER_SENSOR :
+ sf_channel_name = (char *)ACCEL_SENSOR_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 6;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case GEOMAGNETIC_SENSOR :
+ sf_channel_name = (char *)GEOMAG_SENSOR_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 3;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case LIGHT_SENSOR:
+ sf_channel_name = (char *)LIGHT_SENSOR_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 2;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case PROXIMITY_SENSOR:
+ sf_channel_name = (char *)PROXI_SENSOR_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 2;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case MOTION_SENSOR:
+ sf_channel_name = (char *)MOTION_ENGINE_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 7;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case GYROSCOPE_SENSOR:
+ sf_channel_name = (char *)GYRO_SENSOR_BASE_CHANNEL_NAME;
+ g_bind_table[i].cb_event_max_num = 1;
+
+ for(j = 0 ; j < g_bind_table[i].cb_event_max_num ; j++)
+ g_bind_table[i].cb_slot_num[j] = -1;
+
+ break;
+
+ case THERMOMETER_SENSOR:
+ case PRESSURE_SENSOR:
+ case UNKNOWN_SENSOR:
+ default :
+ ERR("Undefined sensor_type");
+ release_handle(i);
+ errno = ENODEV;
+ return -2;
+ break;
+ }
+
+ g_bind_table[i].sensor_type = sensor_type ;
+ g_bind_table[i].my_handle = i;
+ g_bind_table[i].sensor_state = SENSOR_STATE_STOPPED;
+
+ try {
+ g_bind_table[i].ipc = new csock( (char *)STR_SF_CLIENT_IPC_SOCKET, csock::SOCK_TCP|csock::SOCK_IPC|csock::SOCK_WORKER, 0, 0);
+ } catch (...) {
+ release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[i].ipc && g_bind_table[i].ipc->connect_to_server() == false) {
+ delete g_bind_table[i].ipc;
+ g_bind_table[i].ipc = NULL;
+ release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+
+
+ INFO("Connected to server\n");
+ payload = (cmd_hello_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ release_handle(i);
+ errno = ENOMEM;
+ return -2;
+ }
+
+ if (!sf_channel_name ) {
+ ERR("cannot find matched-sensor name!!!");
+ release_handle(i);
+ errno = ENODEV;
+ return -2;
+ } else {
+ channel_name_length = strlen(sf_channel_name);
+ if ( channel_name_length > MAX_CHANNEL_NAME_LEN ) {
+ ERR("error, channel_name_length too long !!!");
+ release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_HELLO);
+ packet.set_payload_size(sizeof(cmd_hello_t) + channel_name_length);
+ strcpy(payload->name, sf_channel_name);
+
+ if (g_bind_table[i].ipc && g_bind_table[i].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Failed to send a hello packet\n");
+ release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+
+ INFO("Wait for recv a reply packet\n");
+ if (g_bind_table[i].ipc && g_bind_table[i].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[i].ipc && g_bind_table[i].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+ }
+
+ return_payload = (cmd_done_t*)packet.data();
+ if (!return_payload) {
+ ERR("cannot find memory for return packet.data");
+ release_handle(i);
+ return -1;
+ }
+
+ if ( return_payload->value < 0) {
+ ERR("There is no sensor \n");
+ release_handle(i);
+ return -1;
+ }
+
+ INFO("Connected sensor type : %x , handle : %d \n", sensor_type , i);
+ return i;
+}
+
+EXTAPI int sf_disconnect(int handle)
+{
+ cpacket packet(sizeof(cmd_byebye_t)+4);
+ cmd_byebye_t *payload;
+
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_detach_channel fail , invalid handle value : %d",handle);
+
+ INFO("Detach, so remove %d from the table\n", handle);
+
+ payload = (cmd_byebye_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_BYEBYE);
+ packet.set_payload_size(sizeof(cmd_byebye_t));
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Failed to send, but delete handle\n");
+ errno = ECOMM;
+ goto out;
+ }
+
+ INFO("Recv a reply packet\n");
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Send to reply packet fail\n");
+ errno = ECOMM;
+ goto out;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ ERR("Failed to recv packet\n");
+ errno = ECOMM;
+ }
+ }
+
+out:
+ release_handle(handle);
+ return 0;
+
+}
+
+EXTAPI int sf_start(int handle , int option)
+{
+ cpacket packet(sizeof(cmd_start_t)+4);
+ cmd_start_t *payload;
+
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_start fail , invalid handle value : %d",handle);
+ retvm_if( option != 0 , -1 , "sensor_start fail , invalid option value : %d",option);
+
+
+ INFO("Sensor S/F Started\n");
+
+ payload = (cmd_start_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_START);
+ packet.set_payload_size(sizeof(cmd_start_t));
+ payload->option = option;
+
+ INFO("Send CMD_START command\n");
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Faield to send a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ INFO("Recv a reply packet\n");
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Send to reply packet fail\n");
+ errno = ECOMM;
+ return -2;
+ }
+
+ DBG("packet received\n");
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.cmd() == CMD_DONE) {
+ cmd_done_t *payload;
+ payload = (cmd_done_t*)packet.data();
+ if (payload->value < 0) {
+ ERR("Error from sensor server [-1 or -2 : socket error, -3 : stopped by sensor plugin] value = [%d]\n", payload->value);
+ errno = ECOMM;
+ return payload->value;
+ }
+ } else {
+ ERR("unexpected server cmd\n");
+ errno = ECOMM;
+ return -2;
+ }
+ }
+
+ g_bind_table[handle].sensor_state = SENSOR_STATE_STARTED;
+
+ return 0;
+
+}
+
+EXTAPI int sf_stop(int handle)
+{
+ cpacket packet(sizeof(cmd_stop_t)+4);
+ cmd_stop_t *payload;
+
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_stop fail , invalid handle value : %d",handle);
+
+
+ INFO("Sensor S/F Stopped\n");
+
+ payload = (cmd_stop_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_STOP);
+ packet.set_payload_size(sizeof(cmd_stop_t));
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Failed to send a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ g_bind_table[handle].sensor_state = SENSOR_STATE_STOPPED;
+
+ return 0;
+
+}
+
+EXTAPI int sf_register_event(int handle , unsigned int event_type , event_condition_t *event_condition , sensor_callback_func_t cb , void *cb_data )
+{
+ cpacket packet(sizeof(cmd_reg_t)+4);
+ cmd_reg_t *payload;
+ int i;
+ int avail_cb_slot_idx = -1;
+
+ int collect_data_flag = 0;
+
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_register_cb fail , invalid handle value : %d",handle);
+
+ payload = (cmd_reg_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ DBG("Current handle's(%d) cb_event_max_num : %d\n", handle , g_bind_table[handle].cb_event_max_num);
+
+ for ( i=0 ; i<g_bind_table[handle].cb_event_max_num ; i++ ) {
+ if ( ((event_type&0xFFFF)>>i) == 0x0001) {
+ if ( (g_bind_table[handle].cb_slot_num[i] == -1) ||(!(g_cb_table[ g_bind_table[handle].cb_slot_num[i] ].sensor_callback_func_t)) ) {
+ DBG("Find available slot in g_bind_table for cb\n");
+ avail_cb_slot_idx = i;
+ break;
+ }
+ }
+ }
+
+ if (avail_cb_slot_idx < 0 ) {
+ ERR("Find cb_slot fail, There is already callback function!!\n");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ i = cb_acquire_handle();
+ if (i == MAX_CB_BIND_SLOT) {
+ ERR("MAX_BIND_SLOT, Too many slot required");
+ errno = ENOMEM;
+ return -2;
+ }
+ INFO("Empty cb_slot : %d\n", i);
+
+ g_cb_table[i].my_cb_handle = i;
+ g_cb_table[i].my_sf_handle = handle;
+
+ INFO("Sensor S/F register cb\n");
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_REG);
+ packet.set_payload_size(sizeof(cmd_reg_t));
+ payload->type = REG_ADD;
+ payload->event_type = event_type;
+
+ if(!event_condition)
+ payload->interval = BASE_GATHERING_INTERVAL;
+ else if((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ))
+ payload->interval = event_condition->cond_value1;
+ else
+ payload->interval = BASE_GATHERING_INTERVAL;
+
+
+ INFO("Send CMD_REG command with reg_type : %x , event_typ : %x\n",payload->type , payload->event_type );
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Faield to send a packet\n");
+ cb_release_handle(i);
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ cb_release_handle(i);
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ ERR("Faield to receive a packet\n");
+ cb_release_handle(i);
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.cmd() == CMD_DONE) {
+ cmd_done_t *payload;
+ payload = (cmd_done_t*)packet.data();
+ if (payload->value == -1) {
+ ERR("server register fail\n");
+ cb_release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+ } else {
+ ERR("unexpected server cmd\n");
+ cb_release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+ }
+
+ memset(g_cb_table[i].call_back_key,'\0',MAX_KEY_LEN);
+ snprintf(g_cb_table[i].call_back_key,(MAX_KEY_LEN-1),"%s%x",DEFAULT_SENSOR_KEY_PREFIX, event_type);
+
+ g_cb_table[i].cb_event_type = event_type;
+ g_cb_table[i].client_data = cb_data;
+ g_cb_table[i].sensor_callback_func_t = cb;
+
+ switch (event_type ) {
+ case ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case PROXIMITY_EVENT_STATE_REPORT_ON_TIME:
+ /* fall through */
+ case GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME:
+ collect_data_flag = 1;
+ g_cb_table[i].request_count = 1; //support only 1
+ g_cb_table[i].request_data_id = (event_type & (0xFFFF<<16)) |0x0001;
+ if (!event_condition) {
+ g_cb_table[i].gsource_interval = BASE_GATHERING_INTERVAL;
+ } else {
+ if ( (event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ) ) {
+ g_cb_table[i].gsource_interval = (guint)event_condition->cond_value1;
+ } else {
+ ERR("Invaild input_condition interval , input_interval : %f\n", event_condition->cond_value1);
+ cb_release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ }
+
+ break;
+
+ case LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME:
+ collect_data_flag = 1;
+ g_cb_table[i].request_count = 1; //support only 1
+ g_cb_table[i].request_data_id = LIGHT_BASE_DATA_SET;
+ if (!event_condition) {
+ g_cb_table[i].gsource_interval = (BASE_GATHERING_INTERVAL*5);
+ } else {
+ if ( (event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ) ) {
+ g_cb_table[i].gsource_interval = (guint)event_condition->cond_value1;
+ } else {
+ ERR("Invaild input_condition interval , input_interval : %f\n", event_condition->cond_value1);
+ cb_release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ }
+ break;
+
+ case GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME:
+ collect_data_flag = 1;
+ g_cb_table[i].request_count = 1; //support only 1
+ g_cb_table[i].request_data_id = GEOMAGNETIC_RAW_DATA_SET;
+ if (!event_condition) {
+ g_cb_table[i].gsource_interval = (BASE_GATHERING_INTERVAL);
+ } else {
+ if ( (event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ) ) {
+ g_cb_table[i].gsource_interval = (guint)event_condition->cond_value1;
+ } else {
+ ERR("Invaild input_condition interval , input_interval : %f\n", event_condition->cond_value1);
+ cb_release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ }
+ break;
+
+ case ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME:
+ collect_data_flag = 1;
+ g_cb_table[i].request_count = 1; //support only 1
+ g_cb_table[i].request_data_id = ACCELEROMETER_ORIENTATION_DATA_SET;
+ if (!event_condition) {
+ g_cb_table[i].gsource_interval = BASE_GATHERING_INTERVAL;
+ } else {
+ if ( (event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ) ) {
+ g_cb_table[i].gsource_interval = (guint)event_condition->cond_value1;
+ } else {
+ ERR("Invaild input_condition interval , input_interval : %f\n", event_condition->cond_value1);
+ cb_release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ }
+
+ break;
+
+
+ }
+
+ INFO("key : %s(p:%p), cb_handle value : %d\n", g_cb_table[i].call_back_key ,g_cb_table[i].call_back_key, i );
+
+ if ( collect_data_flag ) {
+ sensor_data_t *collected_data_set;
+
+ collected_data_set = new sensor_data_t [g_cb_table[i].request_count];
+ if ( !collected_data_set ) {
+ ERR("memory allocation fail for gathering datas\n");
+ cb_release_handle(i);
+ errno = ECOMM;
+ return -2;
+ }
+ g_cb_table[i].collected_data = (void *)collected_data_set;
+ g_cb_table[i].current_collected_idx = 0;
+
+ if ( g_cb_table[i].gsource_interval != 0 ) {
+ g_cb_table[i].source = g_timeout_source_new(g_cb_table[i].gsource_interval);
+ } else {
+ ERR("Error , gsource_interval value : %u",g_cb_table[i].gsource_interval);
+ cb_release_handle(i);
+ errno = EINVAL;
+ return -1;
+ }
+ g_source_set_callback (g_cb_table[i].source, sensor_timeout_handler, (gpointer)&g_cb_table[i].my_cb_handle,NULL);
+ g_cb_table[i].gID = g_source_attach (g_cb_table[i].source, NULL);
+
+ }else {
+ g_cb_table[i].request_count = 0;
+ g_cb_table[i].request_data_id = 0;
+ g_cb_table[i].collected_data = NULL;
+
+ if (vconf_notify_key_changed( g_cb_table[i].call_back_key,
+ sensor_changed_cb, (void *)&g_cb_table[i].my_cb_handle) < 0 ) {
+ ERR("vconf_add_changed_cb fail, for key : %s , my_cb_handle value : %d\n", g_cb_table[i].call_back_key, g_cb_table[i].my_cb_handle);
+ cb_release_handle(i);
+ errno = ENODEV;
+ return -2;
+ }
+
+ }
+
+ g_bind_table[handle].cb_slot_num[avail_cb_slot_idx] = i;
+
+ return 0;
+}
+
+
+EXTAPI int sf_unregister_event(int handle, unsigned int event_type)
+{
+ int state = 0;
+ cpacket packet(sizeof(cmd_reg_t)+4);
+ cmd_reg_t *payload;
+ int find_cb_handle =-1;
+ int i;
+
+ int collect_data_flag = 0;
+
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_unregister_cb fail , invalid handle value : %d",handle);
+
+ payload = (cmd_reg_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ for ( i=0 ; i<g_bind_table[handle].cb_event_max_num ; i++ ) {
+ if ( g_bind_table[handle].cb_slot_num[i] != -1 ) {
+
+ if ( event_type == g_cb_table[ g_bind_table[handle].cb_slot_num[i] ].cb_event_type) {
+ find_cb_handle = g_bind_table[handle].cb_slot_num[i];
+ break;
+ }
+ }
+ }
+
+ if (find_cb_handle < 0) {
+ ERR("Err , Cannot find cb_slot_num!! for event : %x\n", event_type );
+ errno = EINVAL;
+ return -1;
+ }
+
+
+ INFO("Sensor S/F unregister cb\n");
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_REG);
+ packet.set_payload_size(sizeof(cmd_reg_t));
+ payload->type = REG_DEL;
+ payload->event_type = event_type;
+
+ switch (event_type ) {
+ case ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case PROXIMITY_EVENT_STATE_REPORT_ON_TIME:
+ /* fall through */
+ case GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME:
+ /* fall through */
+ case GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME:
+ collect_data_flag = 1;
+ break;
+ }
+
+ INFO("Send CMD_REG command\n");
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ ERR("Faield to send a packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ ERR("Failed to recv packet_header\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ ERR("Failed to recv packet\n");
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ }
+
+ if ( collect_data_flag ) {
+ g_source_destroy(g_cb_table[find_cb_handle].source);
+ g_source_unref(g_cb_table[find_cb_handle].source);
+ g_cb_table[find_cb_handle].request_count = 0;
+ g_cb_table[find_cb_handle].request_data_id = 0;
+ g_cb_table[find_cb_handle].gsource_interval = 0;
+
+ } else {
+ state = vconf_ignore_key_changed(g_cb_table[find_cb_handle].call_back_key, sensor_changed_cb);
+ if ( state < 0 ) {
+ ERR("Failed to del callback using by vconf_del_changed_cb for key : %s\n",g_cb_table[find_cb_handle].call_back_key);
+ errno = ENODEV;
+ state = -2;
+ }
+ }
+
+ cb_release_handle(find_cb_handle);
+ g_bind_table[handle].cb_slot_num[i] = -1;
+
+ return state;
+
+
+}
+
+
+EXTAPI int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values)
+{
+ cpacket packet(sizeof(cmd_get_struct_t)+sizeof(base_data_struct)+4);
+ cmd_get_data_t *payload;
+ cmd_get_struct_t *return_payload;
+ int i;
+ struct timeval sv;
+
+
+ retvm_if( (!values) , -1 , "sf_get_data fail , invalid get_values pointer %p", values);
+ retvm_if( ( (data_id & 0xFFFF) < 1) || ( (data_id & 0xFFFF) > 0xFFF), -1 , "sf_get_data fail , invalid data_id %d", data_id);
+ retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sf_get_data fail , invalid handle value : %d",handle);
+
+ if(g_bind_table[handle].sensor_state != SENSOR_STATE_STARTED)
+ {
+ ERR("sensor framewoker doesn't started");
+ values->data_accuracy = SENSOR_ACCURACY_UNDEFINED;
+ values->data_unit_idx = SENSOR_UNDEFINED_UNIT;
+ values->time_stamp = 0;
+ values->values_num = 0;
+ errno = ECOMM;
+ return -2;
+ }
+
+ payload = (cmd_get_data_t*)packet.data();
+ if (!payload) {
+ ERR("cannot find memory for send packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ packet.set_version(PROTOCOL_VERSION);
+ packet.set_cmd(CMD_GET_STRUCT);
+ packet.set_payload_size(sizeof(cmd_get_data_t));
+ payload->data_id = data_id;
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet.packet(), packet.size()) == false) {
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet.packet(), packet.header_size()) == false) {
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+
+ if (packet.payload_size()) {
+ if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet.packet() + packet.header_size(), packet.payload_size()) == false) {
+ release_handle(handle);
+ errno = ECOMM;
+ return -2;
+ }
+ }
+
+ return_payload = (cmd_get_struct_t*)packet.data();
+ if (!return_payload) {
+ ERR("cannot find memory for return packet.data");
+ errno = ENOMEM;
+ return -2;
+ }
+
+ if ( return_payload->state < 0 ) {
+ ERR("get values fail from server \n");
+ values->data_accuracy = SENSOR_ACCURACY_UNDEFINED;
+ values->data_unit_idx = SENSOR_UNDEFINED_UNIT;
+ values->time_stamp = 0;
+ values->values_num = 0;
+ errno = ECOMM;
+ return -2;
+ }
+
+ base_data_struct *base_return_data;
+ base_return_data = (base_data_struct *)return_payload->data_struct;
+
+ gettimeofday(&sv, NULL);
+ values->time_stamp = MICROSECONDS(sv);
+
+ values->data_accuracy = base_return_data->data_accuracy;
+ values->data_unit_idx = base_return_data->data_unit_idx;
+ values->values_num = base_return_data->values_num;
+ for ( i = 0 ; i < base_return_data->values_num ; i++ ) {
+ values->values[i] = base_return_data->values[i];
+ DBG("client , get_data_value , [%d] : %f \n", i , values->values[i]);
+ }
+
+
+ return 0;
+
+}
+
+EXTAPI int sf_check_rotation( unsigned long *curr_state)
+{
+ int state = -1;
+
+ double raw_z;
+ double atan_value, norm_z;
+ int acc_theta , acc_pitch;
+ int handle = 0;
+ int lcd_type = 0;
+
+ sensor_data_t *base_data_values = (sensor_data_t*)malloc(sizeof(sensor_data_t));
+
+ retvm_if( curr_state==NULL , -1 , "sf_check_rotation fail , invalid curr_state");
+
+ *curr_state = ROTATION_UNKNOWN;
+
+ INFO("Sensor_attach_channel from pid : %d",getpid());
+
+ handle = sf_connect( ACCELEROMETER_SENSOR);
+ if (handle<0)
+ {
+ ERR("sensor attach fail\n");
+ return 0;
+ }
+
+ state = sf_start(handle, 0);
+ if(state < 0)
+ {
+ ERR("sf_start fail\n");
+ return 0;
+ }
+
+ state = sf_get_data(handle, ACCELEROMETER_BASE_DATA_SET, base_data_values);
+ if(state < 0)
+ {
+ ERR("sf_get_data fail\n");
+ return 0;
+ }
+
+ state = sf_stop(handle);
+ if(state < 0)
+ {
+ ERR("sf_stop fail\n");
+ return 0;
+ }
+
+ state = sf_disconnect(handle);
+ if(state < 0)
+ {
+ ERR("sf_disconnect fail\n");
+ return 0;
+ }
+
+ if(vconf_get_int(LCD_TYPE_KEY, &lcd_type) != 0)
+ lcd_type = 0;
+
+ atan_value = atan2(base_data_values->values[1],base_data_values->values[0]);
+
+ acc_theta = (int)(atan_value * (RADIAN_VALUE) + 270)%360;
+
+ raw_z = (double)(base_data_values->values[2]/(0.004 * 9.81));
+
+ if ( raw_z > 250 ) {
+ norm_z = 1.0;
+ }
+ else if ( raw_z < -250 ) {
+ norm_z = -1.0;
+ }
+ else {
+ norm_z = ((double)raw_z)/250;
+ }
+ acc_pitch = (int)( acos(norm_z) *(RADIAN_VALUE));
+
+ INFO( "cal value [acc_theta] : %d , [acc_pitch] : %d\n",acc_theta ,acc_pitch);
+
+ if( (acc_pitch>PITCH_MIN) && (acc_pitch<PITCH_MAX) ) {
+ if ((acc_theta >= ROTATION_360 - ROTATION_THD && acc_theta <= ROTATION_360 ) || (acc_theta >= ROTATION_0 && acc_theta < ROTATION_0 + ROTATION_THD))
+ {
+ *curr_state = rotation_mode[ROTATION_EVENT_0].rm[lcd_type];
+ }
+ else if(acc_theta >= ROTATION_90 - ROTATION_THD && acc_theta < ROTATION_90 + ROTATION_THD)
+ {
+ *curr_state = rotation_mode[ROTATION_EVENT_90].rm[lcd_type];
+ }
+ else if(acc_theta >= ROTATION_180 - ROTATION_THD && acc_theta < ROTATION_180 + ROTATION_THD)
+ {
+ *curr_state = rotation_mode[ROTATION_EVENT_180].rm[lcd_type];
+ }
+ else if(acc_theta >= ROTATION_270 - ROTATION_THD && acc_theta < ROTATION_270 + ROTATION_THD)
+ {
+ *curr_state = rotation_mode[ROTATION_EVENT_270].rm[lcd_type];
+ }
+ else {
+ ERR("Wrong acc_theta : %d , cannot detect current state of ACCEL_SENSOR",acc_theta);
+ *curr_state = rotation_mode[ROTATION_UNKNOWN].rm[lcd_type];
+ }
+ }else {
+ INFO("Cannot detect current state of ACCEL_SENSOR");
+ *curr_state = rotation_mode[ROTATION_UNKNOWN].rm[lcd_type];
+ }
+
+ state = 0;
+ if(base_data_values)
+ free(base_data_values);
+
+ return state;
+
+}
+
+EXTAPI int sf_read_raw_data(sensor_type_t sensor_type , float values[] , size_t *values_size)
+{
+ return -1;
+}
+//! End of a file
projects / framework / system / libslp-sensor.git / commitdiff
