satellitemodel.cpp Example File | Qt Positioning 5.6

Qt 5.6 | Qt Positioning | SatelliteInfo (C++/QML) | satellitemodel.cpp Example File

Qt 5.6.2 Reference Documentation

# satellitemodel.cpp Example File

satelliteinfo/satellitemodel.cpp

      /****************************************************************************
      **
      ** Copyright (C) 2015 The Qt Company Ltd.
      ** Contact: http://www.qt.io/licensing/
      **
      ** This file is part of the examples of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** 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();
      }