DeviceAdaptor* SensorManager::requestDeviceAdaptor(const QString& id)
{
sensordLogD() << "Requesting adaptor: " << id;
clearError();
if( id.contains(';') ) // no parameter passing in release
{
setError( SmIdNotRegistered, QString(tr("unknown adaptor id '%1'").arg(id)) );
return false;
}
DeviceAdaptor* da = NULL;
QMap<QString, DeviceAdaptorInstanceEntry>::iterator entryIt = deviceAdaptorInstanceMap_.find(id);
if ( entryIt != deviceAdaptorInstanceMap_.end() )
{
if ( entryIt.value().adaptor_ )
{
Q_ASSERT( entryIt.value().adaptor_ );
da = entryIt.value().adaptor_;
entryIt.value().cnt_++;
sensordLogD() << "Found adaptor '" << id << "'. Ref count: " << entryIt.value().cnt_;
}
else
{
QString type = entryIt.value().type_;
if ( deviceAdaptorFactoryMap_.contains(type) )
{
da = deviceAdaptorFactoryMap_[type](id);
Q_ASSERT( da );
da->init();
ParameterParser::applyPropertyMap(da, entryIt.value().propertyMap_);
bool ok = da->startAdaptor();
if (ok)
{
entryIt.value().adaptor_ = da;
entryIt.value().cnt_++;
sensordLogD() << "Instantiated adaptor '" << id << "'. Valid = " << da->isValid();
}
else
{
setError(SmAdaptorNotStarted, QString(tr("adaptor '%1' can not be started").arg(id)) );
delete da;
da = NULL;
}
}
else
{
setError( SmFactoryNotRegistered, QString(tr("unknown adaptor type '%1'").arg(type)) );
}
}
}
else
{
setError( SmIdNotRegistered, QString(tr("unknown adaptor id '%1'").arg(id)) );
}
return da;
}
unsigned int IioAdaptor::interval() const
{
int value = 100;
sensordLogD() << "Returning dummy value in interval(): " << value;
return value;
}
void SensorManager::lostClient(int sessionId)
{
for(QMap<QString, SensorInstanceEntry>::iterator it = sensorInstanceMap_.begin(); it != sensorInstanceMap_.end(); ++it) {
if (it.value().sessions_.contains(sessionId)) {
sensordLogD() << "[SensorManager]: Lost session " << sessionId << " detected as " << it.key();
sensordLogD() << "[SensorManager]: Stopping sessionId " << sessionId;
it.value().sensor_->stop(sessionId);
sensordLogD() << "[SensorManager]: Releasing sessionId " << sessionId;
releaseSensor(it.key(), sessionId);
return;
}
}
sensordLogW() << "[SensorManager]: Lost session " << sessionId << " detected, but not found from session list";
}
void SensorManager::displayStateChanged(bool displayState)
{
sensordLogD() << "Signal detected, display state changed to: " << displayState;
if (displayState) {
/// Emit signal to make background calibration resume from sleep
emit displayOn();
#ifdef SENSORFW_MCE_WATCHER
if (!mceWatcher_->PSMEnabled())
#endif // SENSORFW_MCE_WATCHER
{
emit resumeCalibration();
}
}
foreach (const DeviceAdaptorInstanceEntry& adaptor, deviceAdaptorInstanceMap_) {
if (adaptor.adaptor_) {
if (displayState) {
adaptor.adaptor_->setScreenBlanked(false);
adaptor.adaptor_->resume();
} else {
adaptor.adaptor_->setScreenBlanked(true);
adaptor.adaptor_->standby();
}
}
}
}
int SensorManager::requestSensor(const QString& id)
{
sensordLogD() << "Requesting sensor: " << id;
clearError();
QString cleanId = getCleanId(id);
QMap<QString, SensorInstanceEntry>::iterator entryIt = sensorInstanceMap_.find(cleanId);
if ( entryIt == sensorInstanceMap_.end() )
{
setError(SmIdNotRegistered, QString(tr("requested sensor id '%1' not registered")).arg(cleanId));
return INVALID_SESSION;
}
int sessionId = createNewSessionId();
if(!entryIt.value().sensor_)
{
AbstractSensorChannel* sensor = addSensor(id);
if ( sensor == NULL )
{
setError(SmNotInstantiated, tr("sensor has not been instantiated"));
return INVALID_SESSION;
}
entryIt.value().sensor_ = sensor;
}
entryIt.value().sessions_.insert(sessionId);
return sessionId;
}
void MagnetometerAdaptor::processSample(int pathId, int fd)
{
Q_UNUSED(pathId);
struct ak8974_data mag_data;
unsigned int bytesRead = read(fd, &mag_data, sizeof(mag_data));
if (bytesRead < sizeof(mag_data)) {
sensordLogW() << "read " << bytesRead << " bytes out of expected " << sizeof(mag_data) << " bytes. Previous error: " << strerror(errno);
//return;
}
if (!mag_data.valid) {
// Can't trust this, printed for curiosity
sensordLogD() << "Invalid sample received from magnetometer";
}
sensordLogT() << "Magnetometer reading: " << mag_data.x << ", " << mag_data.y << ", " << mag_data.z;
CalibratedMagneticFieldData* sample = magnetometerBuffer_->nextSlot();
sample->timestamp_ = Utils::getTimeStamp();
sample->x_ = mag_data.x;
sample->y_ = mag_data.y;
sample->z_ = mag_data.z;
magnetometerBuffer_->commit();
magnetometerBuffer_->wakeUpReaders();
}
void MagCalibrationChainPlugin::Register(class Loader&)
{
sensordLogD() << "registering magcalibrationchain";
SensorManager& sm = SensorManager::instance();
sm.registerFilter<CalibrationFilter>("calibrationfilter");
sm.registerChain<MagCalibrationChain>("magcalibrationchain");
}
bool HybrisProximityAdaptor::startSensor()
{
if (!(HybrisAdaptor::startSensor()))
return false;
sensordLogD() << "HybrisProximityAdaptor start\n";
return true;
}
IioAdaptor::IioAdaptor(const QString& id) :
SysfsAdaptor(id, SysfsAdaptor::IntervalMode, true)
{
int i;
sensordLogD() << "Creating IioAdaptor with id: " << id;
dev_accl_ = sensorExists(IIO_ACCELEROMETER);
dev_gyro_ = -1;/*sensorExists(IIO_GYROSCOPE);*/
dev_magn_ = -1;/*sensorExists(IIO_MAGNETOMETER);*/
if (dev_accl_ != -1) {
iioAcclBuffer_ = new DeviceAdaptorRingBuffer<TimedXyzData>(1);
QString desc = "Industrial I/O accelerometer (" + devices_[dev_accl_].name +")";
sensordLogD() << "Accelerometer found";
setAdaptedSensor("accelerometer", desc, iioAcclBuffer_);
}
if (dev_gyro_ != -1) {
iioGyroBuffer_ = new DeviceAdaptorRingBuffer<TimedXyzData>(1);
QString desc = "Industrial I/O gyroscope (" + devices_[dev_gyro_].name +")";
sensordLogD() << "Gyroscope found";
setAdaptedSensor("gyroscope", desc, iioGyroBuffer_);
}
if (dev_magn_ != -1) {
iioMagnBuffer_ = new DeviceAdaptorRingBuffer<TimedXyzData>(1);
QString desc = "Industrial I/O magnetometer (" + devices_[dev_magn_].name +")";
sensordLogD() << "Magnetometer found";
setAdaptedSensor("magnetometer", desc, iioMagnBuffer_);
}
// Disable and then enable devices to make sure they allow changing settings
for (i = 0; i < IIO_MAX_DEVICES; ++i) {
if (dev_accl_ == i || dev_gyro_ == i || dev_magn_ == i) {
deviceEnable(i, false);
deviceEnable(i, true);
addDevice(i);
}
}
//introduceAvailableDataRange(DataRange(0, 65535, 1));
setAdaptedSensor("accelerometer", "IIO Accelerometer", iioAcclBuffer_);
setDescription("Sysfs Industrial I/O sensor adaptor");
}
bool HybrisGyroscopeAdaptor::startSensor()
{
if (!(HybrisAdaptor::startSensor()))
return false;
sensordLogD() << "HybrisGyroscopeAdaptor start\n";
return true;
}
bool HybrisAccelerometerAdaptor::startSensor()
{
if (!(HybrisAdaptor::startSensor()))
return false;
sensordLogD() << "Hybris AccelAdaptor start\n";
return true;
}
bool AbstractSensorChannel::writeToSession(int sessionId, const void* source, int size)
{
if (!(SensorManager::instance().write(sessionId, source, size))) {
sensordLogD() << "AbstractSensor failed to write to session " << sessionId;
return false;
}
return true;
}
bool HybrisOrientationAdaptor::startSensor()
{
if (!(HybrisAdaptor::startSensor()))
return false;
sensordLogD() << "Hybris OrientationAdaptor start\n";
return true;
}
void SensorManager::releaseDeviceAdaptor(const QString& id)
{
sensordLogD() << "Releasing adaptor: " << id;
clearError();
if( id.contains(';') ) // no parameter passing in release
{
setError( SmIdNotRegistered, QString(tr("unknown adaptor id '%1'").arg(id)) );
return;
}
QMap<QString, DeviceAdaptorInstanceEntry>::iterator entryIt = deviceAdaptorInstanceMap_.find(id);
if ( entryIt != deviceAdaptorInstanceMap_.end() )
{
if ( entryIt.value().adaptor_ )
{
Q_ASSERT( entryIt.value().adaptor_ );
entryIt.value().cnt_--;
if ( entryIt.value().cnt_ == 0 )
{
sensordLogD() << "Adaptor '" << id << "' has no more references.";
Q_ASSERT( entryIt.value().adaptor_ );
entryIt.value().adaptor_->stopAdaptor();
/** Fix for NB#242237
delete entryIt.value().adaptor_;
entryIt.value().adaptor_ = 0;
*/
}
else
{
sensordLogD() << "Adaptor '" << id << "' has ref count: " << entryIt.value().cnt_;
}
}
else
{
setError( SmNotInstantiated, QString(tr("adaptor '%1' not instantiated, cannot release").arg(id)) );
}
}
else
{
setError( SmIdNotRegistered, QString(tr("unknown adaptor id '%1'").arg(id)) );
}
}
bool IioAdaptor::setInterval(const unsigned int value, const int sessionId)
{
if (mode() == SysfsAdaptor::IntervalMode)
return SysfsAdaptor::setInterval(value, sessionId);
sensordLogD() << "Ignoring setInterval for " << value;
return true;
}
bool MagCalibrationChain::stop()
{
if (AbstractSensorChannel::stop()) {
sensordLogD() << "Stopping MagCalibrationChain";
magAdaptor->stopSensor();
filterBin->stop();
}
return true;
}
void SensorManager::removeSensor(const QString& id)
{
sensordLogD() << "Removing sensor: " << id;
QMap<QString, SensorInstanceEntry>::iterator entryIt = sensorInstanceMap_.find(id);
bus().unregisterObject(OBJECT_PATH + "/" + id);
delete entryIt.value().sensor_;
entryIt.value().sensor_ = 0;
}
void HybrisProximityAdaptor::processSample(const sensors_event_t& data)
{
ProximityData *d = buffer->nextSlot();
d->timestamp_ = quint64(data.timestamp * .0001);
bool near = false;
sensordLogD() << "Guhl: HybrisProximityAdaptor processSample absinfo.value=" << data.distance << ", maxRange=" << maxRange << "\n";
if (data.distance < maxRange) {
sensordLogD() << "Guhl: HybrisProximityAdaptor processSample setting near=true.\n";
near = true;
// near = false;
}
d->withinProximity_ = near;
d->value_ = data.distance;
buffer->commit();
buffer->wakeUpReaders();
}
bool GyroscopeAdaptor::setInterval(const unsigned int value, const int sessionId)
{
if (mode() == SysfsAdaptor::IntervalMode)
return SysfsAdaptor::setInterval(value, sessionId);
int rate = value==0?100:1000/value;
sensordLogD() << "Setting poll interval for " << dataRatePath_ << " to " << rate;
QByteArray dataRateString(QString("%1\n").arg(rate).toLocal8Bit());
return writeToFile(dataRatePath_, dataRateString);
}
bool SocketHandler::listen(const QString& serverName)
{
if (m_server->isListening()) {
sensordLogW() << "[SocketHandler]: Already listening";
return false;
}
bool unlinkDone = false;
while (!m_server->listen(serverName) && !unlinkDone && serverName[0] == QChar('/'))
{
if ( unlink(serverName.toLocal8Bit().constData()) == 0) {
sensordLogD() << "[SocketHandler]: Unlinked stale socket" << serverName;
} else {
sensordLogD() << m_server->errorString();
}
unlinkDone = true;
}
return m_server->isListening();
}
bool ALSSensorChannel::stop()
{
sensordLogD() << "Stopping ALSSensorChannel";
if (AbstractSensorChannel::stop()) {
alsAdaptor_->stopSensor();
filterBin_->stop();
marshallingBin_->stop();
}
return true;
}
bool GyroscopeSensorChannel::stop()
{
sensordLogD() << "Stopping GyroscopeSensorChannel";
if (AbstractSensorChannel::stop()) {
gyroscopeAdaptor_->stopSensor();
filterBin_->stop();
marshallingBin_->stop();
}
return true;
}
bool SocketHandler::write(int id, const void* source, int size)
{
QMap<int, SessionData*>::iterator it = m_idMap.find(id);
if (it == m_idMap.end())
{
sensordLogD() << "[SocketHandler]: Trying to write to nonexistent session (normal, no panic).";
return false;
}
sensordLogT() << "[SocketHandler]: Writing to session " << id;
return (*it)->write(source, size);
}
FilterBase* SensorManager::instantiateFilter(const QString& id)
{
sensordLogD() << "Instantiating filter: " << id;
QMap<QString, FilterFactoryMethod>::iterator it = filterFactoryMap_.find(id);
if(it == filterFactoryMap_.end())
{
sensordLogW() << "Filter " << id << " not found.";
return NULL;
}
return it.value()();
}
AbstractChain* SensorManager::requestChain(const QString& id)
{
sensordLogD() << "Requesting chain: " << id;
clearError();
AbstractChain* chain = NULL;
QMap<QString, ChainInstanceEntry>::iterator entryIt = chainInstanceMap_.find(id);
if (entryIt != chainInstanceMap_.end())
{
if (entryIt.value().chain_ )
{
chain = entryIt.value().chain_;
entryIt.value().cnt_++;
sensordLogD() << "Found chain '" << id << "'. Ref count: " << entryIt.value().cnt_;
}
else
{
QString type = entryIt.value().type_;
if (chainFactoryMap_.contains(type))
{
chain = chainFactoryMap_[type](id);
Q_ASSERT(chain);
sensordLogD() << "Instantiated chain '" << id << "'. Valid = " << chain->isValid();
entryIt.value().cnt_++;
entryIt.value().chain_ = chain;
}
else
{
setError( SmFactoryNotRegistered, QString(tr("unknown chain type '%1'").arg(type)) );
}
}
}
else
{
setError( SmIdNotRegistered, QString(tr("unknown chain id '%1'").arg(id)) );
}
return chain;
}
bool SensorManager::loadPlugin(const QString& name)
{
sensordLogD() << "Loading plugin: " << name;
QString errorMessage;
bool result;
Loader& l = Loader::instance();
if (! (result = l.loadPlugin(name, &errorMessage))) {
setError (SmCanNotRegisterObject, errorMessage);
}
return result;
}
bool SensorManager::releaseSensor(const QString& id, int sessionId)
{
sensordLogD() << "Releasing sensor '" << id << "' for session: " << sessionId;
clearError();
if( id.contains(';') ) // no parameter passing in release
{
sensordLogW() << "Invalid parameter passed to releaseSensor(): " << id;
return false;
}
QMap<QString, SensorInstanceEntry>::iterator entryIt = sensorInstanceMap_.find(id);
if ( entryIt == sensorInstanceMap_.end() )
{
setError( SmIdNotRegistered, QString(tr("requested sensor id '%1' not registered").arg(id)) );
return false;
}
/// Remove any property requests by this session
entryIt.value().sensor_->removeSession(sessionId);
if (entryIt.value().sessions_.empty())
{
setError(SmNotInstantiated, tr("sensor has not been instantiated, no session to release"));
return false;
}
bool returnValue = false;
if(entryIt.value().sessions_.remove( sessionId ))
{
/** Fix for NB#242237
if ( entryIt.value().sessions_.empty() )
{
removeSensor(id);
}
*/
returnValue = true;
}
else
{
// sessionId does not correspond to a request
setError( SmNotInstantiated, tr("invalid sessionId, no session to release") );
}
socketHandler_->removeSession(sessionId);
return returnValue;
}
bool CompassChain::stop()
{
if (AbstractSensorChannel::stop()) {
sensordLogD() << "Stopping compassChain";
// if (orientAdaptor->isValid()) {
// orientAdaptor->stopSensor();
// } else {
accelerometerChain->stop();
magChain->stop();
// }
filterBin->stop();
}
return true;
}
bool CompassChain::stop()
{
if (AbstractSensorChannel::stop()) {
sensordLogD() << "Stopping compassChain";
if (hasOrientationAdaptor) {
orientAdaptor->stopSensor();
} else {
accelerometerChain->stop();
magChain->stop();
}
filterBin->stop();
}
return true;
}
void DeclinationFilter::correct(unsigned, const CompassData* data)
{
CompassData newOrientation(*data);
if (newOrientation.timestamp_ - lastUpdate_ > updateInterval_) {
loadSettings();
lastUpdate_ = newOrientation.timestamp_;
}
newOrientation.correctedDegrees_ = newOrientation.degrees_;
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
if (declinationCorrection_) {
newOrientation.correctedDegrees_ += declinationCorrection_;
#else
if (declinationCorrection_.loadAcquire() != 0) {
newOrientation.correctedDegrees_ += declinationCorrection_.loadAcquire();
#endif
newOrientation.correctedDegrees_ %= 360;
// sensordLogT() << "DeclinationFilter corrected degree " << newOrientation.degrees_ << " => " << newOrientation.correctedDegrees_ << ". Level: " << newOrientation.level_;
}
orientation_ = newOrientation;
source_.propagate(1, &orientation_);
}
void DeclinationFilter::loadSettings()
{
QSettings confFile("/etc/xdg/sensorfw/location.conf", QSettings::IniFormat);
confFile.beginGroup("location");
double declination = confFile.value("declination",0).toDouble();
if (declination != 0) {
declinationCorrection_ = declination;
}
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
sensordLogD() << "Fetched declination correction from GConf: " << declinationCorrection_;
#else
sensordLogD() << "Fetched declination correction from GConf: " << declinationCorrection_.loadAcquire();
#endif
}