void CLbsPositionLogger::readNextPosition()
{
QByteArray line = m_logFile.readLine().trimmed();
if (line.isEmpty()) {
LOG_MODEL_ERROR("CLbsPositionLogger", "no readlien");
return;
}
QList<QByteArray> data = line.split(',');
QGeoCoordinate coordinate;
QGeoPositionInfo info;
bool hasTimestamp = false;
QDateTime timestamp = QDateTime::fromTime_t(data.value(0).toLong(&hasTimestamp), Qt::UTC);
if(hasTimestamp && timestamp.isValid())
info.setTimestamp(timestamp);
double latitude;
bool hasLatitude = false;
latitude = data.value(1).toDouble(&hasLatitude);
if(hasLatitude)
coordinate.setLatitude(latitude);
double longitude;
bool hasLongitude = false;
longitude = data.value(2).toDouble(&hasLongitude);
if(hasLongitude)
coordinate.setLongitude(longitude);
double altitude;
bool hasAltitude = false;
altitude = data.value(3).toDouble(&hasAltitude);
if(hasAltitude)
coordinate.setAltitude(altitude);
info.setCoordinate(coordinate);
double HorizontalAccuracy;
bool hasHorizontalAccuracy = false;
HorizontalAccuracy = data.value(4).toDouble(&hasHorizontalAccuracy);
if(hasHorizontalAccuracy)
info.setAttribute(QGeoPositionInfo::HorizontalAccuracy, HorizontalAccuracy);
double Direction;
bool hasDirection = false;
Direction = data.value(5).toDouble(&hasDirection);
if(hasDirection)
info.setAttribute(QGeoPositionInfo::Direction, Direction);
double GroundSpeed;
bool hasGroundSpeed = false;
GroundSpeed = data.value(6).toDouble(&hasGroundSpeed);
if(hasGroundSpeed)
info.setAttribute(QGeoPositionInfo::GroundSpeed, GroundSpeed);
if (info.isValid()) {
m_lastPosition = info;
emit positionUpdated(info);
}
}
QGeoPositionInfo LiblocationWrapper::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const
{
QGeoPositionInfo posInfo;
QGeoCoordinate coordinate;
double time;
double latitude;
double longitude;
double altitude;
double speed;
double track;
double climb;
GConfItem lastKnownPositionTime("/system/nokia/location/lastknown/time");
GConfItem lastKnownPositionLatitude("/system/nokia/location/lastknown/latitude");
GConfItem lastKnownPositionLongitude("/system/nokia/location/lastknown/longitude");
GConfItem lastKnownPositionAltitude("/system/nokia/location/lastknown/altitude");
GConfItem lastKnownPositionSpeed("/system/nokia/location/lastknown/speed");
GConfItem lastKnownPositionTrack("/system/nokia/location/lastknown/track");
GConfItem lastKnownPositionClimb("/system/nokia/location/lastknown/climb");
if (validLastSatUpdate)
return lastSatUpdate;
if (!fromSatellitePositioningMethodsOnly)
if (validLastUpdate)
return lastUpdate;
time = lastKnownPositionTime.value().toDouble();
latitude = lastKnownPositionLatitude.value().toDouble();
longitude = lastKnownPositionLongitude.value().toDouble();
altitude = lastKnownPositionAltitude.value().toDouble();
speed = lastKnownPositionSpeed.value().toDouble();
track = lastKnownPositionTrack.value().toDouble();
climb = lastKnownPositionClimb.value().toDouble();
if (longitude && latitude) {
coordinate.setLongitude(longitude);
coordinate.setLatitude(latitude);
if (altitude) {
coordinate.setAltitude(altitude);
}
posInfo.setCoordinate(coordinate);
}
if (speed) {
posInfo.setAttribute(QGeoPositionInfo::GroundSpeed, speed);
}
if (track) {
posInfo.setAttribute(QGeoPositionInfo::Direction, track);
}
if (climb) {
posInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, climb);
}
// Only positions with time (3D) are provided.
if (time) {
posInfo.setTimestamp(QDateTime::fromTime_t(time));
return posInfo;
}
return QGeoPositionInfo();
}
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);
}
void PsyUtils::TPositionInfo2QGeoPositionInfo(TPositionInfoBase &aPosInfoBase, QGeoPositionInfo& aQPosInfo)
{
if (aPosInfoBase.PositionClassType() & EPositionInfoClass ||
aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TPositionInfo *posInfo = static_cast<TPositionInfo*>(&aPosInfoBase);
TPosition pos;
QGeoCoordinate coord;
posInfo->GetPosition(pos);
coord.setLatitude(pos.Latitude());
coord.setLongitude(pos.Longitude());
coord.setAltitude(pos.Altitude());
//store the QGeoCoordinate values
aQPosInfo.setCoordinate(coord);
TDateTime datetime = pos.Time().DateTime();
QDateTime dt(QDate(datetime.Year() , datetime.Month() + 1, datetime.Day() + 1),
QTime(datetime.Hour() , datetime.Minute(), datetime.Second(),
datetime.MicroSecond() / 1000),
Qt::UTC);
//store the time stamp
aQPosInfo.setTimestamp(dt);
//store the horizontal accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, pos.HorizontalAccuracy());
//store the vertical accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, pos.VerticalAccuracy());
if (aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TCourse course;
TPositionSatelliteInfo *satInfo = static_cast<TPositionSatelliteInfo*>(&aPosInfoBase);
satInfo->GetCourse(course);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, course.Heading());
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, course.Speed());
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, course.VerticalSpeed());
}
}
if (aPosInfoBase.PositionClassType() & EPositionGenericInfoClass) {
HPositionGenericInfo *genInfo = static_cast<HPositionGenericInfo*>(&aPosInfoBase);
float val;
//check for the horizontal speed
if (genInfo->IsFieldAvailable(EPositionFieldHorizontalSpeed)) {
genInfo->GetValue(EPositionFieldHorizontalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, val);
}
//check for the vertcal speed
if (genInfo->IsFieldAvailable(EPositionFieldVerticalSpeed)) {
genInfo->GetValue(EPositionFieldVerticalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, val);
}
//check for the magnetic variation
if (genInfo->IsFieldAvailable(EPositionFieldMagneticCourseError)) {
genInfo->GetValue(EPositionFieldMagneticCourseError, val);
aQPosInfo.setAttribute(QGeoPositionInfo::MagneticVariation, val);
}
//check for the heading
if (genInfo->IsFieldAvailable(EPositionFieldHeading)) {
genInfo->GetValue(EPositionFieldHeading, val);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, val);
}
}
}
void TrackRecorder::loadAutoSave() {
QString homeDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
QString subDir = "Rena";
QString filename = "Autosave";
QFile file;
file.setFileName(homeDir + "/" + subDir + "/" + filename);
if(!file.exists()) {
qDebug()<<"No autosave found";
return;
}
qDebug()<<"Loading autosave";
if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug()<<"File opening failed, aborting";
return;
}
QTextStream stream(&file);
while(!stream.atEnd()) {
QGeoPositionInfo point;
qreal lat, lon, alt, temp;
QString timeStr;
stream>>lat>>lon>>timeStr>>alt;
point.setCoordinate(QGeoCoordinate(lat, lon, alt));
point.setTimestamp(QDateTime::fromString(timeStr,Qt::ISODate));
stream>>temp;
if(temp == temp) { // If value is not nan
point.setAttribute(QGeoPositionInfo::Direction, temp);
}
stream>>temp;
if(temp == temp) {
point.setAttribute(QGeoPositionInfo::GroundSpeed, temp);
}
stream>>temp;
if(temp == temp) {
point.setAttribute(QGeoPositionInfo::VerticalSpeed, temp);
}
stream>>temp;
if(temp == temp) {
point.setAttribute(QGeoPositionInfo::MagneticVariation, temp);
}
stream>>temp;
if(temp == temp) {
point.setAttribute(QGeoPositionInfo::HorizontalAccuracy, temp);
}
stream>>temp;
if(temp == temp) {
point.setAttribute(QGeoPositionInfo::VerticalAccuracy, temp);
}
stream.readLine(); // Read rest of the line, if any
m_points.append(point);
if(m_points.size() > 1) {
if(point.coordinate().latitude() < m_minLat) {
m_minLat = point.coordinate().latitude();
} else if(point.coordinate().latitude() > m_maxLat) {
m_maxLat = point.coordinate().latitude();
}
if(point.coordinate().longitude() < m_minLon) {
m_minLon = point.coordinate().longitude();
} else if(point.coordinate().longitude() > m_maxLon) {
m_maxLon = point.coordinate().longitude();
}
} else {
m_minLat = m_maxLat = point.coordinate().latitude();
m_minLon = m_maxLon = point.coordinate().longitude();
}
emit newTrackPoint(point.coordinate());
}
m_autoSavePosition = m_points.size();
file.close();
qDebug()<<m_autoSavePosition<<"track points loaded";
emit pointsChanged();
emit timeChanged();
if(m_points.size() > 1) {
for(int i=1;i<m_points.size();i++) {
m_distance += m_points.at(i-1).coordinate().distanceTo(m_points.at(i).coordinate());
}
emit distanceChanged();
}
if(!m_points.isEmpty()) {
m_isEmpty = false;
emit isEmptyChanged();
}
}