# The sensor support is implemented in android_app module, so the user can enable the type of sensor he wants to use.
# There is an example of how you can use the android sensors in nit/examples/mnit_ballz :
#
# The sensor support is implemented in android_app module, so the user can enable the type of sensor he wants to use.
# There is an example of how you can use the android sensors in nit/examples/mnit_ballz :
#
-# ~~~~
-# var app = new MyApp
-# app.sensors_support_enabled = true
-# app.accelerometer.enabled = true
-# app.accelerometer.eventrate = 10000
-# app.magnetic_field.enabled = true
-# app.gyroscope.enabled = true
-# app.light.enabled = true
-# app.proximity.enabled = true
-# app.main_loop
+# ~~~~nitish
+# #FIXME rewrite the example
+# redef class App
+# sensors_support_enabled = true
+# accelerometer.enabled = true
+# accelerometer.eventrate = 10000
+# magnetic_field.enabled = true
+# gyroscope.enabled = true
+# light.enabled = true
+# proximity.enabled = true
+# end
-# In this example, we enable the sensor support, then enable all types of sensors supported, before running the app.
-# The result is you get all type of SensorEvent (ASensorAccelerometer, ASensorMagneticField ...) in the input method of your app
+# In this example, we enable the sensor support, then enable all types of sensors supported by the API, directly with `App` attributes
+# As a result, you get all type of SensorEvent (ASensorAccelerometer, ASensorMagneticField ...) in the `input` callback of `App`
extern class ASensorType `{int`}
new accelerometer: ASensorType `{return ASENSOR_TYPE_ACCELEROMETER;`}
extern class ASensorType `{int`}
new accelerometer: ASensorType `{return ASENSOR_TYPE_ACCELEROMETER;`}
return list;
`}
# Create a new sensor event queue and associate it with a looper
fun create_event_queue(app: NativeAppGlue): ASensorEventQueue `{
return list;
`}
# Create a new sensor event queue and associate it with a looper
fun create_event_queue(app: NativeAppGlue): ASensorEventQueue `{
- return ASensorManager_createEventQueue(recv, app->looper, LOOPER_ID_USER, NULL, NULL);
+ return ASensorManager_createEventQueue(self, app->looper, LOOPER_ID_USER, NULL, NULL);
`}
# Returns the default sensor of the given type
fun get_default_sensor(sensortype: ASensorType): ASensor `{
`}
# Returns the default sensor of the given type
fun get_default_sensor(sensortype: ASensorType): ASensor `{
`}
# Destroys the event queue and free all resources associated to it
fun destroy_event_queue(queue: ASensorEventQueue) `{
`}
# Destroys the event queue and free all resources associated to it
fun destroy_event_queue(queue: ASensorEventQueue) `{
# Enable the selected sensor, returns a negative value on error
fun enable_sensor(sensor: ASensor): Int `{
# Enable the selected sensor, returns a negative value on error
fun enable_sensor(sensor: ASensor): Int `{
`}
# Disable the selected sensor, returns a negative value on error
fun disable_sensor(sensor: ASensor): Int `{
`}
# Disable the selected sensor, returns a negative value on error
fun disable_sensor(sensor: ASensor): Int `{
`}
# Set the delivery rate of events in microseconds for the given sensor
fun set_event_rate(sensor: ASensor, usec: Int): Int `{
`}
# Set the delivery rate of events in microseconds for the given sensor
fun set_event_rate(sensor: ASensor, usec: Int): Int `{
`}
# Returns 1 if the queue has events, 0 if it does not have events,
# and a negative value if there is an error
fun has_events: Int `{
`}
# Returns 1 if the queue has events, 0 if it does not have events,
# and a negative value if there is an error
fun has_events: Int `{
`}
# Returns the next available events from the queue.
# Returns a negative value if no events are available or an error has occured
# otherwise the number of events returned
fun get_events(events: ASensorEvents, count: Int): Int `{
`}
# Returns the next available events from the queue.
# Returns a negative value if no events are available or an error has occured
# otherwise the number of events returned
fun get_events(events: ASensorEvents, count: Int): Int `{
- fun name: NativeString `{return (char*)ASensor_getName(recv);`}
- fun vendor: NativeString `{return (char*)ASensor_getVendor(recv);`}
- fun sensor_type: ASensorType `{return ASensor_getType(recv);`}
- fun resolution: Float `{return ASensor_getResolution(recv);`}
- fun min_delay: Int `{return ASensor_getMinDelay(recv);`}
+ fun name: NativeString `{return (char*)ASensor_getName(self);`}
+ fun vendor: NativeString `{return (char*)ASensor_getVendor(self);`}
+ fun sensor_type: ASensorType `{return ASensor_getType(self);`}
+ fun resolution: Float `{return ASensor_getResolution(self);`}
+ fun min_delay: Int `{return ASensor_getMinDelay(self);`}
- fun version: Int `{return recv->version;`}
- fun sensor: ASensor `{return (ASensorRef)recv->sensor;`}
- fun sensor_type: ASensorType `{return recv->type;`}
- fun timestamp: Int `{return recv->timestamp;`}
+ fun version: Int `{return self->version;`}
+ fun sensor: ASensor `{return (ASensorRef)self->sensor;`}
+ fun sensor_type: ASensorType `{return self->type;`}
+ fun timestamp: Int `{return self->timestamp;`}
- fun temperature: Float `{return recv->temperature;`}
- fun pressure: Float `{return recv->pressure;`}
- fun data: Pointer `{return recv->data;`}
- fun vector: ASensorVector `{return &(recv->vector);`}
- fun acceleration: ASensorVector `{return &(recv->acceleration);`}
- fun magnetic: ASensorVector `{return &(recv->magnetic);`}
+ fun temperature: Float `{return self->temperature;`}
+ fun pressure: Float `{return self->pressure;`}
+ fun data: Pointer `{return self->data;`}
+ fun vector: ASensorVector `{return &(self->vector);`}
+ fun acceleration: ASensorVector `{return &(self->acceleration);`}
+ fun magnetic: ASensorVector `{return &(self->magnetic);`}
end
# Extern class referencing a ASensorVector, attribute of ASensorRef
extern class ASensorVector `{ASensorVector*`}
end
# Extern class referencing a ASensorVector, attribute of ASensorRef
extern class ASensorVector `{ASensorVector*`}
- fun v: Pointer `{return recv->v;`}
- fun x: Float `{ return recv->x;`}
- fun y: Float `{return recv->y;`}
- fun z: Float `{return recv->z;`}
- fun azimuth: Float `{return recv->azimuth;`}
- fun pitch: Float `{return recv->pitch;`}
- fun roll: Float `{return recv->roll;`}
- fun status: Int `{return recv->status;`}
- fun reserved: Pointer `{return recv->reserved;`}
+ fun v: Pointer `{return self->v;`}
+ fun x: Float `{ return self->x;`}
+ fun y: Float `{return self->y;`}
+ fun z: Float `{return self->z;`}
+ fun azimuth: Float `{return self->azimuth;`}
+ fun pitch: Float `{return self->pitch;`}
+ fun roll: Float `{return self->roll;`}
+ fun status: Int `{return self->status;`}
+ fun reserved: Pointer `{return self->reserved;`}
end
# Sensor event returned by the Accelerometer sensor
extern class ASensorAccelerometer `{ASensorEvent*`}
super ASensorEvent
end
# Sensor event returned by the Accelerometer sensor
extern class ASensorAccelerometer `{ASensorEvent*`}
super ASensorEvent
- fun x: Float `{return recv->acceleration.x;`}
- fun y: Float `{return recv->acceleration.y;`}
- fun z: Float `{return recv->acceleration.z;`}
+ fun x: Float `{return self->acceleration.x;`}
+ fun y: Float `{return self->acceleration.y;`}
+ fun z: Float `{return self->acceleration.z;`}
end
# Sensor event returned by the Magnetic Field sensor
extern class ASensorMagneticField `{ASensorEvent*`}
super ASensorEvent
end
# Sensor event returned by the Magnetic Field sensor
extern class ASensorMagneticField `{ASensorEvent*`}
super ASensorEvent
- fun x: Float `{return recv->magnetic.x;`}
- fun y: Float `{return recv->magnetic.y;`}
- fun z: Float `{ return recv->magnetic.z;`}
+ fun x: Float `{return self->magnetic.x;`}
+ fun y: Float `{return self->magnetic.y;`}
+ fun z: Float `{ return self->magnetic.z;`}
- fun x: Float `{return recv->vector.x;`}
- fun y: Float `{return recv->vector.y;`}
- fun z: Float `{return recv->vector.y;`}
+ fun x: Float `{return self->vector.x;`}
+ fun y: Float `{return self->vector.y;`}
+ fun z: Float `{return self->vector.y;`}
new (length: Int) `{return malloc(sizeof(ASensorEvent)*length);`}
fun [](index: Int): ASensorEvent `{
new (length: Int) `{return malloc(sizeof(ASensorEvent)*length);`}
fun [](index: Int): ASensorEvent `{
private fun enable_accelerometer
do
accelerometer.asensor = sensormanager.get_default_sensor(new ASensorType.accelerometer)
private fun enable_accelerometer
do
accelerometer.asensor = sensormanager.get_default_sensor(new ASensorType.accelerometer)
else
if eventqueue.enable_sensor(accelerometer.asensor) < 0 then print "Accelerometer enabling failed"
eventqueue.set_event_rate(accelerometer.asensor, accelerometer.event_rate)
else
if eventqueue.enable_sensor(accelerometer.asensor) < 0 then print "Accelerometer enabling failed"
eventqueue.set_event_rate(accelerometer.asensor, accelerometer.event_rate)
private fun enable_proximity
do
proximity.asensor = sensormanager.get_default_sensor(new ASensorType.proximity)
private fun enable_proximity
do
proximity.asensor = sensormanager.get_default_sensor(new ASensorType.proximity)
print "Proximity sensor unavailable"
else
if eventqueue.enable_sensor(proximity.asensor) < 0 then print "Proximity enabling failed"
print "Proximity sensor unavailable"
else
if eventqueue.enable_sensor(proximity.asensor) < 0 then print "Proximity enabling failed"
//maybe add a boolean to the app to know if we want to use Sensor API or ASensorEvent directly ...
ASensorEvent* events = malloc(sizeof(ASensorEvent)*10);
int nbevents;
//maybe add a boolean to the app to know if we want to use Sensor API or ASensorEvent directly ...
ASensorEvent* events = malloc(sizeof(ASensorEvent)*10);
int nbevents;
while((nbevents = ASensorEventQueue_getEvents(queue, events, 10)) > 0) {
int i;
for(i = 0; i < nbevents; i++){
ASensorEvent event = events[i];
switch (event.type) {
case ASENSOR_TYPE_ACCELEROMETER:
while((nbevents = ASensorEventQueue_getEvents(queue, events, 10)) > 0) {
int i;
for(i = 0; i < nbevents; i++){
ASensorEvent event = events[i];
switch (event.type) {
case ASENSOR_TYPE_ACCELEROMETER: