satellitemodel.cpp Example File

satelliteinfo/satellitemodel.cpp
 /****************************************************************************
 **
 ** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** BSD License Usage
 ** Alternatively, you may use this file under the terms of the BSD license
 ** as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of The Qt Company Ltd nor the names of its
 **     contributors may be used to endorse or promote products derived
 **     from this software without specific prior written permission.
 **
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "satellitemodel.h"
 #include <QTimer>
 #include <QDebug>

 SatelliteModel::SatelliteModel(QObject *parent) :
     QAbstractListModel(parent), source(0), m_componentCompleted(false), m_running(false),
     m_runningRequested(false), demo(false), isSingle(false), singleRequestServed(false)
 {
     source = QGeoSatelliteInfoSource::createDefaultSource(this);
     if (!demo && !source) {
         qWarning() << "No satellite data source found. Changing to demo mode.";
         demo = true;
     }
     if (!demo) {
         source->setUpdateInterval(3000);
         connect(source, SIGNAL(satellitesInViewUpdated(QList<QGeoSatelliteInfo>)),
                 this, SLOT(satellitesInViewUpdated(QList<QGeoSatelliteInfo>)));
         connect(source, SIGNAL(satellitesInUseUpdated(QList<QGeoSatelliteInfo>)),
                 this, SLOT(satellitesInUseUpdated(QList<QGeoSatelliteInfo>)));
         connect(source, SIGNAL(error(QGeoSatelliteInfoSource::Error)),
                 this, SLOT(error(QGeoSatelliteInfoSource::Error)));
     }

     if (demo) {
         timer = new QTimer(this);
         connect(timer, SIGNAL(timeout()), this, SLOT(updateDemoData()));
         timer->start(3000);
     }
 }

 int SatelliteModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if (!source && !demo)
         return 0;

     return knownSatellites.count();
 }

 QVariant SatelliteModel::data(const QModelIndex &index, int role) const
 {
     if (!demo && !source)
         return QVariant();

     if (!index.isValid() || index.row() < 0)
         return QVariant();

     if (index.row() >= knownSatellites.count()) {
         qWarning() << "SatelliteModel: Index out of bound";
         return QVariant();
     }

     const QGeoSatelliteInfo &info = knownSatellites.at(index.row());
     switch (role) {
     case IdentifierRole:
         return info.satelliteIdentifier();
     case InUseRole:
         return satellitesInUse.contains(info.satelliteIdentifier());
     case SignalStrengthRole:
         return info.signalStrength();
     case ElevationRole:
         if (!info.hasAttribute(QGeoSatelliteInfo::Elevation))
             return QVariant();
         return info.attribute(QGeoSatelliteInfo::Elevation);
     case AzimuthRole:
         if (!info.hasAttribute(QGeoSatelliteInfo::Azimuth))
             return QVariant();
         return info.attribute(QGeoSatelliteInfo::Azimuth);
     default:
         break;

     }

     return QVariant();
 }

 QHash<int, QByteArray> SatelliteModel::roleNames() const
 {
     QHash<int, QByteArray> roleNames;
     roleNames.insert(IdentifierRole, "satelliteIdentifier");
     roleNames.insert(InUseRole, "isInUse");
     roleNames.insert(SignalStrengthRole, "signalStrength");
     roleNames.insert(ElevationRole, "elevation");
     roleNames.insert(AzimuthRole, "azimuth");
     return roleNames;
 }

 void SatelliteModel::componentComplete()
 {
     m_componentCompleted = true;
     if (m_runningRequested)
         setRunning(true);
 }

 bool SatelliteModel::running() const
 {
     return m_running;
 }

 bool SatelliteModel::isSingleRequest() const
 {
     return isSingle;
 }

 void SatelliteModel::setSingleRequest(bool single)
 {
     if (running()) {
         qWarning() << "Cannot change single request mode while running";
         return;
     }

     if (single != isSingle) { //flag changed
         isSingle = single;
         emit singleRequestChanged();
     }
 }

 void SatelliteModel::setRunning(bool isActive)
 {
     if (!source && !demo)
         return;

     if (!m_componentCompleted) {
         m_runningRequested = isActive;
         return;
     }

     if (m_running == isActive)
         return;

     m_running = isActive;

     if (m_running) {
         clearModel();
         if (demo)
             timer->start(2000);
         else if (isSingleRequest())
             source->requestUpdate(10000);
         else
             source->startUpdates();

         if (demo)
             singleRequestServed = false;
     } else {
         if (demo)
             timer->stop();
         else if (!isSingleRequest())
             source->stopUpdates();
     }

     Q_EMIT runningChanged();
 }

 int SatelliteModel::entryCount() const
 {
     return knownSatellites.count();
 }

 bool SatelliteModel::canProvideSatelliteInfo() const
 {
     return !demo;
 }

 void SatelliteModel::clearModel()
 {
     beginResetModel();
     knownSatelliteIds.clear();
     knownSatellites.clear();
     satellitesInUse.clear();
     endResetModel();
 }

 void SatelliteModel::updateDemoData()
 {
     static bool flag = true;
     QList<QGeoSatelliteInfo> satellites;
     if (flag) {
         for (int i = 0; i<5; i++) {
             QGeoSatelliteInfo info;
             info.setSatelliteIdentifier(i);
             info.setSignalStrength(20 + 20*i);
             satellites.append(info);
         }
     } else {
         for (int i = 0; i<9; i++) {
             QGeoSatelliteInfo info;
             info.setSatelliteIdentifier(i*2);
             info.setSignalStrength(20 + 10*i);
             satellites.append(info);
         }
     }

     satellitesInViewUpdated(satellites);
     flag ? satellitesInUseUpdated(QList<QGeoSatelliteInfo>() << satellites.at(2))
          : satellitesInUseUpdated(QList<QGeoSatelliteInfo>() << satellites.at(3));
     flag = !flag;

     emit errorFound(flag);

     if (isSingleRequest() && !singleRequestServed) {
         singleRequestServed = true;
         setRunning(false);
     }
 }

 void SatelliteModel::error(QGeoSatelliteInfoSource::Error error)
 {
     emit errorFound((int)error);
 }

 inline bool operator<(const QGeoSatelliteInfo& a, const QGeoSatelliteInfo& b)
 {
     return a.satelliteIdentifier() < b.satelliteIdentifier();
 }

 void SatelliteModel::satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &infos)
 {
     if (!running())
         return;

     int oldEntryCount = knownSatellites.count();

     QSet<int> satelliteIdsInUpdate;
     foreach (const QGeoSatelliteInfo &info, infos)
         satelliteIdsInUpdate.insert(info.satelliteIdentifier());

     QSet<int> toBeRemoved = knownSatelliteIds - satelliteIdsInUpdate;

     //We reset the model as in reality just about all entry values change
     //and there are generally a lot of inserts and removals each time
     //Hence we don't bother with complex model update logic beyond resetModel()
     beginResetModel();

     knownSatellites = infos;

     //sort them for presentation purposes
     std::sort(knownSatellites.begin(), knownSatellites.end());

     //remove old "InUse" data
     //new satellites are by default not in "InUse"
     //existing satellites keep their "inUse" state
     satellitesInUse -= toBeRemoved;

     knownSatelliteIds = satelliteIdsInUpdate;
     endResetModel();

     if (oldEntryCount != knownSatellites.count())
         emit entryCountChanged();
 }

 void SatelliteModel::satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &infos)
 {
     if (!running())
         return;

     beginResetModel();

     satellitesInUse.clear();
     foreach (const QGeoSatelliteInfo &info, infos)
         satellitesInUse.insert(info.satelliteIdentifier());

     endResetModel();
 }