void QGeoSatelliteInfoSourceAndroid::onSatelliteInfoAvailable(QList<QtLocationJni::SatelliteInfo> &satInfoList)
{
QtLocationJni::SatelliteInfo satInfo;
QList<QGeoSatelliteInfo> qSatellites;
if (m_satelliteInfoState & QGeoSatelliteInfoSourceAndroid::RequestActive)
{
m_requestTimer->stop();
m_satelliteInfoState &= ~QGeoSatelliteInfoSourceAndroid::RequestActive;
if(m_satelliteInfoState & QGeoSatelliteInfoSourceAndroid::Stopped)
{
QtLocationJni::satelliteDisableupdates(this);
}
}
foreach(satInfo,satInfoList)
{
QGeoSatelliteInfo qSatellite;
qSatellite.setPrnNumber(satInfo.m_prnNumber);
//10 log10 (ratio of the powers)
int signalStrength=(satInfo.m_signalStrength==0) ? 0:(int)(10 * ::log10(satInfo.m_signalStrength));
qSatellite.setSignalStrength(signalStrength);
qSatellite.setAttribute(QGeoSatelliteInfo::Elevation,satInfo.m_elevation);
qSatellite.setAttribute(QGeoSatelliteInfo::Azimuth,satInfo.m_azimuth);
qSatellites.append(qSatellite);
}
/*
This is _only_ called when QGeoSatelliteInfoValidator::valid() returns true for the position.
This means that it is implied that:
- (data.dwValidFields & GPS_VALID_SATELLITE_COUNT) != 0
- (data.dwValidFields & GPS_VALID_SATELLITES_IN_VIEW) != 0
- (data.dwValidFields & GPS_VALID_SATELLITES_IN_VIEW_PRNS) != 0
- (data.dwValidFields & GPS_VALID_SATELLITES_IN_VIEW_SIGNAL_TO_NOISE_RATIO) != 0
This guarantees that the newly created position will be valid.
If the code is changed such that this is no longer guaranteed then this method will need to be
updated to test for those conditions.
*/
void QGeoSatelliteInfoSourceWinCE::dataUpdated(GPS_POSITION data)
{
// Satellites in view are hashed on the PRN values since the PRN value is how we
// determine which of the satellites are in use.
QHash<int, QGeoSatelliteInfo> satellitesInView;
for (unsigned int i = 0; i < data.dwSatellitesInView; ++i) {
QGeoSatelliteInfo satellite;
satellite.setPrnNumber(data.rgdwSatellitesInViewPRNs[i]);
satellite.setSignalStrength(data.rgdwSatellitesInViewSignalToNoiseRatio[i]);
// The following properties are optional, and so are set if the data is present and valid
// in the GPS_POSITION structure.
if ((data.dwValidFields & GPS_VALID_SATELLITES_IN_VIEW_AZIMUTH) != 0) {
satellite.setAttribute(QGeoSatelliteInfo::Azimuth,
data.rgdwSatellitesInViewAzimuth[i]);
}
if ((data.dwValidFields & GPS_VALID_SATELLITES_IN_VIEW_ELEVATION) != 0) {
satellite.setAttribute(QGeoSatelliteInfo::Elevation,
data.rgdwSatellitesInViewElevation[i]);
}
satellitesInView.insert(satellite.prnNumber(), satellite);
}
emit satellitesInViewUpdated(satellitesInView.values());
// If the PRN data for the satellites which were used is unavailable we are done...
if ((data.dwValidFields & GPS_VALID_SATELLITES_USED_PRNS) == 0)
return;
// ...otherwise we construct the list of satellites which are in use and emit the appropriate
// signal
QList<QGeoSatelliteInfo> satellitesInUse;
for (unsigned int i = 0; i < data.dwSatelliteCount; ++i) {
int inUsePRN = data.rgdwSatellitesUsedPRNs[i];
if (satellitesInView.contains(inUsePRN))
satellitesInUse << satellitesInView.value(inUsePRN);
}
emit satellitesInUseUpdated(satellitesInUse);
}
void QGeoSatelliteInfoSourceGypsy::satellitesChanged(GypsySatellite* satellite,
GPtrArray* satellites)
{
if (!satellite || !satellites)
return;
// We have satellite data and assume it is valid.
// If a single updateRequest was active, send signals right away.
// If a periodic timer was running (meaning that the client wishes
// to have updates at defined intervals), store the data for later sending.
QList<QtMobility::QGeoSatelliteInfo> lastSatellitesInView;
QList<QtMobility::QGeoSatelliteInfo> lastSatellitesInUse;
unsigned int i;
for (i = 0; i < satellites->len; i++) {
GypsySatelliteDetails *details = (GypsySatelliteDetails*)satellites->pdata[i];
QGeoSatelliteInfo info;
info.setAttribute(QGeoSatelliteInfo::Elevation, details->elevation);
info.setAttribute(QGeoSatelliteInfo::Azimuth, details->azimuth);
info.setPrnNumber(details->satellite_id);
info.setSignalStrength(details->snr);
if (details->in_use)
lastSatellitesInUse.append(info);
lastSatellitesInView.append(info);
}
bool sendUpdates(false);
// If a single updateRequest() has been issued:
if (m_requestOngoing) {
sendUpdates = true;
m_requestTimer.stop();
m_requestOngoing = false;
// If there is no regular updates ongoing, disconnect now.
if (!m_updatesOngoing) {
m_engine->eng_g_signal_handlers_disconnect_by_func(G_OBJECT(m_satellite), (void*)satellites_changed, this);
}
}
// If regular updates are to be delivered as they come:
if (m_updatesOngoing)
sendUpdates = true;
if (sendUpdates) {
emit satellitesInUseUpdated(lastSatellitesInUse);
emit satellitesInViewUpdated(lastSatellitesInView);
}
}
void QGeoSatelliteInfoSourceSimulator::updateData()
{
QList<QGeoSatelliteInfo> satellitesInUse;
QList<QGeoSatelliteInfo> satellitesInView;
QGeoSatelliteInfoData *data = qtSatelliteInfo();
for(int i = 0; i < data->satellites.count(); i++) {
QGeoSatelliteInfoData::SatelliteInfo info = data->satellites.at(i);
QGeoSatelliteInfo satInfo;
satInfo.setPrnNumber(info.prn);
satInfo.setAttribute(QGeoSatelliteInfo::Azimuth, info.azimuth);
satInfo.setAttribute(QGeoSatelliteInfo::Elevation, info.elevation);
satInfo.setSignalStrength(info.signalStrength);
satellitesInView.append(satInfo);
if (info.inUse)
satellitesInUse.append(satInfo);
}
emit satellitesInViewUpdated(satellitesInView);
emit satellitesInUseUpdated(satellitesInUse);
}
// From a QvariantMap representing a location response from the Location Manager fill the lists of
// QGeoSatelliteInfo instances intended to be emitted via satellitesInUseUpdated() and
// satellitesInViewUpdated() signals.
void QGeoSatelliteInfoSourceBbPrivate::populateSatelliteLists(const QVariantMap &map)
{
// populate _currentSatelliteInfo
QVariantMap datMap = map.value("dat").toMap();
QVariantList satelliteList = datMap.value("satellites").toList();
_satellitesInView.clear();
_satellitesInUse.clear();
Q_FOREACH (const QVariant &satelliteData, satelliteList) {
datMap = satelliteData.toMap();
QGeoSatelliteInfo satelliteInfo = QGeoSatelliteInfo();
if (datMap.contains("id"))
satelliteInfo.setSatelliteIdentifier(static_cast<int>(datMap.value("id").toDouble()));
satelliteInfo.setSatelliteSystem(determineSatSystem(satelliteInfo.satelliteIdentifier()));
if (datMap.contains("cno"))
satelliteInfo.setSignalStrength(static_cast<int>(datMap.value("cno").toDouble()));
// attributes
if (datMap.contains("elevation"))
satelliteInfo.setAttribute(QGeoSatelliteInfo::Elevation,
static_cast<qreal>(datMap.value("elevation").toDouble()));
else
satelliteInfo.removeAttribute(QGeoSatelliteInfo::Elevation);
if (datMap.contains("azimuth"))
satelliteInfo.setAttribute(QGeoSatelliteInfo::Azimuth,
static_cast<qreal>(datMap.value("azimuth").toDouble()));
else
satelliteInfo.removeAttribute(QGeoSatelliteInfo::Azimuth);
// each satellite in this list is considered "in view"
_satellitesInView.append(satelliteInfo);
if (datMap.value("used").toBool() == true)
_satellitesInUse.append(satelliteInfo);
}
void QGeoSatelliteInfoSourceNpeBackend::onSatelliteUpdate(const QList<SatelliteData> &satellites)
{
QList<QGeoSatelliteInfo> inUse;
QList<QGeoSatelliteInfo> inView;
QListIterator<SatelliteData> it(satellites);
if (!satellites.empty()) {
while (it.hasNext())
{
QGeoSatelliteInfo satinfo;
const SatelliteData &satellite = it.next();
satinfo.setAttribute(QGeoSatelliteInfo::Elevation, satellite.elevation);
satinfo.setAttribute(QGeoSatelliteInfo::Azimuth, satellite.azimuth);
satinfo.setSatelliteIdentifier(satellite.id);
satinfo.setSignalStrength(satellite.signalStrength);
if (satellite.satSystem == LocationdStrings::PositionInfo::kGPS)
satinfo.setSatelliteSystem(QGeoSatelliteInfo::GPS);
else if (satellite.satSystem == LocationdStrings::PositionInfo::kGLONASS)
satinfo.setSatelliteSystem(QGeoSatelliteInfo::GLONASS);
else
satinfo.setSatelliteSystem(QGeoSatelliteInfo::Undefined);
if (satellite.status & SATELLITES_STATUS_VISIBLE) {
inView.append(satinfo);
if (satellite.status & SATELLITES_STATUS_USED_POS)
inUse.append(satinfo);
}
}
if (inUse.count() > 0) // emit updated signal if satellite list is not empty
emit satellitesInUseUpdated(inUse);
qDebug() << "emit satelliteUpdated signals: in use count: " << inUse.count() << ", in view count: " <<inView.count();
if (inView.count() > 0)
emit satellitesInViewUpdated(inView);
if ( requestTimer->isActive() )
shutdownRequestSession();
}
}
void LiblocationWrapper::locationChanged(LocationGPSDevice *device,
gpointer data)
{
QGeoPositionInfo posInfo;
QGeoCoordinate coordinate;
QGeoSatelliteInfo satInfo;
int satellitesInUseCount = 0;
LiblocationWrapper *object;
if (!data || !device) {
return;
}
object = (LiblocationWrapper *)data;
if (device) {
if (device->fix) {
if (device->fix->fields & LOCATION_GPS_DEVICE_TIME_SET) {
posInfo.setTimestamp(QDateTime::fromTime_t(device->fix->time));
}
if (device->fix->fields & LOCATION_GPS_DEVICE_LATLONG_SET) {
coordinate.setLatitude(device->fix->latitude);
coordinate.setLongitude(device->fix->longitude);
posInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy,
device->fix->eph / 100.0);
posInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy,
device->fix->epv);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_ALTITUDE_SET) {
coordinate.setAltitude(device->fix->altitude);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_SPEED_SET) {
posInfo.setAttribute(QGeoPositionInfo::GroundSpeed,
device->fix->speed / 3.6);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_CLIMB_SET) {
posInfo.setAttribute(QGeoPositionInfo::VerticalSpeed,
device->fix->climb);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_TRACK_SET) {
posInfo.setAttribute(QGeoPositionInfo::Direction,
device->fix->track);
}
}
if (device->satellites_in_view) {
QList<QGeoSatelliteInfo> satsInView;
QList<QGeoSatelliteInfo> satsInUse;
unsigned int i;
for (i = 0;i < device->satellites->len;i++) {
LocationGPSDeviceSatellite *satData =
(LocationGPSDeviceSatellite *)g_ptr_array_index(device->satellites,
i);
satInfo.setSignalStrength(satData->signal_strength);
satInfo.setPrnNumber(satData->prn);
satInfo.setAttribute(QGeoSatelliteInfo::Elevation,
satData->elevation);
satInfo.setAttribute(QGeoSatelliteInfo::Azimuth,
satData->azimuth);
satsInView.append(satInfo);
if (satData->in_use) {
satellitesInUseCount++;
satsInUse.append(satInfo);
}
}
if (!satsInView.isEmpty())
object->satellitesInViewUpdated(satsInView);
if (!satsInUse.isEmpty())
object->satellitesInUseUpdated(satsInUse);
}
}
posInfo.setCoordinate(coordinate);
emit object->positionUpdated(posInfo);
}