/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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 "android/sdk-controller-socket.h"
#include "android/sensors-port.h"
#include "android/hw-sensors.h"
#include "android/utils/debug.h"
#define E(...) derror(__VA_ARGS__)
#define W(...) dwarning(__VA_ARGS__)
#define D(...) VERBOSE_PRINT(sensors_port,__VA_ARGS__)
#define D_ACTIVE VERBOSE_CHECK(sensors_port)
#define TRACE_ON 1
#if TRACE_ON
#define T(...) VERBOSE_PRINT(sensors_port,__VA_ARGS__)
#else
#define T(...)
#endif
/* Timeout (millisec) to use when communicating with SDK controller. */
#define SDKCTL_SENSORS_TIMEOUT 3000
/*
* Queries sent to sensors port of the SDK controller.
*/
/* Queries the port for list of available sensors. */
#define SDKCTL_SENSORS_QUERY_LIST 1
/*
* Messages sent between the emuator, and sensors port of the SDK controller.
*/
/* Starts sensor emulation. */
#define SDKCTL_SENSORS_START 1
/* Stops sensor emulation. */
#define SENSOR_SENSORS_STOP 2
/* Enables emulation for a sensor. */
#define SDKCTL_SENSORS_ENABLE 3
/* Disables emulation for a sensor. */
#define SDKCTL_SENSORS_DISABLE 4
/* This message delivers sensor values. */
#define SDKCTL_SENSORS_SENSOR_EVENT 5
/* Describes a sensor on the device.
* When SDK controller sensors port replies to a "list" query, it replies with
* a flat buffer containing entries of this type following each other. End of
* each entry is a zero-terminator for its 'sensor_name' field. The end of the
* entire list is marked with an entry, containing -1 at its 'sensor_id' field.
*/
typedef struct SensorEntry {
/* Identifies sensor on the device. Value -1 indicates list terminator,
* rather than a valid sensor descriptor. */
int sensor_id;
/* Beginning of zero-terminated sensor name. */
char sensor_name[1];
} SensorEntry;
/* Describes a sensor in the array of emulated sensors. */
typedef struct SensorDescriptor {
/* Identifies sensor on the device. */
int sensor_id;
/* Identifies sensor in emulator. */
int emulator_id;
/* Sensor name. */
char* sensor_name;
} SensorDescriptor;
/* Sensor event message descriptor.
* Entries of this type are sent along with SDKCTL_SENSORS_SENSOR_EVENT message
*/
typedef struct SensorEvent {
/* Identifies a device sensor for which values have been delivered. */
int sensor_id;
/* Sensor values. */
float fvalues[3];
} SensorEvent;
/* Sensors port descriptor. */
struct AndroidSensorsPort {
/* Caller identifier. */
void* opaque;
/* Communication socket. */
SDKCtlSocket* sdkctl;
/* Lists sensors available for emulation. */
SensorDescriptor** sensors;
/* Number of sensors in 'sensors' list. */
int sensors_count;
};
/********************************************************************************
* Sensors port internals
*******************************************************************************/
/* Checks if sensor descriptor is the terminator.
* Return:
* Boolean, 1 if it is a terminator, 0 if it is not.
*/
static int
_sensor_entry_is_terminator(const SensorEntry* entry)
{
return entry == NULL || entry->sensor_id == -1;
}
/* Gets next sensor descriptor.
* Return:
* Next sensor desciptor, or NULL if there are no more descriptors in the list.
*/
static const SensorEntry*
_sensor_entry_next(const SensorEntry* entry)
{
if (!_sensor_entry_is_terminator(entry)) {
/* Next descriptor begins right after zero-terminator for the sensor_name
* field of this descriptor. */
entry = (const SensorEntry*)(entry->sensor_name + strlen(entry->sensor_name) + 1);
if (!_sensor_entry_is_terminator(entry)) {
return entry;
}
}
return NULL;
}
/* Gets number of entries in the list. */
static int
_sensor_entry_list_size(const SensorEntry* entry) {
int ret = 0;
while (!_sensor_entry_is_terminator(entry)) {
ret++;
entry = _sensor_entry_next(entry);
}
return ret;
}
/* Discards sensors saved in AndroidSensorsPort's array. */
static void
_sensors_port_discard_sensors(AndroidSensorsPort* asp)
{
if (asp->sensors != NULL) {
int n;
for (n = 0; n < asp->sensors_count; n++) {
if (asp->sensors[n] != NULL) {
free(asp->sensors[n]->sensor_name);
AFREE(asp->sensors[n]);
}
}
free(asp->sensors);
asp->sensors = NULL;
}
asp->sensors_count = 0;
}
/* Destroys and frees the descriptor. */
static void
_sensors_port_free(AndroidSensorsPort* asp)
{
if (asp != NULL) {
_sensors_port_discard_sensors(asp);
if (asp->sdkctl != NULL) {
sdkctl_socket_release(asp->sdkctl);
}
AFREE(asp);
}
}
/* Parses flat sensor list, and saves its entries into 'sensors' array filed of
* the AndroidSensorsPort descriptor. */
static void
_sensors_port_save_sensors(AndroidSensorsPort* asp, const SensorEntry* list)
{
const int count = _sensor_entry_list_size(list);
if (count != 0) {
int n;
/* Allocate array for sensor descriptors. */
asp->sensors = malloc(sizeof(SensorDescriptor*) * count);
/* Iterate through the flat sensor list, filling up array of emulated
* sensors. */
const SensorEntry* entry = _sensor_entry_is_terminator(list) ? NULL : list;
for (n = 0; n < count && entry != NULL; n++) {
/* Get emulator-side ID for the sensor. < 0 value indicates that
* sensor is not supported by the emulator. */
const int emulator_id =
android_sensors_get_id_from_name((char*)entry->sensor_name);
if (emulator_id >= 0) {
SensorDescriptor* desc;
ANEW0(desc);
desc->emulator_id = emulator_id;
desc->sensor_id = entry->sensor_id;
desc->sensor_name = ASTRDUP(entry->sensor_name);
asp->sensors[asp->sensors_count++] = desc;
D("Sensors: Emulated sensor '%s': Device id = %d, Emulator id = %d",
desc->sensor_name, desc->sensor_id, desc->emulator_id);
} else {
D("Sensors: Sensor '%s' is not support by emulator",
entry->sensor_name);
}
entry = _sensor_entry_next(entry);
}
D("Sensors: Emulating %d sensors", asp->sensors_count);
}
}
/* Finds sensor descriptor for an SDK controller-side ID. */
static const SensorDescriptor*
_sensor_from_sdkctl_id(AndroidSensorsPort* asp, int id)
{
int n;
for (n = 0; n < asp->sensors_count; n++) {
if (asp->sensors[n]->sensor_id == id) {
return asp->sensors[n];
}
}
return NULL;
}
/* Initiates sensor emulation.
* Param:
* asp - Android sensors port instance returned from sensors_port_create.
* Return:
* Zero on success, failure otherwise.
*/
static void
_sensors_port_start(AndroidSensorsPort* asp)
{
int n;
if (!sdkctl_socket_is_port_ready(asp->sdkctl)) {
/* SDK controller side is not ready for emulation. Retreat... */
D("Sensors: SDK controller side is not ready for emulation.");
return;
}
/* Disable all sensors, and reenable only those that are emulated by
* hardware. */
sensors_port_disable_sensor(asp, "all");
/* Walk throuh the list of enabled sensors enabling them on the device. */
for (n = 0; n < asp->sensors_count; n++) {
if (android_sensors_get_sensor_status(asp->sensors[n]->emulator_id) == 1) {
/* Reenable emulation for this sensor. */
sensors_port_enable_sensor(asp, asp->sensors[n]->sensor_name);
D("Sensors: Sensor '%s' is enabled on SDK controller.",
asp->sensors[n]->sensor_name);
}
}
/* Start the emulation. */
SDKCtlMessage* const msg =
sdkctl_message_send(asp->sdkctl, SDKCTL_SENSORS_START, NULL, 0);
sdkctl_message_release(msg);
D("Sensors: Emulation has been started.");
}
/********************************************************************************
* Sensors port callbacks
*******************************************************************************/
/* Completion for the "list" query. */
static AsyncIOAction
_on_sensor_list_query(void* query_opaque,
SDKCtlQuery* query,
AsyncIOState status)
{
AndroidSensorsPort* const asp = (AndroidSensorsPort*)(query_opaque);
if (status != ASIO_STATE_SUCCEEDED) {
/* We don't really care about failures at this point. They will
* eventually surface up in another place. */
return ASIO_ACTION_DONE;
}
/* Parse query response which is a flat list of SensorEntry entries. */
const SensorEntry* const list =
(const SensorEntry*)sdkctl_query_get_buffer_out(query);
D("Sensors: Sensor list received with %d sensors.",
_sensor_entry_list_size(list));
_sensors_port_save_sensors(asp, list);
/* At this point we are ready to statr sensor emulation. */
_sensors_port_start(asp);
return ASIO_ACTION_DONE;
}
/* A callback that is invoked on sensor events.
* Param:
* asp - AndroidSensorsPort instance.
* event - Sensor event.
*/
static void
_on_sensor_event(AndroidSensorsPort* asp, const SensorEvent* event)
{
/* Find corresponding server descriptor. */
const SensorDescriptor* const desc =
_sensor_from_sdkctl_id(asp, event->sensor_id);
if (desc != NULL) {
T("Sensors: %s -> %f, %f, %f", desc->sensor_name,
event->fvalues[0], event->fvalues[1],
event->fvalues[2]);
/* Fire up sensor change in the guest. */
android_sensors_set(desc->emulator_id, event->fvalues[0],
event->fvalues[1], event->fvalues[2]);
} else {
W("Sensors: No descriptor for sensor %d", event->sensor_id);
}
}
/* A callback that is invoked on SDK controller socket connection events. */
static AsyncIOAction
_on_sensors_socket_connection(void* client_opaque,
SDKCtlSocket* sdkctl,
AsyncIOState status)
{
AndroidSensorsPort* const asp = (AndroidSensorsPort*)client_opaque;
if (status == ASIO_STATE_FAILED) {
/* Disconnection could mean that user is swapping devices. New device may
* have different set of sensors, so we need to re-query sensor list on
* reconnection. */
_sensors_port_discard_sensors(asp);
/* Reconnect (after timeout delay) on failures */
if (sdkctl_socket_is_handshake_ok(sdkctl)) {
sdkctl_socket_reconnect(sdkctl, SDKCTL_DEFAULT_TCP_PORT,
SDKCTL_SENSORS_TIMEOUT);
}
}
return ASIO_ACTION_DONE;
}
/* A callback that is invoked on SDK controller port connection events. */
static void
_on_sensors_port_connection(void* client_opaque,
SDKCtlSocket* sdkctl,
SdkCtlPortStatus status)
{
AndroidSensorsPort* const asp = (AndroidSensorsPort*)client_opaque;
switch (status) {
case SDKCTL_PORT_CONNECTED: {
D("Sensors: SDK Controller is connected.");
/* Query list of available sensors. */
SDKCtlQuery* const query =
sdkctl_query_build_and_send(asp->sdkctl, SDKCTL_SENSORS_QUERY_LIST,
0, NULL, NULL, NULL,
_on_sensor_list_query, asp,
SDKCTL_SENSORS_TIMEOUT);
sdkctl_query_release(query);
break;
}
case SDKCTL_PORT_DISCONNECTED:
_sensors_port_discard_sensors(asp);
D("Sensors: SDK Controller is disconnected.");
break;
case SDKCTL_PORT_ENABLED:
_sensors_port_start(asp);
D("Sensors: SDK Controller is enabled.");
break;
case SDKCTL_PORT_DISABLED:
D("Sensors: SDK Controller is disabled.");
break;
case SDKCTL_HANDSHAKE_CONNECTED:
D("Sensors: SDK Controller has succeeded handshake, and port is connected.");
break;
case SDKCTL_HANDSHAKE_NO_PORT:
D("Sensors: SDK Controller has succeeded handshake, and port is not connected.");
break;
case SDKCTL_HANDSHAKE_DUP:
E("Sensors: SDK Controller has failed the handshake due to port duplication.");
sdkctl_socket_disconnect(sdkctl);
break;
case SDKCTL_HANDSHAKE_UNKNOWN_QUERY:
E("Sensors: SDK Controller has failed the handshake due to unknown query.");
sdkctl_socket_disconnect(sdkctl);
break;
case SDKCTL_HANDSHAKE_UNKNOWN_RESPONSE:
default:
E("Sensors: Handshake has failed due to unknown reasons.");
sdkctl_socket_disconnect(sdkctl);
break;
}
}
/* A callback that is invoked when a message is received from SDK controller. */
static void
_on_sensors_message(void* client_opaque,
SDKCtlSocket* sdkctl,
SDKCtlMessage* message,
int msg_type,
void* msg_data,
int msg_size)
{
AndroidSensorsPort* const asp = (AndroidSensorsPort*)client_opaque;
switch (msg_type) {
case SDKCTL_SENSORS_SENSOR_EVENT:
_on_sensor_event(asp, (const SensorEvent*)msg_data);
break;
default:
E("Sensors: Unknown message type %d", msg_type);
break;
}
}
/********************************************************************************
* Sensors port API
*******************************************************************************/
AndroidSensorsPort*
sensors_port_create(void* opaque)
{
AndroidSensorsPort* asp;
ANEW0(asp);
asp->opaque = opaque;
asp->sensors = NULL;
asp->sensors_count = 0;
asp->sdkctl = sdkctl_socket_new(SDKCTL_SENSORS_TIMEOUT, "sensors",
_on_sensors_socket_connection,
_on_sensors_port_connection,
_on_sensors_message, asp);
sdkctl_init_recycler(asp->sdkctl, 76, 8);
sdkctl_socket_connect(asp->sdkctl, SDKCTL_DEFAULT_TCP_PORT,
SDKCTL_SENSORS_TIMEOUT);
return asp;
}
void
sensors_port_destroy(AndroidSensorsPort* asp)
{
if (asp->sdkctl != NULL) {
sdkctl_socket_disconnect(asp->sdkctl);
}
_sensors_port_free(asp);
}
int
sensors_port_enable_sensor(AndroidSensorsPort* asp, const char* name)
{
if (asp->sdkctl != NULL && sdkctl_socket_is_port_ready(asp->sdkctl)) {
SDKCtlMessage* const msg = sdkctl_message_send(asp->sdkctl,
SDKCTL_SENSORS_ENABLE,
name, strlen(name));
sdkctl_message_release(msg);
return 0;
} else {
return -1;
}
}
int
sensors_port_disable_sensor(AndroidSensorsPort* asp, const char* name)
{
if (asp->sdkctl != NULL && sdkctl_socket_is_port_ready(asp->sdkctl)) {
SDKCtlMessage* const msg = sdkctl_message_send(asp->sdkctl,
SDKCTL_SENSORS_DISABLE,
name, strlen(name));
sdkctl_message_release(msg);
return 0;
} else {
return -1;
}
}