enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

eeze: Add sensor API 

Extend eeze to read out sensor data from various sources with a simple API to
access for application developers. The sensor backends are eina modules. For
now we support a tizen module as well as a fake module for testing.

Modules for plain sysfs on a desktop or other sensor frameworks could get
integrated.

The api is not fixed until 1.8 is out so let me know what you think. Having
small wrappers for all kind of infos like eeze_sensor_light_get or
eeze_sensor_proximity_get are possible but I did not want to bloat the api
from the beginning.

SVN revision: 76825
This commit is contained in:
Stefan Schmidt 2012-09-18 14:14:48 +00:00
parent e0807db1c3
commit 535ef37087
11 changed files with 1713 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
legacy/eeze/configure.ac
View File

@ -206,6 +206,19 @@ if test "x${have_ipv6}" = "xyes" ; then
AC_DEFINE(HAVE_IPV6, 1, [Define if IPV6 is supported])
fi
eeze_sensor_tizen="no"
PKG_CHECK_EXISTS([capi-system-sensor],
[
AC_DEFINE([HAVE_EEZE_TIZEN], [1], [Eeze has Tizen sensor support enabled])
AM_CONDITIONAL([HAVE_EEZE_TIZEN], [true])
eeze_sensor_tizen="yes"
],
AM_CONDITIONAL([HAVE_EEZE_TIZEN], [false])
)
if test "x$eeze_sensor_tizen" = "xyes";then
PKG_CHECK_MODULES([TIZEN_SENSOR], [capi-system-sensor])
fi
### Checks for header files
@ -230,6 +243,7 @@ EFL_COMPILER_FLAG([-Wshadow])
### Binary
EFL_ENABLE_BIN([eeze-udev-test], ["yes"])
EFL_ENABLE_BIN([eeze_sensor_test], ["yes"])
EFL_ENABLE_BIN([eeze-mount], ["yes"])
EFL_ENABLE_BIN([eeze-disk-ls], ["yes"])
EFL_ENABLE_BIN([eeze-umount], ["yes"])
@ -281,6 +295,9 @@ echo " eeze_scanner.........: ${have_eeze_scanner}"
echo
echo "IPv6...................: ${have_ipv6}"
echo
echo "Sensor.................:"
echo " Tizen................: ${eeze_sensor_tizen}"
echo
echo "Documentation..........: ${build_doc}"
echo
echo "Compilation............: make (or gmake)"

7
legacy/eeze/src/bin/Makefile.am
View File

@ -5,7 +5,7 @@ EEZE_CFLAGS = \
@EEZE_CFLAGS@
noinst_PROGRAMS = @EEZE_UDEV_TEST_PRG@
EXTRA_PROGRAMS = eeze_udev_test eeze_mount eeze_umount eeze_disk_ls eeze_scanner
EXTRA_PROGRAMS = eeze_udev_test eeze_mount eeze_umount eeze_disk_ls eeze_scanner eeze_sensor_test
if HAVE_EEZE_MOUNT
DISK_PROGS = @EEZE_MOUNT_PRG@ @EEZE_UMOUNT_PRG@ @EEZE_DISK_LS_PRG@
@ -23,6 +23,11 @@ eeze_udev_test_SOURCES = eeze_udev_test.c
eeze_udev_test_CPPFLAGS = -I$(top_srcdir)/src/lib @EEZE_CFLAGS@
eeze_udev_test_LDADD = $(top_builddir)/src/lib/libeeze.la @EEZE_LIBS@
bin_PROGRAMS += @EEZE_SENSOR_TEST_PRG@
eeze_sensor_test_SOURCES = eeze_sensor_test.c
eeze_sensor_test_CPPFLAGS = -I$(top_srcdir)/src/lib @EEZE_CFLAGS@
eeze_sensor_test_LDADD = $(top_builddir)/src/lib/libeeze.la @EEZE_LIBS@
if HAVE_EEZE_MOUNT
eeze_mount_SOURCES = eeze_mount.c
eeze_mount_CFLAGS = -I$(top_srcdir)/src/lib $(EEZE_CFLAGS) @LIBMOUNT_CFLAGS@ @ECORE_FILE_CFLAGS@

137
legacy/eeze/src/bin/eeze_sensor_test.c Normal file
View File

@ -0,0 +1,137 @@
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* ifdef HAVE_CONFIG_H */
#include <Eeze.h>
#include <Ecore.h>
#include <stdio.h>
#include <Eeze_Sensor.h>
/*
TODO
if you want a continual flow maybe eeze_sensor_flow_set(sens, EINA_TRUE); (by
default they are alll EINA_FALSE - ie dont provide a flow of events).
*/
static Eina_Bool
event_cb(void *data EINA_UNUSED, int ev_type, void *event)
{
Eeze_Sensor_Obj *sens = NULL;
float x, y, z;
int acc;
unsigned long long timestamp;
sens = event;
if (!sens) printf("can't find sensor!\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
if (ev_type == EEZE_SENSOR_EVENT_ACCELEROMETER)
{
if (!eeze_sensor_xyz_get(sens, &x, &y, &z)) printf("fail get xyz\n");
printf("Accelerometer callback: accuracy %i, x %f, y %f, z %f at time: %lli\n", acc, x, y, z, timestamp);
}
else if (ev_type == EEZE_SENSOR_EVENT_FACEDOWN)
printf("Facedown callback at time: %lli\n", timestamp);
else if (ev_type == EEZE_SENSOR_EVENT_DOUBLETAP)
printf("Doubletap callback at time: %lli\n", timestamp);
else if (ev_type == EEZE_SENSOR_EVENT_SHAKE)
{
if (!eeze_sensor_x_get(sens, &x)) printf("fail get x\n");
printf("Shake callback: accuracy %i, x %f at time: %lli\n", acc, x, timestamp);
}
return ECORE_CALLBACK_PASS_ON;
}
int
main(void)
{
Eeze_Sensor_Obj *sens;
float x, y, z;
int acc;
unsigned long long timestamp;
ecore_init();
eeze_init();
printf("=== Test sync reads: ===\n");
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_MAGNETIC);
if (!sens) printf("can't find an magnetic sensor!\n");
if (!eeze_sensor_xyz_get(sens, &x, &y, &z)) printf("fail get xyz\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Magnetic output: accuracy %i, x %f, y %f, z %f at time: %lli\n", acc, x, y, z, timestamp);
eeze_sensor_free(sens);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_ACCELEROMETER);
if (!sens) printf("can't find an accelerometer sensor!\n");
if (!eeze_sensor_xyz_get(sens, &x, &y, &z)) printf("fail get xyz\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Accel output: accuracy %i, x %f, y %f, z %f at time: %lli\n", acc, x, y, z, timestamp);
eeze_sensor_free(sens);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_ORIENTATION);
if (!sens) printf("can't find an orientation sensor!\n");
if (!eeze_sensor_xyz_get(sens, &x, &y, &z)) printf("fail get xyz\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Orientation output: accuracy %i, x %f, y %f, z %f at time: %lli\n", acc, x, y, z, timestamp);
eeze_sensor_free(sens);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_GYROSCOPE);
if (!sens) printf("can't find an gyroscope sensor!\n");
if (!eeze_sensor_xyz_get(sens, &x, &y, &z)) printf("fail get xyz\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Gyroscope output: accuracy %i, x %f, y %f, z %f at time: %lli\n", acc, x, y, z, timestamp);
eeze_sensor_free(sens);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_PROXIMITY);
if (!sens) printf("can't find an proximity sensor!\n");
if (!eeze_sensor_x_get(sens, &x)) printf("fail get x\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Proximity output: accuracy %i, distance %f at time: %lli\n", acc, x, timestamp);
eeze_sensor_free(sens);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_LIGHT);
if (!sens) printf("can't find an light sensor!\n");
if (!eeze_sensor_x_get(sens, &x)) printf("fail get x\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Light output: accuracy %i, lux %f at time: %lli\n", acc, x, timestamp);
sleep(1);
/* Get updated values on a sensor. Read out is synchronous */
eeze_sensor_read(sens);
if (!sens) printf("can't find an light sensor!\n");
if (!eeze_sensor_x_get(sens, &x)) printf("fail get x\n");
if (!eeze_sensor_accuracy_get(sens, &acc)) printf("fail get accuracy\n");
if (!eeze_sensor_timestamp_get(sens, &timestamp)) printf("fail get timestamp\n");
printf("Light output: accuracy %i, lux %f at time: %lli\n", acc, x, timestamp);
eeze_sensor_free(sens);
printf("=== Test async reads / events: ===\n");
/* Async read request for sensors. You have to register an event handler for it first and then
* request the read out */
ecore_event_handler_add(EEZE_SENSOR_EVENT_ACCELEROMETER, event_cb, NULL);
sens = eeze_sensor_new(EEZE_SENSOR_TYPE_ACCELEROMETER);
eeze_sensor_async_read(sens, NULL);
/* Set callbacks for motion events coming in */
ecore_event_handler_add(EEZE_SENSOR_EVENT_FACEDOWN, event_cb, NULL);
ecore_event_handler_add(EEZE_SENSOR_EVENT_DOUBLETAP, event_cb, NULL);
ecore_main_loop_begin();
eeze_sensor_free(sens);
eeze_shutdown();
ecore_shutdown();
return 0;
}

1
legacy/eeze/src/lib/Eeze.h
View File

@ -30,6 +30,7 @@
@li @ref find Functions which find types of devices
@li @ref disk Disk functions
@li @ref net Net functions
@li @ref sensor Sensor functions
@verbatim
Pants
@endverbatim

250
legacy/eeze/src/lib/Eeze_Sensor.h Normal file
View File

@ -0,0 +1,250 @@
#ifndef EEZE_SENSOR_H
#define EEZE_SENSOR_H
#ifdef EAPI
# undef EAPI
#endif
#ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
#else
# define EAPI
#endif
#include <Eina.h>
/**
* @file Eeze_Sensor.h
* @brief Sensor information
* @since 1.8
*
* Eeze sensor functions allow you to gather sensor information from different sensor sources
* available on the hardware. It supports a plugin architecture to support different hardware
* platforms and devices.
*
* @addtogroup sensor Sensor
* @{
*/
/**
* @enum Eeze_Sensor_Type
* @since 1.8
*
* All sensor types known by Eeze Sensor. This list of types include real physical types like
* proximity or light as well as "aggregated" types like putting a device down on the dsiplay side
* (facedown).
*/
typedef enum
{
EEZE_SENSOR_TYPE_ACCELEROMETER, /**< Accelerometer sensor */
EEZE_SENSOR_TYPE_MAGNETIC, /**< Magnetic sensor */
EEZE_SENSOR_TYPE_ORIENTATION, /**< Orientation sensor */
EEZE_SENSOR_TYPE_GYROSCOPE, /**< Gyroscope sensor */
EEZE_SENSOR_TYPE_LIGHT, /**< Light sensor */
EEZE_SENSOR_TYPE_PROXIMITY, /**< Proximity sensor */
EEZE_SENSOR_TYPE_MOTION_SNAP, /**< Snap motion sensor */
EEZE_SENSOR_TYPE_MOTION_SHAKE, /**< Shake motion sensor */
EEZE_SENSOR_TYPE_MOTION_DOUBLETAP, /**< Doubletap motion sensor */
EEZE_SENSOR_TYPE_MOTION_PANNING, /**< Panning motion sensor */
EEZE_SENSOR_TYPE_MOTION_FACEDOWN, /**< Facedown motion sensor */
/* Non-Tizen from here */
EEZE_SENSOR_TYPE_BAROMETER, /**< Barometer sensor */
EEZE_SENSOR_TYPE_TEMPERATURE, /**< Temperature sensor */
EEZE_SENSOR_TYPE_LAST = 0xFF /**< Last item to mark end of enum */
} Eeze_Sensor_Type;
/**
* @defgroup Sensor_Events Available eeze sensor events
* @brief Sensor events that are emitted from the library as ecore events
*
* Event types used to regoister ecore_event_handler on. These events are used for
* #eeze_sensor_async_read to deliver read out data. It is also used for generated events like
* facedown or shake.
* @since 1.8
* @{
*/
EAPI int EEZE_SENSOR_EVENT_ACCELEROMETER;
EAPI int EEZE_SENSOR_EVENT_MAGNETIC;
EAPI int EEZE_SENSOR_EVENT_ORIENTATION;
EAPI int EEZE_SENSOR_EVENT_GYROSCOPE;
EAPI int EEZE_SENSOR_EVENT_LIGHT;
EAPI int EEZE_SENSOR_EVENT_PROXIMITY;
EAPI int EEZE_SENSOR_EVENT_SNAP;
EAPI int EEZE_SENSOR_EVENT_SHAKE;
EAPI int EEZE_SENSOR_EVENT_DOUBLETAP;
EAPI int EEZE_SENSOR_EVENT_PANNING;
EAPI int EEZE_SENSOR_EVENT_FACEDOWN;
EAPI int EEZE_SENSOR_EVENT_BAROMETER;
EAPI int EEZE_SENSOR_EVENT_TEMPERATURE;
/**@}*/
/**
* @typedef Eeze_Sensor
* @since 1.8
*
* Handle for an Eeze_Sensor.
*/
typedef struct _Eeze_Sensor
{
Eina_Array *modules_array; /**< Array of available runtime modules */
Eina_Hash *modules; /**< Hash with loaded modules */
} Eeze_Sensor;
/**
* @typedef Eeze_Sensor_Obj;
* @since 1.8
*
* Object for a sensor type. Keeps information about the type and holds the data for the accessor
* functions. As this information gets also updated by async reads it might be a good idea to check
* the timestamp value to see when the data has been updated. The timestamp is given as unix epoch
* (seconds since 00:00:00 UTC on 1 January 1970).
*/
typedef struct _Eeze_Sensor_Obj
{
unsigned int type; /**< Sensor type see #Eeze_Sensor_Type */
int accuracy; /**< Accuracy of the sensor value */
float data[3]; /**< Sensor data depending on the sensor type */
unsigned long long timestamp; /**< Timestamp of data read */
Eina_Bool continuous_flow; /**< FUTURE USE: Continuous flow of sensor read out */
} Eeze_Sensor_Obj;
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Create sensor object to operate on.
* @param type Sensor type to create object from.
* @return Sensor object for the given type.
*
* Takes the sensor type and create an object for it to operate on. During this it also does an
* initial sensor data read to fill the sensor data into the object.
* The #eeze_sensor_free function must be used to destroy the object and release its memory.
* @since 1.8
*/
EAPI Eeze_Sensor_Obj *eeze_sensor_new(Eeze_Sensor_Type type);
/**
* @brief Free a sensor object.
* @param sens Sensor object to operate on.
*
* Free an sensor object when it is no longer needed.
* @since 1.8
*/
EAPI void eeze_sensor_free(Eeze_Sensor_Obj *sens);
/**
* @brief Get accuracy from sensor object.
* @param sens Sensor object to operate on.
* @param accuracy Pointer to write accurancy value into.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* Accessor function to get the accurancy property from the sensor object.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_accuracy_get(Eeze_Sensor_Obj *sens, int *accuracy);
/**
* @brief Get data from all three data properties
* @param sens Sensor object to operate on.
* @param x Pointer to write first data property value into.
* @param y Pointer to write second data property value into.
* @param z Pointer to write third data property value into.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* Accessor function to get all three data properties from the sensor object. This is used for sensor
* types that offer all three values. Like acceleromter and magnetic.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_xyz_get(Eeze_Sensor_Obj *sens, float *x, float *y, float *z);
/**
* @brief Get data from first two data properties
* @param sens Sensor object to operate on.
* @param x Pointer to write first data property value into.
* @param y Pointer to write second data property value into.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* Accessor function to get the first two data properties from the sensor object. This is used for sensor
* types that offer two values. Like panning.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_xy_get(Eeze_Sensor_Obj *sens, float *x, float *y);
/**
* @brief Get the data from first data property
* @param sens Sensor object to operate on.
* @param x Pointer to write first data property value into.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* Accessor function to get the first data property from the sensor object. This is used for sensor
* types that only offer one value. Like light or proximity.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_x_get(Eeze_Sensor_Obj *sens, float *x);
/**
* @brief Get timestamp from sensor object.
* @param sens Sensor object to operate on.
* @param timestamp Pointer to write timestamp value into.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* Accessor function to get the timestamp property from the sensor object.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_timestamp_get(Eeze_Sensor_Obj *sens, unsigned long long *timestamp);
/**
* @brief Read out sensor data
* @param sens Sensor object to operate on.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* This function reads sensor data from the device and fills the sensor object with the data. This
* call is synchronuos and blocks until the data is read out and updated in the sensor object.
* For simple applications this is fine and the easiest way to use the API.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_read(Eeze_Sensor_Obj *sens);
/**
* @brief Asynchronous read out sensor data
* @param sens Sensor object to operate on.
* @param user_data Data to pass to the callback function.
* @return EINA_TRUE for success and EINA_FALSE for failure
*
* This function reads sensor data from the device and fills the sensor object with the data. The
* read is done asynchronously and thus does not block after calling. Instead the given callback
* function is called once the read is finished and the object filled.
* @since 1.8
*/
EAPI Eina_Bool eeze_sensor_async_read(Eeze_Sensor_Obj *sens, void *user_data);
/**
* @brief Helper function to access the sensor handle
* @return The sensor handle to operate on
*
* @since 1.8
*/
EAPI Eeze_Sensor *eeze_sensor_handle_get(void);
/**
* @brief Fetch the sensor object by type from the sensor object list
* @param type Sensor type to fetch from the list of sensor objects.
* @return The sensor object matching the given type
*
* @since 1.8
*/
EAPI Eeze_Sensor_Obj *eeze_sensor_obj_get(Eeze_Sensor_Type type);
Eina_Bool eeze_sensor_init(void);
void eeze_sensor_shutdown(void);
#ifdef __cplusplus
}
#endif
/** @} */
#endif

31
legacy/eeze/src/lib/Makefile.am
View File

@ -1,8 +1,9 @@
MAINTAINERCLEANFILES = Makefile.in
AM_CPPFLAGS = @EEZE_CFLAGS@
AM_CPPFLAGS = @EEZE_CFLAGS@ \
-DPACKAGE_LIB_DIR=\"$(libdir)\"
includes_HEADERS = Eeze.h Eeze_Net.h
includes_HEADERS = Eeze.h Eeze_Net.h Eeze_Sensor.h
libeeze_la_SOURCES = \
eeze_main.c \
@ -13,7 +14,8 @@ eeze_udev_private.h \
eeze_udev_private.c \
eeze_udev_syspath.c \
eeze_udev_walk.c \
eeze_udev_watch.c
eeze_udev_watch.c \
eeze_sensor.c
if HAVE_EEZE_MOUNT
AM_CFLAGS = @EEZE_CFLAGS@ @LIBMOUNT_CFLAGS@ @ECORE_FILE_CFLAGS@
@ -35,9 +37,26 @@ endif
lib_LTLIBRARIES = libeeze.la
includesdir = $(includedir)/eeze-@VMAJ@
if HAVE_EEZE_MOUNT
libeeze_la_LIBADD = @EEZE_LIBS@ @LIBMOUNT_LIBS@ @ECORE_FILE_LIBS@
else
libeeze_la_LIBADD = @EEZE_LIBS@
if HAVE_EEZE_MOUNT
libeeze_la_LIBADD += @LIBMOUNT_LIBS@ @ECORE_FILE_LIBS@
endif
libeeze_la_LDFLAGS = -no-undefined -version-info @version_info@ @release_info@
# Sensor modules
pkgdir = $(libdir)/eeze-sensor
if HAVE_EEZE_TIZEN
pkg_LTLIBRARIES = eeze-sensor-tizen.la
eeze_sensor_tizen_la_SOURCES = eeze_sensor_tizen.c
eeze_sensor_tizen_la_LDFLAGS = -no-undefined -module -avoid-version @TIZEN_SENSOR_LIBS@
eeze_sensor_tizen_la_LIBTOOLFLAGS = --tag=disable-static
else
pkg_LTLIBRARIES = eeze-sensor-fake.la
eeze_sensor_fake_la_SOURCES = eeze_sensor_fake.c
eeze_sensor_fake_la_LDFLAGS = -no-undefined -module -avoid-version
eeze_sensor_fake_la_LIBTOOLFLAGS = --tag=disable-static
endif

19
legacy/eeze/src/lib/eeze_main.c
View File

@ -5,6 +5,7 @@
#include <Ecore.h>
#include <Eeze.h>
#include <Eeze_Disk.h>
#include <Eeze_Sensor.h>
#include "eeze_udev_private.h"
#include "eeze_net_private.h"
#include "eeze_disk_private.h"
@ -13,6 +14,7 @@ _udev *udev;
int _eeze_udev_log_dom = -1;
int _eeze_net_log_dom = -1;
int _eeze_sensor_log_dom = -1;
int _eeze_init_count = 0;
static Eeze_Version _version = { VMAJ, VMIN, VMIC, VREV };
@ -40,6 +42,12 @@ eeze_init(void)
goto eina_net_fail;
}
_eeze_sensor_log_dom = eina_log_domain_register("eeze_sensor", EINA_COLOR_BLUE);
if (_eeze_sensor_log_dom < 0)
{
EINA_LOG_ERR("Could not register 'eeze_sensor' log domain.");
goto eina_sensor_fail;
}
if (!ecore_init())
goto ecore_fail;
@ -57,9 +65,16 @@ eeze_init(void)
EINA_LOG_ERR("Error initializing eeze_net subsystems!");
goto net_fail;
}
if (!eeze_sensor_init())
{
EINA_LOG_ERR("Error initializing eeze_sensor subsystems!");
goto sensor_fail;
}
return _eeze_init_count;
sensor_fail:
eeze_net_shutdown();
net_fail:
udev_unref(udev);
fail:
@ -69,6 +84,9 @@ eeze_fail:
#endif
ecore_shutdown();
ecore_fail:
eina_log_domain_unregister(_eeze_sensor_log_dom);
_eeze_sensor_log_dom = -1;
eina_sensor_fail:
eina_log_domain_unregister(_eeze_net_log_dom);
_eeze_net_log_dom = -1;
eina_net_fail:
@ -94,6 +112,7 @@ eeze_shutdown(void)
#ifdef HAVE_EEZE_MOUNT
eeze_disk_shutdown();
#endif
eeze_sensor_shutdown();
eeze_net_shutdown();
ecore_shutdown();
eina_log_domain_unregister(_eeze_udev_log_dom);

276
legacy/eeze/src/lib/eeze_sensor.c Normal file
View File

@ -0,0 +1,276 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <Eina.h>
#include <Ecore.h>
#include <Eeze_Sensor.h>
#include "eeze_sensor_private.h"
Eeze_Sensor *g_handle;
/* Priority order for modules. The one with the highest order of the available ones will be used */
static const char *_module_priority[] = {
"tizen",
"fake",
NULL
};
EAPI Eeze_Sensor *
eeze_sensor_handle_get(void)
{
return g_handle;
}
Eeze_Sensor_Module *
_highest_priority_module_get(void)
{
Eeze_Sensor_Module *module = NULL;
int i = 0;
while (_module_priority[i] != NULL)
{
module = eina_hash_find(g_handle->modules, _module_priority[i]);
if (module) return module;
i++;
}
return NULL;
}
EAPI Eeze_Sensor_Obj *
eeze_sensor_obj_get(Eeze_Sensor_Type sensor_type)
{
Eina_List *l;
Eeze_Sensor_Obj *obj;
Eeze_Sensor_Module *module;
module = _highest_priority_module_get();
if (!module) return NULL;
EINA_LIST_FOREACH(module->sensor_list, l, obj)
{
if (obj->type == sensor_type)
{
return obj;
}
}
return NULL;
}
static void
eeze_sensor_modules_load(void)
{
/* Check for available runtime modules and load them */
g_handle->modules_array = eina_module_list_get(NULL, PACKAGE_LIB_DIR "/eeze-sensor/", 0, NULL, NULL);
/* FIXME check for modules also in HOME and other locations */
if (!g_handle->modules_array)
{
ERR("No modules found!");
return;
}
eina_module_list_load(g_handle->modules_array);
}
static void
eeze_sensor_modules_unload(void)
{
if (!g_handle->modules_array) return;
eina_module_list_unload(g_handle->modules_array);
eina_module_list_free(g_handle->modules_array);
eina_array_free(g_handle->modules_array);
g_handle->modules_array = NULL;
}
Eina_Bool
eeze_sensor_module_register(const char *name, Eeze_Sensor_Module *mod)
{
Eeze_Sensor_Module *module = NULL;
if (!mod) return EINA_FALSE;
module = calloc(1, sizeof(Eeze_Sensor_Module));
if (!module) return EINA_FALSE;
module = mod;
if (!module->init) return EINA_FALSE;
if (!(module->init())) return EINA_FALSE;
INF("Registered module %s", name);
return eina_hash_add(g_handle->modules, name, module);
}
Eina_Bool
eeze_sensor_module_unregister(const char *name)
{
DBG("Unregister module %s", name);
Eeze_Sensor_Module *module = NULL;
module = eina_hash_find(g_handle->modules, name);
if (module->shutdown)
module->shutdown();
return eina_hash_del(g_handle->modules, name, NULL);
}
EAPI Eeze_Sensor_Obj *
eeze_sensor_new(Eeze_Sensor_Type type)
{
Eeze_Sensor_Obj *sens;
Eeze_Sensor *handle;
Eeze_Sensor_Module *module = NULL;
handle = eeze_sensor_handle_get();
if (!handle) return NULL;
sens = calloc(1, sizeof(Eeze_Sensor_Obj));
if (!sens) return NULL;
sens = eeze_sensor_obj_get(type);
module = _highest_priority_module_get();
if (!module) return EINA_FALSE;
if (!module->read) return NULL;
if (module->read(sens->type, sens))
{
return sens;
}
else
return NULL;
}
EAPI void
eeze_sensor_free(Eeze_Sensor_Obj *sens)
{
if (!sens) return;
free(sens);
}
EAPI Eina_Bool
eeze_sensor_accuracy_get(Eeze_Sensor_Obj *sens, int *accuracy)
{
if (!sens) return EINA_FALSE;
*accuracy = sens->accuracy;
return EINA_TRUE;
}
EAPI Eina_Bool
eeze_sensor_xyz_get(Eeze_Sensor_Obj *sens, float *x, float *y, float *z)
{
if (!sens) return EINA_FALSE;
*x = sens->data[0];
*y = sens->data[1];
*z = sens->data[2];
return EINA_TRUE;
}
EAPI Eina_Bool
eeze_sensor_xy_get(Eeze_Sensor_Obj *sens, float *x, float *y)
{
if (!sens) return EINA_FALSE;
*x = sens->data[0];
*y = sens->data[1];
return EINA_TRUE;
}
EAPI Eina_Bool
eeze_sensor_x_get(Eeze_Sensor_Obj *sens, float *x)
{
if (!sens) return EINA_FALSE;
*x = sens->data[0];
return EINA_TRUE;
}
EAPI Eina_Bool
eeze_sensor_timestamp_get(Eeze_Sensor_Obj *sens, unsigned long long *timestamp)
{
if (!sens) return EINA_FALSE;
*timestamp = sens->timestamp;
return EINA_TRUE;
}
EAPI Eina_Bool
eeze_sensor_read(Eeze_Sensor_Obj *sens)
{
Eeze_Sensor *handle = NULL;
Eeze_Sensor_Module *module = NULL;
if (!sens) return EINA_FALSE;
handle = eeze_sensor_handle_get();
if (!handle) return EINA_FALSE;
module = _highest_priority_module_get();
if (!module) return EINA_FALSE;
if (module->read)
return module->read(sens->type, sens);
return EINA_FALSE;
}
EAPI Eina_Bool
eeze_sensor_async_read(Eeze_Sensor_Obj *sens, void *user_data)
{
Eeze_Sensor_Module *module = NULL;
Eeze_Sensor *handle = NULL;
handle = eeze_sensor_handle_get();
if (!handle) return EINA_FALSE;
module = _highest_priority_module_get();
if (!module) return EINA_FALSE;
if (module->async_read)
return module->async_read(sens->type, user_data);
return EINA_FALSE;
}
void
eeze_sensor_shutdown(void)
{
eeze_sensor_modules_unload();
free(g_handle);
g_handle = NULL;
eina_shutdown();
}
Eina_Bool
eeze_sensor_init(void)
{
if (!eina_init()) return EINA_FALSE;
g_handle = calloc(1, sizeof(Eeze_Sensor));
if (!g_handle) return EINA_FALSE;
g_handle->modules_array = NULL;
g_handle->modules = eina_hash_string_small_new(NULL);
if (!g_handle->modules) return EINA_FALSE;
EEZE_SENSOR_EVENT_SNAP = ecore_event_type_new();
EEZE_SENSOR_EVENT_SHAKE = ecore_event_type_new();
EEZE_SENSOR_EVENT_DOUBLETAP = ecore_event_type_new();
EEZE_SENSOR_EVENT_PANNING = ecore_event_type_new();
EEZE_SENSOR_EVENT_FACEDOWN = ecore_event_type_new();
EEZE_SENSOR_EVENT_ACCELEROMETER = ecore_event_type_new();
eeze_sensor_modules_load();
return EINA_TRUE;
}

166
legacy/eeze/src/lib/eeze_sensor_fake.c Normal file
View File

@ -0,0 +1,166 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <time.h>
#include <Eina.h>
#include <Ecore.h>
#include <Eeze_Sensor.h>
#include "eeze_sensor_private.h"
Eeze_Sensor_Module *esensor_module;
Eina_Bool
fake_init(void)
{
/* Set a list with fake sensors */
Eeze_Sensor_Type type;
for (type = 0; type <= EEZE_SENSOR_TYPE_LAST; type++)
{
Eeze_Sensor_Obj *obj = calloc(1, sizeof(Eeze_Sensor_Obj));
obj->type = type;
esensor_module->sensor_list = eina_list_append(esensor_module->sensor_list, obj);
}
return EINA_TRUE;
}
Eina_Bool
fake_shutdown(void)
{
return EINA_TRUE;
}
Eina_Bool
fake_read(Eeze_Sensor_Type sensor_type, Eeze_Sensor_Obj *lobj)
{
Eeze_Sensor_Obj *obj;
obj = eeze_sensor_obj_get(sensor_type);
if (obj == NULL)
{
ERR("No matching sensor object found in list");
return EINA_FALSE;
}
switch (sensor_type)
{
case EEZE_SENSOR_TYPE_ACCELEROMETER:
case EEZE_SENSOR_TYPE_MAGNETIC:
case EEZE_SENSOR_TYPE_ORIENTATION:
case EEZE_SENSOR_TYPE_GYROSCOPE:
obj->accuracy = 0;
obj->data[0] = 7;
obj->data[1] = 23;
obj->data[2] = 42;
obj->timestamp = time(NULL);
break;
case EEZE_SENSOR_TYPE_LIGHT:
case EEZE_SENSOR_TYPE_PROXIMITY:
case EEZE_SENSOR_TYPE_BAROMETER:
case EEZE_SENSOR_TYPE_TEMPERATURE:
obj->accuracy = 0;
obj->data[0] = 7;
obj->timestamp = time(NULL);
break;
default:
ERR("Not possible to read from this sensor type.");
return EINA_FALSE;
}
memcpy(lobj, obj, sizeof(Eeze_Sensor_Obj));
return EINA_TRUE;
}
Eina_Bool
fake_async_read(Eeze_Sensor_Type sensor_type, void *user_data EINA_UNUSED)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(sensor_type);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return EINA_FALSE;
}
switch (sensor_type)
{
case EEZE_SENSOR_TYPE_ACCELEROMETER:
ecore_event_add(EEZE_SENSOR_EVENT_ACCELEROMETER, obj, NULL, NULL);
case EEZE_SENSOR_TYPE_MAGNETIC:
case EEZE_SENSOR_TYPE_ORIENTATION:
case EEZE_SENSOR_TYPE_GYROSCOPE:
obj->accuracy = 0;
obj->data[0] = 7;
obj->data[1] = 23;
obj->data[2] = 42;
obj->timestamp = time(NULL);
break;
case EEZE_SENSOR_TYPE_LIGHT:
case EEZE_SENSOR_TYPE_PROXIMITY:
case EEZE_SENSOR_TYPE_BAROMETER:
case EEZE_SENSOR_TYPE_TEMPERATURE:
obj->accuracy = 0;
obj->data[0] = 7;
obj->timestamp = time(NULL);
break;
case EEZE_SENSOR_TYPE_MOTION_SNAP:
break;
case EEZE_SENSOR_TYPE_MOTION_SHAKE:
break;
case EEZE_SENSOR_TYPE_MOTION_PANNING:
break;
default:
ERR("Not possible to set a callback for this sensor type.");
return EINA_FALSE;
}
return EINA_TRUE;
}
Eina_Bool
sensor_fake_init(void)
{
/* Check to avoid multi-init */
if (esensor_module) return EINA_FALSE;
/* Set module function pointer to allow calls into the module */
esensor_module = calloc(1, sizeof(Eeze_Sensor_Module));
if (!esensor_module) return EINA_FALSE;
esensor_module->init = fake_init;
esensor_module->shutdown = fake_shutdown;
esensor_module->read = fake_read;
esensor_module->async_read = fake_async_read;
if (!eeze_sensor_module_register("fake", esensor_module))
{
ERR("Failed to register fake module.");
return EINA_FALSE;
}
return EINA_TRUE;
}
void
sensor_fake_shutdown(void)
{
eeze_sensor_module_unregister("fake");
free(esensor_module);
esensor_module = NULL;
}
EINA_MODULE_INIT(sensor_fake_init);
EINA_MODULE_SHUTDOWN(sensor_fake_shutdown);

53
legacy/eeze/src/lib/eeze_sensor_private.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef EEZE_SENSOR_PRIVATE_H
#define EEZE_SENSOR_PRIVATE_H
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <Eeze_Sensor.h>
#ifndef EEZE_SENSOR_COLOR_DEFAULT
#define EEZE_SENSOR_COLOR_DEFAULT EINA_COLOR_BLUE
#endif
extern int _eeze_sensor_log_dom;
#ifdef CRI
#undef CRI
#endif
#ifdef ERR
#undef ERR
#endif
#ifdef INF
#undef INF
#endif
#ifdef WARN
#undef WARN
#endif
#ifdef DBG
#undef DBG
#endif
#define CRI(...) EINA_LOG_DOM_CRIT(_eeze_sensor_log_dom, __VA_ARGS__)
#define DBG(...) EINA_LOG_DOM_DBG(_eeze_sensor_log_dom, __VA_ARGS__)
#define INF(...) EINA_LOG_DOM_INFO(_eeze_sensor_log_dom, __VA_ARGS__)
#define WARN(...) EINA_LOG_DOM_WARN(_eeze_sensor_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_eeze_sensor_log_dom, __VA_ARGS__)
/**
* @typedef Eeze_Sensor_Module;
* @since 1.8
*
* Loadable module data structure.
*/
typedef struct _Eeze_Sensor_Module
{
Eina_Bool (*init)(void); /**< Pointer to module init function */
Eina_Bool (*shutdown)(void); /**< Pointer to module shutdown function */
Eina_Bool (*async_read)(Eeze_Sensor_Type sensor_type, void *user_data); /**< Pointer to module async_read function */
Eina_Bool (*read)(Eeze_Sensor_Type sensor_type, Eeze_Sensor_Obj *obj); /**< Pointer to module read function */
Eina_List *sensor_list; /**< List of sensor objects attached to the module */
} Eeze_Sensor_Module;
Eina_Bool eeze_sensor_module_register(const char *name, Eeze_Sensor_Module *mod);
Eina_Bool eeze_sensor_module_unregister(const char *name);
#endif // EEZE_SENSOR_PRIVATE_H

763
legacy/eeze/src/lib/eeze_sensor_tizen.c Normal file
View File

@ -0,0 +1,763 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <system/sensors.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <Eina.h>
#include <Eeze_Sensor.h>
#include "eeze_sensor_private.h"
Eeze_Sensor_Module *esensor_module;
sensor_h sensor_handle; // Tizen sensor handle
static sensor_type_e
eeze_to_tizen(Eeze_Sensor_Type type)
{
switch (type)
{
case EEZE_SENSOR_TYPE_ACCELEROMETER:
return SENSOR_ACCELEROMETER;
case EEZE_SENSOR_TYPE_MAGNETIC:
return SENSOR_MAGNETIC;
case EEZE_SENSOR_TYPE_ORIENTATION:
return SENSOR_ORIENTATION;
case EEZE_SENSOR_TYPE_GYROSCOPE:
return SENSOR_GYROSCOPE;
case EEZE_SENSOR_TYPE_LIGHT:
return SENSOR_LIGHT;
case EEZE_SENSOR_TYPE_PROXIMITY:
return SENSOR_PROXIMITY;
case EEZE_SENSOR_TYPE_MOTION_SNAP:
return SENSOR_MOTION_SNAP;
case EEZE_SENSOR_TYPE_MOTION_SHAKE:
return SENSOR_MOTION_SHAKE;
case EEZE_SENSOR_TYPE_MOTION_DOUBLETAP:
return SENSOR_MOTION_DOUBLETAP;
case EEZE_SENSOR_TYPE_MOTION_PANNING:
return SENSOR_MOTION_PANNING;
case EEZE_SENSOR_TYPE_MOTION_FACEDOWN:
return SENSOR_MOTION_FACEDOWN;
default:
ERR("No matching Tizen sensor type available.");
return -1;
}
}
void
accelerometer_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_ACCELEROMETER);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_ACCELEROMETER, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_ACCELEROMETER));
}
void
magnetic_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MAGNETIC);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_MAGNETIC, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MAGNETIC));
}
void
orientation_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float azimuth, float pitch, float roll, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_ORIENTATION);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = azimuth;
obj->data[1] = pitch;
obj->data[2] = roll;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_ORIENTATION, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_ORIENTATION));
}
void
gyroscope_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_GYROSCOPE);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_GYROSCOPE, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_GYROSCOPE));
}
void
light_cb(unsigned long long timestamp, float lux, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_LIGHT);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = 0;
obj->data[0] = lux;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_LIGHT, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_LIGHT));
}
void
proximity_cb(unsigned long long timestamp, float distance, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_PROXIMITY);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = 0;
obj->data[0] = distance;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_PROXIMITY, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_PROXIMITY));
}
void
snap_cb(unsigned long long timestamp, sensor_motion_snap_e snap, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_SNAP);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = snap;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_SNAP, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_SNAP));
}
void
shake_cb(unsigned long long timestamp, sensor_motion_shake_e shake, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_SHAKE);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = shake;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_SHAKE, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_SHAKE));
}
void
panning_cb(unsigned long long timestamp, int x, int y, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_PANNING);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = x;
obj->data[1] = y;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_PANNING, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_PANNING));
}
void
facedown_cb(unsigned long long timestamp, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_FACEDOWN);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_FACEDOWN, obj, NULL, NULL);
}
void
doubletap_cb(unsigned long long timestamp, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_DOUBLETAP);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_DOUBLETAP, obj, NULL, NULL);
}
void
accelerometer_read_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_accelerometer_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_ACCELEROMETER);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_ACCELEROMETER, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_ACCELEROMETER));
}
void
magnetic_read_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_magnetic_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MAGNETIC);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_MAGNETIC, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MAGNETIC));
}
void
orientation_read_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float azimuth, float pitch, float roll, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_orientation_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_ORIENTATION);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = azimuth;
obj->data[1] = pitch;
obj->data[2] = roll;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_ORIENTATION, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_ORIENTATION));
}
void
gyroscope_read_cb(unsigned long long timestamp, sensor_data_accuracy_e accuracy, float x, float y, float z, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_gyroscope_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_GYROSCOPE);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_GYROSCOPE, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_GYROSCOPE));
}
void
light_read_cb(unsigned long long timestamp, float lux, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_light_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_LIGHT);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = 0;
obj->data[0] = lux;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_LIGHT, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_LIGHT));
}
void
proximity_read_cb(unsigned long long timestamp, float distance, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_proximity_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_PROXIMITY);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->accuracy = 0;
obj->data[0] = distance;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_PROXIMITY, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_PROXIMITY));
}
void
snap_read_cb(unsigned long long timestamp, sensor_motion_snap_e snap, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_motion_snap_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_SNAP);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = snap;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_SNAP, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_SNAP));
}
void
shake_read_cb(unsigned long long timestamp, sensor_motion_shake_e shake, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_motion_shake_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_SHAKE);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = shake;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_SHAKE, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_SHAKE));
}
void
panning_read_cb(unsigned long long timestamp, int x, int y, void *user_data)
{
Eeze_Sensor_Obj *obj = NULL;
sensor_motion_panning_unset_cb(sensor_handle);
obj = eeze_sensor_obj_get(EEZE_SENSOR_TYPE_MOTION_PANNING);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return;
}
obj->data[0] = x;
obj->data[1] = y;
obj->timestamp = timestamp;
ecore_event_add(EEZE_SENSOR_EVENT_PANNING, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_TYPE_MOTION_PANNING));
}
void
facedown_read_cb(unsigned long long timestamp, void *user_data)
{
sensor_motion_facedown_unset_cb(sensor_handle);
ecore_event_add(EEZE_SENSOR_EVENT_FACEDOWN, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_MOTION_TYPE_FACEDOWN));
}
void
doubletap_read_cb(unsigned long long timestamp, void *user_data)
{
sensor_motion_doubletap_unset_cb(sensor_handle);
ecore_event_add(EEZE_SENSOR_EVENT_DOUBLETAP, obj, NULL, NULL);
sensor_stop(sensor_handle, eeze_to_tizen(EEZE_SENSOR_MOTION_TYPE_DOUBLETAP));
}
Eina_Bool
eeze_sensor_tizen_read(Eeze_Sensor_Type sensor_type, Eeze_Sensor_Obj *lobj)
{
sensor_data_accuracy_e accuracy;
float x, y, z;
float azimuth, pitch, roll, lux, distance;
bool supported;
sensor_type_e type;
Eeze_Sensor_Obj *obj;
type = eeze_to_tizen(sensor_type);
sensor_is_supported(type, &supported);
if (!supported)
{
ERR("Sensor type %d not available on this device.", type);
return EINA_FALSE;
}
sensor_start(handle->sensor_handle, type);
obj = eeze_sensor_obj_get(sensor_type);
if (obj == NULL)
{
ERR("No matching sensor object found in list.");
return EINA_FALSE;
}
switch (type)
{
case SENSOR_ACCELEROMETER:
sensor_accelerometer_read_data(sensor_handle, &accuracy, &x, &y, &z);
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
break;
case SENSOR_MAGNETIC:
sensor_magnetic_read_data(sensor_handle, &accuracy, &x, &y, &z);
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
break;
case SENSOR_ORIENTATION:
sensor_orientation_read_data(sensor_handle, &accuracy, &azimuth, &pitch, &roll);
obj->accuracy = accuracy;
obj->data[0] = azimuth;
obj->data[1] = pitch;
obj->data[2] = roll;
break;
case SENSOR_GYROSCOPE:
sensor_gyroscope_read_data(sensor_handle, &accuracy, &x, &y, &z);
obj->accuracy = accuracy;
obj->data[0] = x;
obj->data[1] = y;
obj->data[2] = z;
break;
case SENSOR_LIGHT:
sensor_light_read_data(sensor_handle, &lux);
obj->accuracy = 0;
obj->data[0] = lux;
break;
case SENSOR_PROXIMITY:
sensor_proximity_read_data(sensor_handle, &distance);
obj->accuracy = 0;
obj->data[0] = distance;
break;
default:
ERR("Not possible to read from this sensor type.");
return EINA_FALSE;
}
memcpy(lobj, obj, sizeof(Eeze_Sensor_Obj));
sensor_stop(sensor_handle, type);
return EINA_TRUE;
}
// FIXME ho to handle this without explicit callback setting
#if 0
Eina_Bool
eeze_sensor_tizen_cb_set(Eeze_Sensor *handle, Eeze_Sensor_Type sensor_type, void *cb_function, void *user_data)
{
sensor_type_e type;
type = eeze_to_tizen(sensor_type);
handle->cb_function = cb_function;
sensor_start(handle->sensor_handle, type);
switch (type)
{
case SENSOR_ACCELEROMETER:
sensor_accelerometer_set_cb(handle->sensor_handle, 0, accelerometer_cb, handle);
break;
case SENSOR_MAGNETIC:
sensor_magnetic_set_cb(handle->sensor_handle, 0, magnetic_cb, handle);
break;
case SENSOR_ORIENTATION:
sensor_orientation_set_cb(handle->sensor_handle, 0, orientation_cb, handle);
break;
case SENSOR_GYROSCOPE:
sensor_gyroscope_set_cb(handle->sensor_handle, 0, gyroscope_cb, handle);
break;
case SENSOR_LIGHT:
sensor_light_set_cb(handle->sensor_handle, 0, light_cb, handle);
break;
case SENSOR_PROXIMITY:
sensor_proximity_set_cb(handle->sensor_handle, 0, proximity_cb, handle);
break;
case SENSOR_MOTION_SNAP:
sensor_motion_snap_set_cb(handle->sensor_handle, snap_cb, handle);
break;
case SENSOR_MOTION_SHAKE:
sensor_motion_shake_set_cb(handle->sensor_handle, shake_cb, handle);
break;
case SENSOR_MOTION_PANNING:
sensor_motion_panning_set_cb(handle->sensor_handle, panning_cb, handle);
break;
default:
ERR("Not possible to set a callback for this sensor type.");
return EINA_FALSE;
}
return EINA_TRUE;
}
#endif
Eina_Bool
eeze_sensor_tizen_async_read(Eeze_Sensor_Type sensor_type, void *user_data)
{
sensor_type_e type;
type = eeze_to_tizen(sensor_type);
sensor_start(sensor_handle, type);
switch (type)
{
case SENSOR_ACCELEROMETER:
sensor_accelerometer_set_cb(sensor_handle, 0, accelerometer_read_cb, NULL);
break;
case SENSOR_MAGNETIC:
sensor_magnetic_set_cb(sensor_handle, 0, magnetic_read_cb, NULL);
break;
case SENSOR_ORIENTATION:
sensor_orientation_set_cb(sensor_handle, 0, orientation_read_cb, NULL);
break;
case SENSOR_GYROSCOPE:
sensor_gyroscope_set_cb(sensor_handle, 0, gyroscope_read_cb, NULL);
break;
case SENSOR_LIGHT:
sensor_light_set_cb(sensor_handle, 0, light_read_cb, NULL);
break;
case SENSOR_PROXIMITY:
sensor_proximity_set_cb(sensor_handle, 0, proximity_read_cb, NULL);
break;
case SENSOR_MOTION_SNAP:
sensor_motion_snap_set_cb(sensor_handle, snap_read_cb, NULL);
break;
case SENSOR_MOTION_SHAKE:
sensor_motion_shake_set_cb(sensor_handle, shake_read_cb, NULL);
break;
case SENSOR_MOTION_DOUBLETAP:
sensor_motion_doubletap_set_cb(sensor_handle, doubletap_read_cb, NULL);
break;
case SENSOR_MOTION_PANNING:
sensor_motion_panning_set_cb(sensor_handle, panning_read_cb, NULL);
break;
case SENSOR_MOTION_FACEDOWN:
sensor_motion_facedown_set_cb(sensor_handle, facedown_read_cb, NULL);
break;
default:
ERR("Not possible to set a callback for this sensor type.");
return EINA_FALSE;
}
return EINA_TRUE;
}
static void
eeze_sensor_tizen_sensors_find(void)
{
sensor_type_e type;
bool supported = 0;
/* FIXME: Make this safe against changes in the enum. But how? */
for (type = SENSOR_ACCELEROMETER; type <= SENSOR_MOTION_FACEDOWN; type++)
{
sensor_is_supported(type, &supported);
if (supported)
{
Eeze_Sensor_Obj *obj = calloc(1, sizeof(Eeze_Sensor_Obj));
obj->type = type;
esensor_module->sensor_list = eina_list_append(esensor_module->sensor_list, obj);
}
}
}
Eina_Bool
eeze_sensor_tizen_shutdown(void)
{
Eeze_Sensor_Obj *obj;
EINA_LIST_FREE(esensor_module->sensor_list, obj)
free(obj);
sensor_start(sensor_handle, SENSOR_MOTION_FACEDOWN);
sensor_start(sensor_handle, SENSOR_MOTION_DOUBLETAP);
sensor_start(sensor_handle, SENSOR_MOTION_SHAKE);
if (sensor_destroy(sensor_handle) != 0)
{
ERR("Failing to destroy sensor handle.");
return EINA_FALSE;
}
return EINA_TRUE;
}
Eina_Bool
eeze_sensor_tizen_init(void)
{
if (sensor_create(&sensor_handle) != 0)
{
ERR("Failing to create sensor handle.");
return EINA_FALSE;
}
eeze_sensor_tizen_sensors_find();
/* FIXME add other motion events in here */
sensor_start(sensor_handle, SENSOR_MOTION_FACEDOWN);
sensor_start(sensor_handle, SENSOR_MOTION_DOUBLETAP);
sensor_motion_doubletap_set_cb(sensor_handle, doubletap_cb, handle);
sensor_motion_facedown_set_cb(sensor_handle, facedown_cb, handle);
return EINA_TRUE;
}
Eina_Bool
sensor_tizen_init(void)
{
/* Check to avoid multi-init */
if (esensor_module) return EINA_FALSE;
/* Set module function pointer to allow calls into the module */
esensor_module = calloc(1, sizeof(Eeze_Sensor_Module));
if (!esensor_module) return EINA_FALSE;
esensor_module->init = eeze_sensor_tizen_init;
esensor_module->shutdown = eeze_sensor_tizen_shutdown;
esensor_module->read = eeze_sensor_tizen_read;
esensor_module->async_read = eeze_sensor_tizen_async_read;
if (!eeze_sensor_module_register("tizen", esensor_module))
{
ERR("Failed to register tizen module");
return EINA_FALSE;
}
return EINA_TRUE;
}
void
sensor_tizen_shutdown(void)
{
sensor_stop(sensor_handle, SENSOR_MOTION_FACEDOWN);
sensor_stop(sensor_handle, SENSOR_MOTION_DOUBLETAP);
eeze_sensor_module_unregister("tizen");
free(esensor_module);
esensor_module = NULL;
}
EINA_MODULE_INIT(sensor_tizen_init);
EINA_MODULE_SHUTDOWN(sensor_tizen_shutdown);