ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

am a5552de9: Merge "Sensor batching. Changes to the native code." into klp-dev

Browse Source 
* commit 'a5552de96f0cff9fb1947d8d21556bfeccf9cd03':
  Sensor batching. Changes to the native code.
This commit is contained in:
Aravind Akella 2013-09-03 17:43:44 -07:00 committed by Android Git Automerger
commit e29df8b929
15 changed files with 451 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
include/android/sensor.h
View File

@ -106,6 +106,30 @@ typedef struct ASensorVector {
uint8_t reserved[3];
} ASensorVector;
typedef struct AMetaDataEvent {
int32_t what;
int32_t sensor;
} AMetaDataEvent;
typedef struct AUncalibratedEvent {
union {
float uncalib[3];
struct {
float x_uncalib;
float y_uncalib;
float z_uncalib;
};
};
union {
float bias[3];
struct {
float x_bias;
float y_bias;
float z_bias;
};
};
} AUncalibratedEvent;
/* NOTE: Must match hardware/sensors.h */
typedef struct ASensorEvent {
int32_t version; /* sizeof(struct ASensorEvent) */
@ -123,6 +147,10 @@ typedef struct ASensorEvent {
float distance;
float light;
float pressure;
float relative_humidity;
AUncalibratedEvent uncalibrated_gyro;
AUncalibratedEvent uncalibrated_magnetic;
AMetaDataEvent meta_data;
};
union {
uint64_t data[8];
@ -132,7 +160,6 @@ typedef struct ASensorEvent {
int32_t reserved1[4];
} ASensorEvent;
struct ASensorManager;
typedef struct ASensorManager ASensorManager;

4
include/gui/ISensorEventConnection.h
View File

@ -36,8 +36,10 @@ public:
DECLARE_META_INTERFACE(SensorEventConnection);
virtual sp<BitTube> getSensorChannel() const = 0;
virtual status_t enableDisable(int handle, bool enabled) = 0;
virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
nsecs_t maxBatchReportLatencyNs, int reservedFlags) = 0;
virtual status_t setEventRate(int handle, nsecs_t ns) = 0;
virtual status_t flushSensor(int handle) = 0;
};
// ----------------------------------------------------------------------------

6
include/gui/Sensor.h
View File

@ -53,7 +53,7 @@ public:
};
Sensor();
Sensor(struct sensor_t const* hwSensor);
Sensor(struct sensor_t const* hwSensor, int halVersion = 0);
~Sensor();
const String8& getName() const;
@ -67,6 +67,8 @@ public:
int32_t getMinDelay() const;
nsecs_t getMinDelayNs() const;
int32_t getVersion() const;
int32_t getFifoReservedEventCount() const;
int32_t getFifoMaxEventCount() const;
// LightFlattenable protocol
inline bool isFixedSize() const { return false; }
@ -85,6 +87,8 @@ private:
float mPower;
int32_t mMinDelay;
int32_t mVersion;
int32_t mFifoReservedEventCount;
int32_t mFifoMaxEventCount;
};
// ----------------------------------------------------------------------------

4
include/gui/SensorEventQueue.h
View File

@ -68,8 +68,10 @@ public:
status_t setEventRate(Sensor const* sensor, nsecs_t ns) const;
// these are here only to support SensorManager.java
status_t enableSensor(int32_t handle, int32_t us) const;
status_t enableSensor(int32_t handle, int32_t samplingPeriodUs, int maxBatchReportLatencyUs,
int reservedFlags) const;
status_t disableSensor(int32_t handle) const;
status_t flushSensor(int32_t handle) const;
private:
sp<Looper> getLooper() const;

30
libs/gui/ISensorEventConnection.cpp
View File

@ -33,7 +33,8 @@ namespace android {
enum {
GET_SENSOR_CHANNEL = IBinder::FIRST_CALL_TRANSACTION,
ENABLE_DISABLE,
SET_EVENT_RATE
SET_EVENT_RATE,
FLUSH_SENSOR
};
class BpSensorEventConnection : public BpInterface<ISensorEventConnection>
@ -52,12 +53,16 @@ public:
return new BitTube(reply);
}
virtual status_t enableDisable(int handle, bool enabled)
virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
nsecs_t maxBatchReportLatencyNs, int reservedFlags)
{
Parcel data, reply;
data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
data.writeInt32(handle);
data.writeInt32(enabled);
data.writeInt64(samplingPeriodNs);
data.writeInt64(maxBatchReportLatencyNs);
data.writeInt32(reservedFlags);
remote()->transact(ENABLE_DISABLE, data, &reply);
return reply.readInt32();
}
@ -71,6 +76,14 @@ public:
remote()->transact(SET_EVENT_RATE, data, &reply);
return reply.readInt32();
}
virtual status_t flushSensor(int handle) {
Parcel data, reply;
data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
data.writeInt32(handle);
remote()->transact(FLUSH_SENSOR, data, &reply);
return reply.readInt32();
}
};
IMPLEMENT_META_INTERFACE(SensorEventConnection, "android.gui.SensorEventConnection");
@ -91,7 +104,11 @@ status_t BnSensorEventConnection::onTransact(
CHECK_INTERFACE(ISensorEventConnection, data, reply);
int handle = data.readInt32();
int enabled = data.readInt32();
status_t result = enableDisable(handle, enabled);
nsecs_t samplingPeriodNs = data.readInt64();
nsecs_t maxBatchReportLatencyNs = data.readInt64();
int reservedFlags = data.readInt32();
status_t result = enableDisable(handle, enabled, samplingPeriodNs,
maxBatchReportLatencyNs, reservedFlags);
reply->writeInt32(result);
return NO_ERROR;
} break;
@ -103,6 +120,13 @@ status_t BnSensorEventConnection::onTransact(
reply->writeInt32(result);
return NO_ERROR;
} break;
case FLUSH_SENSOR: {
CHECK_INTERFACE(ISensorEventConnection, data, reply);
int handle = data.readInt32();
status_t result = flushSensor(handle);
reply->writeInt32(result);
return NO_ERROR;
} break;
}
return BBinder::onTransact(code, data, reply, flags);
}

29
libs/gui/Sensor.cpp
View File

@ -32,11 +32,11 @@ namespace android {
Sensor::Sensor()
: mHandle(0), mType(0),
mMinValue(0), mMaxValue(0), mResolution(0),
mPower(0), mMinDelay(0)
mPower(0), mMinDelay(0), mFifoReservedEventCount(0), mFifoMaxEventCount(0)
{
}
Sensor::Sensor(struct sensor_t const* hwSensor)
Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion)
{
mName = hwSensor->name;
mVendor = hwSensor->vendor;
@ -48,6 +48,15 @@ Sensor::Sensor(struct sensor_t const* hwSensor)
mResolution = hwSensor->resolution;
mPower = hwSensor->power;
mMinDelay = hwSensor->minDelay;
// Set fifo event count zero for older devices which do not support batching. Fused
// sensors also have their fifo counts set to zero.
if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
mFifoReservedEventCount = hwSensor->fifoReservedEventCount;
mFifoMaxEventCount = hwSensor->fifoMaxEventCount;
} else {
mFifoReservedEventCount = 0;
mFifoMaxEventCount = 0;
}
}
Sensor::~Sensor()
@ -98,12 +107,20 @@ int32_t Sensor::getVersion() const {
return mVersion;
}
int32_t Sensor::getFifoReservedEventCount() const {
return mFifoReservedEventCount;
}
int32_t Sensor::getFifoMaxEventCount() const {
return mFifoMaxEventCount;
}
size_t Sensor::getFlattenedSize() const
{
size_t fixedSize =
sizeof(int32_t) * 3 +
sizeof(float) * 4 +
sizeof(int32_t);
sizeof(int32_t) * 3;
size_t variableSize =
sizeof(int32_t) + FlattenableUtils::align<4>(mName.length()) +
@ -133,6 +150,8 @@ status_t Sensor::flatten(void* buffer, size_t size) const {
FlattenableUtils::write(buffer, size, mResolution);
FlattenableUtils::write(buffer, size, mPower);
FlattenableUtils::write(buffer, size, mMinDelay);
FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
return NO_ERROR;
}
@ -163,7 +182,7 @@ status_t Sensor::unflatten(void const* buffer, size_t size) {
size_t fixedSize =
sizeof(int32_t) * 3 +
sizeof(float) * 4 +
sizeof(int32_t);
sizeof(int32_t) * 3;
if (size < fixedSize) {
return NO_MEMORY;
@ -177,6 +196,8 @@ status_t Sensor::unflatten(void const* buffer, size_t size) {
FlattenableUtils::read(buffer, size, mResolution);
FlattenableUtils::read(buffer, size, mPower);
FlattenableUtils::read(buffer, size, mMinDelay);
FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
FlattenableUtils::read(buffer, size, mFifoMaxEventCount);
return NO_ERROR;
}

20
libs/gui/SensorEventQueue.cpp
View File

@ -107,23 +107,25 @@ status_t SensorEventQueue::wake() const
}
status_t SensorEventQueue::enableSensor(Sensor const* sensor) const {
return mSensorEventConnection->enableDisable(sensor->getHandle(), true);
return mSensorEventConnection->enableDisable(sensor->getHandle(), true, 0, 0, false);
}
status_t SensorEventQueue::disableSensor(Sensor const* sensor) const {
return mSensorEventConnection->enableDisable(sensor->getHandle(), false);
return mSensorEventConnection->enableDisable(sensor->getHandle(), false, 0, 0, false);
}
status_t SensorEventQueue::enableSensor(int32_t handle, int32_t us) const {
status_t err = mSensorEventConnection->enableDisable(handle, true);
if (err == NO_ERROR) {
mSensorEventConnection->setEventRate(handle, us2ns(us));
}
return err;
status_t SensorEventQueue::enableSensor(int32_t handle, int32_t samplingPeriodUs,
int maxBatchReportLatencyUs, int reservedFlags) const {
return mSensorEventConnection->enableDisable(handle, true, us2ns(samplingPeriodUs),
us2ns(maxBatchReportLatencyUs), reservedFlags);
}
status_t SensorEventQueue::flushSensor(int32_t handle) const {
return mSensorEventConnection->flushSensor(handle);
}
status_t SensorEventQueue::disableSensor(int32_t handle) const {
return mSensorEventConnection->enableDisable(handle, false);
return mSensorEventConnection->enableDisable(handle, false, 0, 0, false);
}
status_t SensorEventQueue::setEventRate(Sensor const* sensor, nsecs_t ns) const {

274
services/sensorservice/SensorDevice.cpp
View File

@ -47,7 +47,7 @@ SensorDevice::SensorDevice()
SENSORS_HARDWARE_MODULE_ID, strerror(-err));
if (mSensorModule) {
err = sensors_open(&mSensorModule->common, &mSensorDevice);
err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
ALOGE_IF(err, "couldn't open device for module %s (%s)",
SENSORS_HARDWARE_MODULE_ID, strerror(-err));
@ -59,7 +59,9 @@ SensorDevice::SensorDevice()
Info model;
for (size_t i=0 ; i<size_t(count) ; i++) {
mActivationCount.add(list[i].handle, model);
mSensorDevice->activate(mSensorDevice, list[i].handle, 0);
mSensorDevice->activate(
reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
list[i].handle, 0);
}
}
}
@ -76,15 +78,23 @@ void SensorDevice::dump(String8& result)
Mutex::Autolock _l(mLock);
for (size_t i=0 ; i<size_t(count) ; i++) {
const Info& info = mActivationCount.valueFor(list[i].handle);
result.appendFormat("handle=0x%08x, active-count=%d, rates(ms)={ ",
list[i].handle,
info.rates.size());
for (size_t j=0 ; j<info.rates.size() ; j++) {
result.appendFormat("%4.1f%s",
info.rates.valueAt(j) / 1e6f,
j<info.rates.size()-1 ? ", " : "");
result.appendFormat("handle=0x%08x, active-count=%d, batch_period(ms)={ ", list[i].handle,
info.batchParams.size());
for (size_t j = 0; j < info.batchParams.size(); j++) {
BatchParams params = info.batchParams.valueAt(j);
result.appendFormat("%4.1f%s", params.batchDelay / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
result.appendFormat(" }, selected=%4.1f ms\n", info.delay / 1e6f);
result.appendFormat(" }, selected=%4.1f ms\n", info.bestBatchParams.batchDelay / 1e6f);
result.appendFormat("handle=0x%08x, active-count=%d, batch_timeout(ms)={ ", list[i].handle,
info.batchParams.size());
for (size_t j = 0; j < info.batchParams.size(); j++) {
BatchParams params = info.batchParams.valueAt(j);
result.appendFormat("%4.1f%s", params.batchTimeout / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
result.appendFormat(" }, selected=%4.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
}
}
@ -102,7 +112,8 @@ ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
if (!mSensorDevice) return NO_INIT;
ssize_t c;
do {
c = mSensorDevice->poll(mSensorDevice, buffer, count);
c = mSensorDevice->poll(reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
buffer, count);
} while (c == -EINTR);
return c;
}
@ -110,7 +121,7 @@ ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
void SensorDevice::autoDisable(void *ident, int handle) {
Info& info( mActivationCount.editValueFor(handle) );
Mutex::Autolock _l(mLock);
info.rates.removeItem(ident);
info.removeBatchParamsForIdent(ident);
}
status_t SensorDevice::activate(void* ident, int handle, int enabled)
@ -119,35 +130,46 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled)
status_t err(NO_ERROR);
bool actuateHardware = false;
Mutex::Autolock _l(mLock);
Info& info( mActivationCount.editValueFor(handle) );
ALOGD_IF(DEBUG_CONNECTIONS,
"SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%d",
ident, handle, enabled, info.rates.size());
"SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%d",
ident, handle, enabled, info.batchParams.size());
if (enabled) {
Mutex::Autolock _l(mLock);
ALOGD_IF(DEBUG_CONNECTIONS, "... index=%ld",
info.rates.indexOfKey(ident));
ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%d", info.batchParams.indexOfKey(ident));
if (info.rates.indexOfKey(ident) < 0) {
info.rates.add(ident, DEFAULT_EVENTS_PERIOD);
if (info.rates.size() == 1) {
actuateHardware = true;
}
if (info.batchParams.indexOfKey(ident) >= 0) {
if (info.batchParams.size() == 1) {
// This is the first connection, we need to activate the underlying h/w sensor.
actuateHardware = true;
}
} else {
// sensor was already activated for this ident
// Log error. Every activate call should be preceded by a batch() call.
ALOGE("\t >>>ERROR: activate called without batch");
}
} else {
Mutex::Autolock _l(mLock);
ALOGD_IF(DEBUG_CONNECTIONS, "... index=%ld",
info.rates.indexOfKey(ident));
ALOGD_IF(DEBUG_CONNECTIONS, "disable index=%d", info.batchParams.indexOfKey(ident));
ssize_t idx = info.rates.removeItem(ident);
if (idx >= 0) {
if (info.rates.size() == 0) {
if (info.removeBatchParamsForIdent(ident) >= 0) {
if (info.batchParams.size() == 0) {
// This is the last connection, we need to de-activate the underlying h/w sensor.
actuateHardware = true;
} else {
const int halVersion = getHalDeviceVersion();
if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
// Call batch for this sensor with the previously calculated best effort
// batch_rate and timeout. One of the apps has unregistered for sensor
// events, and the best effort batch parameters might have changed.
ALOGD_IF(DEBUG_CONNECTIONS,
"\t>>> actuating h/w batch %d %d %lld %lld ", handle,
info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
info.bestBatchParams.batchTimeout);
mSensorDevice->batch(mSensorDevice, handle,info.bestBatchParams.flags,
info.bestBatchParams.batchDelay,
info.bestBatchParams.batchTimeout);
}
}
} else {
// sensor wasn't enabled for this ident
@ -155,41 +177,130 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled)
}
if (actuateHardware) {
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w");
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle, enabled);
err = mSensorDevice->activate(
reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice), handle, enabled);
ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
strerror(-err));
err = mSensorDevice->activate(mSensorDevice, handle, enabled);
ALOGE_IF(err, "Error %s sensor %d (%s)",
enabled ? "activating" : "disabling",
handle, strerror(-err));
if (err != NO_ERROR) {
// clean-up on failure
if (enabled) {
// failure when enabling the sensor
Mutex::Autolock _l(mLock);
info.rates.removeItem(ident);
}
if (err != NO_ERROR && enabled) {
// Failure when enabling the sensor. Clean up on failure.
info.removeBatchParamsForIdent(ident);
}
}
{ // scope for the lock
Mutex::Autolock _l(mLock);
nsecs_t ns = info.selectDelay();
mSensorDevice->setDelay(mSensorDevice, handle, ns);
// On older devices which do not support batch, call setDelay().
if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1 && info.batchParams.size() > 0) {
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w setDelay %d %lld ", handle,
info.bestBatchParams.batchDelay);
mSensorDevice->setDelay(
reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
handle, info.bestBatchParams.batchDelay);
}
return err;
}
status_t SensorDevice::setDelay(void* ident, int handle, int64_t ns)
status_t SensorDevice::batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs) {
if (!mSensorDevice) return NO_INIT;
if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
}
const int halVersion = getHalDeviceVersion();
if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
if (flags & SENSORS_BATCH_DRY_RUN) {
return mSensorDevice->batch(mSensorDevice, handle, flags, samplingPeriodNs,
maxBatchReportLatencyNs);
} else {
// Call h/w with dry run to see if the given parameters are feasible or not. Return if
// there is an error.
status_t errDryRun(NO_ERROR);
errDryRun = mSensorDevice->batch(mSensorDevice, handle, flags | SENSORS_BATCH_DRY_RUN,
samplingPeriodNs, maxBatchReportLatencyNs);
if (errDryRun != NO_ERROR) {
ALOGD_IF(DEBUG_CONNECTIONS, "SensorDevice::batch dry run error %s",
strerror(-errDryRun));
return errDryRun;
}
}
} else if (maxBatchReportLatencyNs != 0) {
// Batch is not supported on older devices.
return INVALID_OPERATION;
}
ALOGD_IF(DEBUG_CONNECTIONS,
"SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%lld timeout=%lld",
ident, handle, flags, samplingPeriodNs, maxBatchReportLatencyNs);
Mutex::Autolock _l(mLock);
Info& info(mActivationCount.editValueFor(handle));
if (info.batchParams.indexOfKey(ident) < 0) {
BatchParams params(flags, samplingPeriodNs, maxBatchReportLatencyNs);
info.batchParams.add(ident, params);
} else {
// A batch has already been called with this ident. Update the batch parameters.
info.setBatchParamsForIdent(ident, flags, samplingPeriodNs, maxBatchReportLatencyNs);
}
BatchParams prevBestBatchParams = info.bestBatchParams;
// Find the minimum of all timeouts and batch_rates for this sensor.
info.selectBatchParams();
ALOGD_IF(DEBUG_CONNECTIONS,
"\t>>> curr_period=%lld min_period=%lld curr_timeout=%lld min_timeout=%lld",
prevBestBatchParams.batchDelay, info.bestBatchParams.batchDelay,
prevBestBatchParams.batchTimeout, info.bestBatchParams.batchTimeout);
status_t err(NO_ERROR);
// If the min period or min timeout has changed since the last batch call, call batch.
if (prevBestBatchParams != info.bestBatchParams) {
if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %lld %lld ", handle,
info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
info.bestBatchParams.batchTimeout);
err = mSensorDevice->batch(mSensorDevice, handle, info.bestBatchParams.flags,
info.bestBatchParams.batchDelay,
info.bestBatchParams.batchTimeout);
} else {
// For older devices which do not support batch, call setDelay() after activate() is
// called. Some older devices may not support calling setDelay before activate(), so
// call setDelay in SensorDevice::activate() method.
}
if (err != NO_ERROR) {
ALOGE("sensor batch failed %p %d %d %lld %lld err=%s", mSensorDevice, handle,
info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
info.bestBatchParams.batchTimeout, strerror(-err));
info.removeBatchParamsForIdent(ident);
}
}
return err;
}
status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs)
{
if (!mSensorDevice) return NO_INIT;
if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
}
Mutex::Autolock _l(mLock);
Info& info( mActivationCount.editValueFor(handle) );
status_t err = info.setDelayForIdent(ident, ns);
if (err < 0) return err;
ns = info.selectDelay();
return mSensorDevice->setDelay(mSensorDevice, handle, ns);
// If the underlying sensor is NOT in continuous mode, setDelay() should return an error.
// Calling setDelay() in batch mode is an invalid operation.
if (info.bestBatchParams.batchTimeout != 0) {
return INVALID_OPERATION;
}
ssize_t index = info.batchParams.indexOfKey(ident);
if (index < 0) {
return BAD_INDEX;
}
BatchParams& params = info.batchParams.editValueAt(index);
params.batchDelay = samplingPeriodNs;
info.selectBatchParams();
return mSensorDevice->setDelay(reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
handle, info.bestBatchParams.batchDelay);
}
int SensorDevice::getHalDeviceVersion() const {
@ -198,31 +309,58 @@ int SensorDevice::getHalDeviceVersion() const {
return mSensorDevice->common.version;
}
status_t SensorDevice::flush(void* ident, int handle) {
if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1) {
return INVALID_OPERATION;
}
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
return mSensorDevice->flush(mSensorDevice, handle);
}
// ---------------------------------------------------------------------------
status_t SensorDevice::Info::setDelayForIdent(void* ident, int64_t ns)
{
ssize_t index = rates.indexOfKey(ident);
status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs) {
ssize_t index = batchParams.indexOfKey(ident);
if (index < 0) {
ALOGE("Info::setDelayForIdent(ident=%p, ns=%lld) failed (%s)",
ident, ns, strerror(-index));
ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%lld timeout=%lld) failed (%s)",
ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
return BAD_INDEX;
}
rates.editValueAt(index) = ns;
BatchParams& params = batchParams.editValueAt(index);
params.flags = flags;
params.batchDelay = samplingPeriodNs;
params.batchTimeout = maxBatchReportLatencyNs;
return NO_ERROR;
}
nsecs_t SensorDevice::Info::selectDelay()
{
nsecs_t ns = rates.valueAt(0);
for (size_t i=1 ; i<rates.size() ; i++) {
nsecs_t cur = rates.valueAt(i);
if (cur < ns) {
ns = cur;
void SensorDevice::Info::selectBatchParams() {
BatchParams bestParams(-1, -1, -1);
if (batchParams.size() > 0) {
BatchParams params = batchParams.valueAt(0);
bestParams = params;
}
for (size_t i = 1; i < batchParams.size(); ++i) {
BatchParams params = batchParams.valueAt(i);
if (params.batchDelay < bestParams.batchDelay) {
bestParams.batchDelay = params.batchDelay;
}
if (params.batchTimeout < bestParams.batchTimeout) {
bestParams.batchTimeout = params.batchTimeout;
}
}
delay = ns;
return ns;
bestBatchParams = bestParams;
}
ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
ssize_t idx = batchParams.removeItem(ident);
if (idx >= 0) {
selectBatchParams();
}
return idx;
}
// ---------------------------------------------------------------------------

52
services/sensorservice/SensorDevice.h
View File

@ -31,20 +31,50 @@
namespace android {
// ---------------------------------------------------------------------------
static const nsecs_t DEFAULT_EVENTS_PERIOD = 200000000; // 5 Hz
class SensorDevice : public Singleton<SensorDevice> {
friend class Singleton<SensorDevice>;
struct sensors_poll_device_t* mSensorDevice;
sensors_poll_device_1_t* mSensorDevice;
struct sensors_module_t* mSensorModule;
mutable Mutex mLock; // protect mActivationCount[].rates
static const nsecs_t MINIMUM_EVENTS_PERIOD = 1000000; // 1000 Hz
mutable Mutex mLock; // protect mActivationCount[].batchParams
// fixed-size array after construction
// Struct to store all the parameters(samplingPeriod, maxBatchReportLatency and flags) from
// batch call. For continous mode clients, maxBatchReportLatency is set to zero.
struct BatchParams {
int flags;
nsecs_t batchDelay, batchTimeout;
BatchParams() : flags(0), batchDelay(0), batchTimeout(0) {}
BatchParams(int flag, nsecs_t delay, nsecs_t timeout): flags(flag), batchDelay(delay),
batchTimeout(timeout) { }
bool operator != (const BatchParams& other) {
return other.batchDelay != batchDelay || other.batchTimeout != batchTimeout ||
other.flags != flags;
}
};
// Store batch parameters in the KeyedVector and the optimal batch_rate and timeout in
// bestBatchParams. For every batch() call corresponding params are stored in batchParams
// vector. A continuous mode request is batch(... timeout=0 ..) followed by activate(). A batch
// mode request is batch(... timeout > 0 ...) followed by activate().
// Info is a per-sensor data structure which contains the batch parameters for each client that
// has registered for this sensor.
struct Info {
Info() : delay(0) { }
KeyedVector<void*, nsecs_t> rates;
nsecs_t delay;
status_t setDelayForIdent(void* ident, int64_t ns);
nsecs_t selectDelay();
BatchParams bestBatchParams;
// Key is the unique identifier(ident) for each client, value is the batch parameters
// requested by the client.
KeyedVector<void*, BatchParams> batchParams;
Info() : bestBatchParams(-1, -1, -1) {}
// Sets batch parameters for this ident. Returns error if this ident is not already present
// in the KeyedVector above.
status_t setBatchParamsForIdent(void* ident, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs);
// Finds the optimal parameters for batching and stores them in bestBatchParams variable.
void selectBatchParams();
// Removes batchParams for an ident and re-computes bestBatchParams. Returns the index of
// the removed ident. If index >=0, ident is present and successfully removed.
ssize_t removeBatchParamsForIdent(void* ident);
};
DefaultKeyedVector<int, Info> mActivationCount;
@ -55,7 +85,11 @@ public:
int getHalDeviceVersion() const;
ssize_t poll(sensors_event_t* buffer, size_t count);
status_t activate(void* ident, int handle, int enabled);
status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs);
// Call batch with timeout zero instead of calling setDelay() for newer devices.
status_t setDelay(void* ident, int handle, int64_t ns);
status_t flush(void* ident, int handle);
void autoDisable(void *ident, int handle);
void dump(String8& result);
};

9
services/sensorservice/SensorFusion.cpp
View File

@ -102,6 +102,15 @@ status_t SensorFusion::activate(void* ident, bool enabled) {
}
}
if (enabled) {
ALOGD("SensorFusion calling batch ident=%p ", ident);
// Activating a sensor in continuous mode is equivalent to calling batch with the default
// period and timeout equal to ZERO, followed by a call to activate.
mSensorDevice.batch(ident, mAcc.getHandle(), 0, DEFAULT_EVENTS_PERIOD, 0);
mSensorDevice.batch(ident, mMag.getHandle(), 0, DEFAULT_EVENTS_PERIOD, 0);
mSensorDevice.batch(ident, mGyro.getHandle(), 0, DEFAULT_EVENTS_PERIOD, 0);
}
mSensorDevice.activate(ident, mAcc.getHandle(), enabled);
mSensorDevice.activate(ident, mMag.getHandle(), enabled);
mSensorDevice.activate(ident, mGyro.getHandle(), enabled);

1
services/sensorservice/SensorFusion.h
View File

@ -37,6 +37,7 @@ class SensorDevice;
class SensorFusion : public Singleton<SensorFusion> {
friend class Singleton<SensorFusion>;
static const nsecs_t DEFAULT_EVENTS_PERIOD = 200000000; // 5 Hz
SensorDevice& mSensorDevice;
Sensor mAcc;

12
services/sensorservice/SensorInterface.cpp
View File

@ -32,7 +32,7 @@ SensorInterface::~SensorInterface()
HardwareSensor::HardwareSensor(const sensor_t& sensor)
: mSensorDevice(SensorDevice::getInstance()),
mSensor(&sensor)
mSensor(&sensor, mSensorDevice.getHalDeviceVersion())
{
ALOGI("%s", sensor.name);
}
@ -50,6 +50,16 @@ status_t HardwareSensor::activate(void* ident, bool enabled) {
return mSensorDevice.activate(ident, mSensor.getHandle(), enabled);
}
status_t HardwareSensor::batch(void* ident, int handle, int flags,
int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs) {
return mSensorDevice.batch(ident, mSensor.getHandle(), flags, samplingPeriodNs,
maxBatchReportLatencyNs);
}
status_t HardwareSensor::flush(void* ident, int handle) {
return mSensorDevice.flush(ident, handle);
}
status_t HardwareSensor::setDelay(void* ident, int handle, int64_t ns) {
return mSensorDevice.setDelay(ident, handle, ns);
}

17
services/sensorservice/SensorInterface.h
View File

@ -38,6 +38,20 @@ public:
virtual status_t activate(void* ident, bool enabled) = 0;
virtual status_t setDelay(void* ident, int handle, int64_t ns) = 0;
// Not all sensors need to support batching.
virtual status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs) {
if (maxBatchReportLatencyNs == 0) {
return setDelay(ident, handle, samplingPeriodNs);
}
return -EINVAL;
}
virtual status_t flush(void* ident, int handle) {
return -EINVAL;
}
virtual Sensor getSensor() const = 0;
virtual bool isVirtual() const = 0;
virtual void autoDisable(void *ident, int handle) { }
@ -59,7 +73,10 @@ public:
const sensors_event_t& event);
virtual status_t activate(void* ident, bool enabled);
virtual status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs);
virtual status_t setDelay(void* ident, int handle, int64_t ns);
virtual status_t flush(void* ident, int handle);
virtual Sensor getSensor() const;
virtual bool isVirtual() const { return false; }
virtual void autoDisable(void *ident, int handle);

72
services/sensorservice/SensorService.cpp
View File

@ -213,6 +213,11 @@ status_t SensorService::dump(int fd, const Vector<String16>& args)
? "on-demand | "
: "one-shot | ");
}
if (s.getFifoMaxEventCount() > 0) {
result.appendFormat("getFifoMaxEventCount=%d events | ", s.getFifoMaxEventCount());
} else {
result.append("no batching support | ");
}
switch (s.getType()) {
case SENSOR_TYPE_ROTATION_VECTOR:
@ -384,7 +389,6 @@ bool SensorService::threadLoop()
// We have read the data, upper layers should hold the wakelock.
if (wakeLockAcquired) release_wake_lock(WAKE_LOCK_NAME);
} while (count >= 0 || Thread::exitPending());
ALOGW("Exiting SensorService::threadLoop => aborting...");
@ -502,7 +506,7 @@ void SensorService::cleanupConnection(SensorEventConnection* c)
}
status_t SensorService::enable(const sp<SensorEventConnection>& connection,
int handle)
int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags)
{
if (mInitCheck != NO_ERROR)
return mInitCheck;
@ -511,7 +515,6 @@ status_t SensorService::enable(const sp<SensorEventConnection>& connection,
if (sensor == NULL) {
return BAD_VALUE;
}
Mutex::Autolock _l(mLock);
SensorRecord* rec = mActiveSensors.valueFor(handle);
if (rec == 0) {
@ -548,10 +551,24 @@ status_t SensorService::enable(const sp<SensorEventConnection>& connection,
handle, connection.get());
}
// we are setup, now enable the sensor.
status_t err = sensor->activate(connection.get(), true);
nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
if (samplingPeriodNs < minDelayNs) {
samplingPeriodNs = minDelayNs;
}
ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%lld timeout== %lld",
handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs);
status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs,
maxBatchReportLatencyNs);
if (err == NO_ERROR) {
ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle);
err = sensor->activate(connection.get(), true);
}
if (err != NO_ERROR) {
// enable has failed, reset our state.
// batch/activate has failed, reset our state.
cleanupWithoutDisableLocked(connection, handle);
}
return err;
@ -618,12 +635,18 @@ status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection
ns = minDelayNs;
}
if (ns < MINIMUM_EVENTS_PERIOD)
ns = MINIMUM_EVENTS_PERIOD;
return sensor->setDelay(connection.get(), handle, ns);
}
status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
int handle) {
if (mInitCheck != NO_ERROR) return mInitCheck;
SensorInterface* sensor = mSensorMap.valueFor(handle);
if (sensor == NULL) {
return BAD_VALUE;
}
return sensor->flush(connection.get(), handle);
}
// ---------------------------------------------------------------------------
SensorService::SensorRecord::SensorRecord(
@ -707,11 +730,21 @@ status_t SensorService::SensorEventConnection::sendEvents(
Mutex::Autolock _l(mConnectionLock);
size_t i=0;
while (i<numEvents) {
const int32_t curr = buffer[i].sensor;
if (mSensorInfo.indexOf(curr) >= 0) {
int32_t curr = buffer[i].sensor;
if (buffer[i].type == SENSOR_TYPE_META_DATA) {
ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
buffer[i].meta_data.sensor);
// Setting curr to the correct sensor to ensure the sensor events per connection are
// filtered correctly. buffer[i].sensor is zero for meta_data events.
curr = buffer[i].meta_data.sensor;
}
if (mSensorInfo.indexOf(curr) >= 0) {
do {
scratch[count++] = buffer[i++];
} while ((i<numEvents) && (buffer[i].sensor == curr));
scratch[count] = buffer[i];
++count; ++i;
} while ((i<numEvents) && ((buffer[i].sensor == curr) ||
(buffer[i].type == SENSOR_TYPE_META_DATA &&
buffer[i].meta_data.sensor == curr)));
} else {
i++;
}
@ -740,11 +773,13 @@ sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const
}
status_t SensorService::SensorEventConnection::enableDisable(
int handle, bool enabled)
int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
int reservedFlags)
{
status_t err;
if (enabled) {
err = mService->enable(this, handle);
err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
reservedFlags);
} else {
err = mService->disable(this, handle);
}
@ -752,11 +787,14 @@ status_t SensorService::SensorEventConnection::enableDisable(
}
status_t SensorService::SensorEventConnection::setEventRate(
int handle, nsecs_t ns)
int handle, nsecs_t samplingPeriodNs)
{
return mService->setEventRate(this, handle, ns);
return mService->setEventRate(this, handle, samplingPeriodNs);
}
status_t SensorService::SensorEventConnection::flushSensor(int handle) {
return mService->flushSensor(this, handle);
}
// ---------------------------------------------------------------------------
}; // namespace android

11
services/sensorservice/SensorService.h
View File

@ -52,7 +52,6 @@ class SensorService :
{
friend class BinderService<SensorService>;
static const nsecs_t MINIMUM_EVENTS_PERIOD = 1000000; // 1000 Hz
static const char* WAKE_LOCK_NAME;
static char const* getServiceName() ANDROID_API { return "sensorservice"; }
@ -74,8 +73,10 @@ class SensorService :
virtual ~SensorEventConnection();
virtual void onFirstRef();
virtual sp<BitTube> getSensorChannel() const;
virtual status_t enableDisable(int handle, bool enabled);
virtual status_t setEventRate(int handle, nsecs_t ns);
virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
nsecs_t maxBatchReportLatencyNs, int reservedFlags);
virtual status_t setEventRate(int handle, nsecs_t samplingPeriodNs);
virtual status_t flushSensor(int handle);
sp<SensorService> const mService;
sp<BitTube> const mChannel;
@ -141,9 +142,11 @@ class SensorService :
public:
void cleanupConnection(SensorEventConnection* connection);
status_t enable(const sp<SensorEventConnection>& connection, int handle);
status_t enable(const sp<SensorEventConnection>& connection, int handle,
nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags);
status_t disable(const sp<SensorEventConnection>& connection, int handle);
status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns);
status_t flushSensor(const sp<SensorEventConnection>& connection, int handle);
};
// ---------------------------------------------------------------------------