satellitemodel.cpp Example File

  /****************************************************************************
  **
  ** 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();
  }