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

Merge "Change API from flush(handle) to flush(). Call flush on all active sensors in the given SensorEventConnection." into klp-dev

Browse Source
This commit is contained in:
Aravind Akella 2013-10-11 02:05:40 +00:00 committed by Android (Google) Code Review
commit 5d6aa95129
6 changed files with 25 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/gui/ISensorEventConnection.h
View File

@ -39,7 +39,7 @@ public:
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;
virtual status_t flush() = 0;
};
// ----------------------------------------------------------------------------

2
include/gui/SensorEventQueue.h
View File

@ -74,7 +74,7 @@ public:
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;
status_t flush() const;
private:
sp<Looper> getLooper() const;

6
libs/gui/ISensorEventConnection.cpp
View File

@ -77,10 +77,9 @@ public:
return reply.readInt32();
}
virtual status_t flushSensor(int handle) {
virtual status_t flush() {
Parcel data, reply;
data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
data.writeInt32(handle);
remote()->transact(FLUSH_SENSOR, data, &reply);
return reply.readInt32();
}
@ -122,8 +121,7 @@ status_t BnSensorEventConnection::onTransact(
} break;
case FLUSH_SENSOR: {
CHECK_INTERFACE(ISensorEventConnection, data, reply);
int handle = data.readInt32();
status_t result = flushSensor(handle);
status_t result = flush();
reply->writeInt32(result);
return NO_ERROR;
} break;

4
libs/gui/SensorEventQueue.cpp
View File

@ -132,8 +132,8 @@ status_t SensorEventQueue::enableSensor(int32_t handle, int32_t samplingPeriodUs
us2ns(maxBatchReportLatencyUs), reservedFlags);
}
status_t SensorEventQueue::flushSensor(int32_t handle) const {
return mSensorEventConnection->flushSensor(handle);
status_t SensorEventQueue::flush() const {
return mSensorEventConnection->flush();
}
status_t SensorEventQueue::disableSensor(int32_t handle) const {

22
services/sensorservice/SensorService.cpp
View File

@ -679,8 +679,12 @@ 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;
if (sensor == NULL) {
return BAD_VALUE;
}
if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) {
ALOGE("flush called on Significant Motion sensor");
return INVALID_OPERATION;
}
SensorDevice& dev(SensorDevice::getInstance());
@ -934,8 +938,18 @@ status_t SensorService::SensorEventConnection::setEventRate(
return mService->setEventRate(this, handle, samplingPeriodNs);
}
status_t SensorService::SensorEventConnection::flushSensor(int handle) {
return mService->flushSensor(this, handle);
status_t SensorService::SensorEventConnection::flush() {
Mutex::Autolock _l(mConnectionLock);
status_t err(NO_ERROR);
for (size_t i = 0; i < mSensorInfo.size(); ++i) {
const int handle = mSensorInfo.keyAt(i);
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;
}
// ---------------------------------------------------------------------------

2
services/sensorservice/SensorService.h
View File

@ -79,7 +79,7 @@ class SensorService :
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);
virtual status_t flush();
// Count the number of flush complete events which are about to be dropped in the buffer.
// Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be
// sent separately before the next batch of events.