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

Merge "SensorService flush fixes." into lmp-dev

Browse Source
This commit is contained in:
Aravind Akella 2014-09-05 19:53:36 +00:00 committed by Android (Google) Code Review
commit 253c4720af
3 changed files with 64 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/gui/SensorEventQueue.h
View File

@ -27,7 +27,7 @@
#include <gui/BitTube.h>
// ----------------------------------------------------------------------------
#define WAKE_UP_SENSOR_EVENT_NEEDS_ACK (1U << 31)
#define WAKE_UP_SENSOR_EVENT_NEEDS_ACK (1U << 30)
struct ALooper;
struct ASensorEvent;

79
services/sensorservice/SensorService.cpp
View File

@ -807,29 +807,36 @@ status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection
return sensor->setDelay(connection.get(), handle, ns);
}
status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
int handle) {
status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection) {
if (mInitCheck != NO_ERROR) return mInitCheck;
SensorDevice& dev(SensorDevice::getInstance());
const int halVersion = dev.getHalDeviceVersion();
status_t err(NO_ERROR);
Mutex::Autolock _l(mLock);
// Loop through all sensors for this connection and call flush on each of them.
for (size_t i = 0; i < connection->mSensorInfo.size(); ++i) {
const int handle = connection->mSensorInfo.keyAt(i);
SensorInterface* sensor = mSensorMap.valueFor(handle);
if (sensor == NULL) {
return BAD_VALUE;
}
if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) {
return BAD_VALUE;
}
if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
ALOGE("flush called on a one-shot sensor");
return INVALID_OPERATION;
err = INVALID_OPERATION;
continue;
}
status_t ret = sensor->flush(connection.get(), handle);
if (ret == NO_ERROR) {
SensorEventConnection::FlushInfo& flushInfo = connection->mSensorInfo.editValueFor(handle);
if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || isVirtualSensor(handle)) {
// For older devices just increment pending flush count which will send a trivial
// flush complete event.
flushInfo.mPendingFlushEventsToSend++;
} else {
status_t err_flush = sensor->flush(connection.get(), handle);
if (err_flush == NO_ERROR) {
SensorRecord* rec = mActiveSensors.valueFor(handle);
if (rec != NULL) rec->addPendingFlushConnection(connection);
}
return ret;
err = (err_flush != NO_ERROR) ? err_flush : err;
}
}
return err;
}
bool SensorService::canAccessSensor(const Sensor& sensor) {
@ -1034,7 +1041,7 @@ void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
}
status_t SensorService::SensorEventConnection::sendEvents(
sensors_event_t const* buffer, size_t numEvents,
sensors_event_t* buffer, size_t numEvents,
sensors_event_t* scratch) {
// filter out events not for this connection
size_t count = 0;
@ -1042,6 +1049,12 @@ status_t SensorService::SensorEventConnection::sendEvents(
if (scratch) {
size_t i=0;
while (i<numEvents) {
// Flush complete events can be invalidated. If this event has been invalidated
// before, ignore and proceed to the next event.
if (buffer[i].flags & SENSOR_EVENT_INVALID_FLAG) {
++i;
continue;
}
int32_t sensor_handle = buffer[i].sensor;
if (buffer[i].type == SENSOR_TYPE_META_DATA) {
ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
@ -1065,9 +1078,12 @@ status_t SensorService::SensorEventConnection::sendEvents(
if (rec && rec->getFirstPendingFlushConnection() == this) {
rec->removeFirstPendingFlushConnection();
flushInfo.mFirstFlushPending = false;
++i;
// Invalidate this flush_complete_event so that it cannot be used by other
// connections.
buffer[i].flags |= SENSOR_EVENT_INVALID_FLAG;
ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ",
buffer[i].meta_data.sensor);
++i;
continue;
}
}
@ -1080,6 +1096,10 @@ status_t SensorService::SensorEventConnection::sendEvents(
}
do {
if (buffer[i].flags & SENSOR_EVENT_INVALID_FLAG) {
++i;
continue;
}
if (buffer[i].type == SENSOR_TYPE_META_DATA) {
// Check if this connection has called flush() on this sensor. Only if
// a flush() has been explicitly called, send a flush_complete_event.
@ -1087,6 +1107,9 @@ status_t SensorService::SensorEventConnection::sendEvents(
if (rec && rec->getFirstPendingFlushConnection() == this) {
rec->removeFirstPendingFlushConnection();
scratch[count++] = buffer[i];
// Invalidate this flush_complete_event so that it cannot be used by
// other connections.
buffer[i].flags |= SENSOR_EVENT_INVALID_FLAG;
}
++i;
} else {
@ -1333,27 +1356,7 @@ status_t SensorService::SensorEventConnection::setEventRate(
}
status_t SensorService::SensorEventConnection::flush() {
SensorDevice& dev(SensorDevice::getInstance());
const int halVersion = dev.getHalDeviceVersion();
Mutex::Autolock _l(mConnectionLock);
status_t err(NO_ERROR);
// Loop through all sensors for this connection and call flush on each of them.
for (size_t i = 0; i < mSensorInfo.size(); ++i) {
const int handle = mSensorInfo.keyAt(i);
FlushInfo& flushInfo = mSensorInfo.editValueFor(handle);
if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) {
// For older devices just increment pending flush count which will send a trivial
// flush complete event.
flushInfo.mPendingFlushEventsToSend++;
} else {
status_t err_flush = mService->flushSensor(this, handle);
if (err_flush != NO_ERROR) {
ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush));
}
err = (err_flush != NO_ERROR) ? err_flush : err;
}
}
return err;
return mService->flushSensor(this);
}
int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* data) {

13
services/sensorservice/SensorService.h
View File

@ -45,6 +45,14 @@
// For older HALs which don't support batching, use a smaller socket buffer size.
#define SOCKET_BUFFER_SIZE_NON_BATCHED 4 * 1024
// Flags for sensors_event_t.flag. Using only the most significant two bits for flags.
// MSB is to invalidate a sensor_event (typically a flush_complete_event) so that
// it won't be used by other connections.
// MSB 2nd bit is used to indicate whether the event needs to be acknowledged or not.
// This is typically used for WAKE_UP sensors. WAKE_UP_SENSOR_EVENT_NEEDS_ACK is defined
// in SensorEveneQueue.h
#define SENSOR_EVENT_INVALID_FLAG (1U << 31)
struct sensors_poll_device_t;
struct sensors_module_t;
@ -148,7 +156,7 @@ class SensorService :
public:
SensorEventConnection(const sp<SensorService>& service, uid_t uid);
status_t sendEvents(sensors_event_t const* buffer, size_t count,
status_t sendEvents(sensors_event_t* buffer, size_t count,
sensors_event_t* scratch);
bool hasSensor(int32_t handle) const;
bool hasAnySensor() const;
@ -229,7 +237,6 @@ class SensorService :
DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;
SortedVector< wp<SensorEventConnection> > mActiveConnections;
bool mWakeLockAcquired;
// The size of this vector is constant, only the items are mutable
KeyedVector<int32_t, sensors_event_t> mLastEventSeen;
@ -239,7 +246,7 @@ public:
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);
status_t flushSensor(const sp<SensorEventConnection>& connection);
};
// ---------------------------------------------------------------------------