diff --git a/src/MeasurementComplexItem/MeasurementComplexItem.cc b/src/MeasurementComplexItem/MeasurementComplexItem.cc
index d89b8e6e9761435e491ff72733e1f212e24705f9..76948c5eac6126fdfdda3ce8709f58409e0a2760 100644
--- a/src/MeasurementComplexItem/MeasurementComplexItem.cc
+++ b/src/MeasurementComplexItem/MeasurementComplexItem.cc
@@ -54,7 +54,7 @@ MeasurementComplexItem::MeasurementComplexItem(
       _altitude(settingsGroup, _metaDataMap[altitudeKey]),
       _variantIndex(settingsGroup, _metaDataMap[variantIndexKey]),
       _pAreaData(new AreaData(this)), _pEditorData(new AreaData(this)),
-      _pCurrentData(_pAreaData), _pGenerator(nullptr),
+      _pCurrentData(_pAreaData), _holdProgress(false), _pGenerator(nullptr),
       _pWorker(new RoutingThread(this)) {
 
   // Setup altitude.
@@ -772,6 +772,24 @@ void MeasurementComplexItem::_onAltitudeChanged() {
     emit routeChanged();
   }
 }
+
+bool MeasurementComplexItem::holdProgress() const { return _holdProgress; }
+
+void MeasurementComplexItem::setHoldProgress(bool holdProgress) {
+  if (_holdProgress != holdProgress) {
+    _holdProgress = holdProgress;
+    emit holdProgressChanged();
+
+    if (_holdProgress) {
+      disconnect(pNemoInterface, &NemoInterface::progressChanged, this,
+                 &MeasurementComplexItem::_onNewProgress);
+    } else {
+      connect(pNemoInterface, &NemoInterface::progressChanged, this,
+              &MeasurementComplexItem::_onNewProgress);
+      _onNewProgress(pNemoInterface->getProgress());
+    }
+  }
+}
 void MeasurementComplexItem::_setAreaData(
     MeasurementComplexItem::PtrAreaData data) {
   if (_pCurrentData != data) {
@@ -940,30 +958,9 @@ void MeasurementComplexItem::_syncTiles() {
     }
 
     if (tilePtrArray.size() > 0) {
-
-      // create id array
-      IDArray idArray;
-      for (const auto *pTile : tilePtrArray) {
-        idArray.push_back(pTile->id());
-      }
-
-      // sync. necessary?
-      bool doSync = false;
-      auto contains = pNemoInterface->containsTiles(idArray);
-      for (auto &&logical : contains) {
-        if (logical == false) {
-          doSync = true;
-          break;
-        }
-      }
-
-      if (doSync) {
-        if (!pNemoInterface->empty()) {
-          (void)pNemoInterface->clearTiles();
-        }
-        (void)pNemoInterface->addTiles(tilePtrArray);
-        return;
-      }
+      (void)pNemoInterface->clearTiles();
+      (void)pNemoInterface->addTiles(tilePtrArray);
+      return;
     } else {
       clear = true;
     }
@@ -972,9 +969,7 @@ void MeasurementComplexItem::_syncTiles() {
   }
 
   if (clear) {
-    if (!pNemoInterface->empty()) {
-      (void)pNemoInterface->clearTiles();
-    }
+    (void)pNemoInterface->clearTiles();
   }
 }
 
diff --git a/src/MeasurementComplexItem/MeasurementComplexItem.h b/src/MeasurementComplexItem/MeasurementComplexItem.h
index 826811e1fc340a40813d271781ac4ea8ac4eeaef..4812b67d048e24ce06f40aa5a409cfa43101655b 100644
--- a/src/MeasurementComplexItem/MeasurementComplexItem.h
+++ b/src/MeasurementComplexItem/MeasurementComplexItem.h
@@ -43,6 +43,8 @@ public:
                  generatorListChanged)
   Q_PROPERTY(bool calculating READ calculating NOTIFY calculatingChanged)
   Q_PROPERTY(bool editing READ editing NOTIFY editingChanged)
+  Q_PROPERTY(bool holdProgress READ holdProgress WRITE setHoldProgress NOTIFY
+                 holdProgressChanged)
   Q_PROPERTY(bool idle READ idle NOTIFY idleChanged)
   Q_PROPERTY(
       routing::GeneratorBase *generator READ generator NOTIFY generatorChanged)
@@ -219,6 +221,9 @@ public:
   static const char *jsonComplexItemTypeValue;
   static const QString name;
 
+  bool holdProgress() const;
+  void setHoldProgress(bool holdProgress);
+
 signals:
   void variantNamesChanged();
 
@@ -231,6 +236,7 @@ signals:
 
   void areaDataChanged();
   void routeChanged();
+  void holdProgressChanged();
 
 private slots:
 
@@ -269,6 +275,7 @@ private:
   PtrAreaData _pAreaData;
   PtrAreaData _pEditorData;
   PtrAreaData _pCurrentData;
+  bool _holdProgress;
 
   // Generators
   QList<PtrGenerator> _generatorList;
diff --git a/src/MeasurementComplexItem/NemoInterface.cpp b/src/MeasurementComplexItem/NemoInterface.cpp
index cafbcfe86d90ae69cc59fbe324634a385aa04bbf..dc741c466e35550690a029e26d6d1442a211df2d 100644
--- a/src/MeasurementComplexItem/NemoInterface.cpp
+++ b/src/MeasurementComplexItem/NemoInterface.cpp
@@ -77,31 +77,32 @@ public:
   std::shared_future<QVariant> clearTiles();
 
   // 	Functions that don't require communication to device.
-  TileArray getTiles(const IDArray &idArray);
-  TileArray getAllTiles();
-  LogicalArray containsTiles(const IDArray &idArray);
-  std::size_t size();
-  bool empty();
+  TileArray getTiles(const IDArray &idArray) const;
+  TileArray getAllTiles() const;
+  LogicalArray containsTiles(const IDArray &idArray) const;
+  std::size_t size() const;
+  bool empty() const;
 
   // Progress.
-  ProgressArray getProgress();
-  ProgressArray getProgress(const IDArray &idArray);
+  ProgressArray getProgress() const;
+  ProgressArray getProgress(const IDArray &idArray) const;
 
-  NemoInterface::STATUS status();
-  bool running(); // thread safe
-  bool ready();   // thread safe
+  NemoInterface::STATUS status() const;
+  bool running() const; // thread safe
+  bool ready() const;   // thread safe
 
-  const QString &infoString();
-  const QString &warningString();
+  const QString &infoString() const;
+  const QString &warningString() const;
 
 private:
   void _doTopicServiceSetup();
   void _doAction();
   void _trySynchronize();
-  bool _isSynchronized();
-  bool _userSync();                // thread safe
-  bool _sysSync();                 // thread safe
+  bool _isSynchronized() const;
+  bool _userSync() const;          // thread safe
+  bool _sysSync() const;           // thread safe
   void _onFutureWatcherFinished(); // thread safe
+  void _onHeartbeatTimeout();      // thread safe
 
   // called from dispatcher thread!
   QVariant _callAddTiles(
@@ -120,15 +121,21 @@ private:
     GET_PROGRESS,
     GET_ALL_PROGRESS
   };
+  QString _toString(CALL_NAME name);
 
   void _addTilesRemote(
-      std::shared_ptr<QVector<std::shared_ptr<const Tile>>> pTileArray);
+      std::shared_ptr<QVector<std::shared_ptr<const Tile>>> pTileArray,
+      std::promise<bool> promise);
   void
-  _addTilesRemote(std::shared_ptr<QVector<std::shared_ptr<Tile>>> pTileArray);
-  void _removeTilesRemote(std::shared_ptr<IDArray> idArray);
-  void _clearTilesRemote();
-  void _updateProgress(std::shared_ptr<ProgressArray> pArray);
-  void _onHeartbeatReceived(const QNemoHeartbeat &hb);
+  _addTilesRemote2(std::shared_ptr<QVector<std::shared_ptr<Tile>>> pTileArray,
+                   std::promise<bool> promise);
+  void _removeTilesRemote(std::shared_ptr<IDArray> idArray,
+                          std::promise<bool> promise);
+  void _clearTilesRemote(std::promise<bool> promise);
+  void _updateProgress(std::shared_ptr<ProgressArray> pArray,
+                       std::promise<bool> promise);
+  void _onHeartbeatReceived(const QNemoHeartbeat &hb,
+                            std::promise<bool> promise);
   void _setInfoString(const QString &info);
   void _setWarningString(const QString &warning);
 
@@ -198,10 +205,8 @@ NemoInterface::Impl::Impl(NemoInterface *p)
   setConnectionString();
 
   // Heartbeat timeout.
-  connect(&this->_timeoutTimer, &QTimer::timeout, [this] {
-    this->_setState(STATE::HEARTBEAT_TIMEOUT);
-    this->_doAction();
-  });
+  connect(&this->_timeoutTimer, &QTimer::timeout,
+          std::bind(&Impl::_onHeartbeatTimeout, this));
 
   // Connection timer (temporary workaround)
   connect(&this->_connectionTimer, &QTimer::timeout, [this] {
@@ -226,7 +231,7 @@ NemoInterface::Impl::Impl(NemoInterface *p)
           [this] { this->_onFutureWatcherFinished(); });
 }
 
-NemoInterface::Impl::~Impl() {}
+NemoInterface::Impl::~Impl() { this->_pRosBridge->reset(); }
 
 void NemoInterface::Impl::start() {
   if (!running()) {
@@ -246,6 +251,8 @@ std::shared_future<QVariant>
 NemoInterface::Impl::addTiles(const TilePtrArray &tileArray) {
   using namespace nemo_interface;
 
+  qDebug() << "addTiles called";
+
   if (tileArray.size() > 0) {
 
     // copy unknown tiles
@@ -266,6 +273,9 @@ NemoInterface::Impl::addTiles(const TilePtrArray &tileArray) {
             << "addTiles(): tile with id: " << pTile->id() << "already added.";
       }
     }
+    if (pTileArray->size() > 0) {
+      this->_parent->tilesChanged();
+    }
 
     // ready for send?
     if (pTileArray->size() > 0 && (this->ready() || this->_userSync())) {
@@ -308,6 +318,8 @@ std::shared_future<QVariant>
 NemoInterface::Impl::removeTiles(const IDArray &idArray) {
   using namespace nemo_interface;
 
+  qDebug() << "removeTiles called";
+
   if (idArray.size() > 0) {
 
     // copy known ids
@@ -322,6 +334,9 @@ NemoInterface::Impl::removeTiles(const IDArray &idArray) {
         qCDebug(NemoInterfaceLog) << "removeTiles(): unknown id: " << id << ".";
       }
     }
+    if (pIdArray->size() > 0) {
+      this->_parent->tilesChanged();
+    }
 
     // ready for send?
     if (pIdArray->size() > 0 && (this->ready() || this->_userSync())) {
@@ -349,10 +364,15 @@ NemoInterface::Impl::removeTiles(const IDArray &idArray) {
 std::shared_future<QVariant> NemoInterface::Impl::clearTiles() {
   using namespace nemo_interface;
 
+  qDebug() << "clearTiles called";
+
   // clear local tiles (_localTiles)
-  this->_localTiles.clear();
+  if (!_localTiles.empty()) {
+    this->_localTiles.clear();
+    this->_parent->tilesChanged();
+  }
 
-  if (this->_localTiles.size() > 0 && (this->ready() || this->_userSync())) {
+  if (this->ready() || this->_userSync()) {
 
     this->_setState(STATE::USER_SYNC);
     this->_doAction();
@@ -373,7 +393,7 @@ std::shared_future<QVariant> NemoInterface::Impl::clearTiles() {
   }
 }
 
-TileArray NemoInterface::Impl::getTiles(const IDArray &idArray) {
+TileArray NemoInterface::Impl::getTiles(const IDArray &idArray) const {
   TileArray tileArray;
 
   for (const auto &id : idArray) {
@@ -390,7 +410,7 @@ TileArray NemoInterface::Impl::getTiles(const IDArray &idArray) {
   return tileArray;
 }
 
-TileArray NemoInterface::Impl::getAllTiles() {
+TileArray NemoInterface::Impl::getAllTiles() const {
   TileArray tileArray;
 
   for (const auto &entry : _localTiles) {
@@ -405,7 +425,7 @@ TileArray NemoInterface::Impl::getAllTiles() {
   return tileArray;
 }
 
-LogicalArray NemoInterface::Impl::containsTiles(const IDArray &idArray) {
+LogicalArray NemoInterface::Impl::containsTiles(const IDArray &idArray) const {
   LogicalArray logicalArray;
 
   for (const auto &id : idArray) {
@@ -416,11 +436,11 @@ LogicalArray NemoInterface::Impl::containsTiles(const IDArray &idArray) {
   return logicalArray;
 }
 
-std::size_t NemoInterface::Impl::size() { return _localTiles.size(); }
+std::size_t NemoInterface::Impl::size() const { return _localTiles.size(); }
 
-bool NemoInterface::Impl::empty() { return _localTiles.empty(); }
+bool NemoInterface::Impl::empty() const { return _localTiles.empty(); }
 
-ProgressArray NemoInterface::Impl::getProgress() {
+ProgressArray NemoInterface::Impl::getProgress() const {
   ProgressArray progressArray;
 
   if (this->_isSynchronized()) {
@@ -438,7 +458,7 @@ ProgressArray NemoInterface::Impl::getProgress() {
   return progressArray;
 }
 
-ProgressArray NemoInterface::Impl::getProgress(const IDArray &idArray) {
+ProgressArray NemoInterface::Impl::getProgress(const IDArray &idArray) const {
   ProgressArray progressArray;
 
   if (this->_isSynchronized()) {
@@ -462,33 +482,45 @@ ProgressArray NemoInterface::Impl::getProgress(const IDArray &idArray) {
   return progressArray;
 }
 
-NemoInterface::STATUS NemoInterface::Impl::status() {
+NemoInterface::STATUS NemoInterface::Impl::status() const {
   return _status(this->_state);
 }
 
-bool NemoInterface::Impl::running() { return _running(this->_state); }
+bool NemoInterface::Impl::running() const { return _running(this->_state); }
 
-bool NemoInterface::Impl::ready() { return _ready(this->_state.load()); }
+bool NemoInterface::Impl::ready() const { return _ready(this->_state.load()); }
 
-bool NemoInterface::Impl::_sysSync() { return _sysSync(this->_state); }
+bool NemoInterface::Impl::_sysSync() const { return _sysSync(this->_state); }
 
 void NemoInterface::Impl::_onFutureWatcherFinished() {
-  if (this->_userSync() || this->_sysSync()) {
+  if (this->ready() || this->_userSync() || this->_sysSync()) {
     auto lastTransactionSuccessfull = _futureWatcher.result().toBool();
     if (!lastTransactionSuccessfull) {
-      QTimer::singleShot(1000, [this] { this->_trySynchronize(); });
+      qCDebug(NemoInterfaceLog)
+          << "last transaction unsuccessfull: " << _toString(_lastCall);
+      QTimer::singleShot(5000, [this] { this->_trySynchronize(); });
     }
   }
 }
 
-bool NemoInterface::Impl::_userSync() { return _userSync(this->_state); }
+void NemoInterface::Impl::_onHeartbeatTimeout() {
+  this->_setState(STATE::HEARTBEAT_TIMEOUT);
+  this->_doAction();
+}
+
+bool NemoInterface::Impl::_userSync() const { return _userSync(this->_state); }
 
-const QString &NemoInterface::Impl::infoString() { return _infoString; }
+const QString &NemoInterface::Impl::infoString() const { return _infoString; }
 
-const QString &NemoInterface::Impl::warningString() { return _warningString; }
+const QString &NemoInterface::Impl::warningString() const {
+  return _warningString;
+}
 
-void NemoInterface::Impl::_updateProgress(
-    std::shared_ptr<ProgressArray> pArray) {
+void NemoInterface::Impl::_updateProgress(std::shared_ptr<ProgressArray> pArray,
+                                          std::promise<bool> promise) {
+  qDebug() << "_updateProgress called";
+
+  bool error = false;
   for (auto itLP = pArray->begin(); itLP != pArray->end();) {
 
     auto it = _remoteTiles.find(itLP->id());
@@ -500,15 +532,19 @@ void NemoInterface::Impl::_updateProgress(
       qCDebug(NemoInterfaceLog)
           << "_updateProgress(): tile with id " << itLP->id() << " not found.";
       itLP = pArray->erase(itLP);
+      error = true;
     }
   }
 
   if (pArray->size() > 0) {
     emit _parent->progressChanged(*pArray);
   }
+
+  promise.set_value(!error);
 }
 
-void NemoInterface::Impl::_onHeartbeatReceived(const QNemoHeartbeat &hb) {
+void NemoInterface::Impl::_onHeartbeatReceived(const QNemoHeartbeat &hb,
+                                               std::promise<bool> promise) {
   _lastHeartbeat = hb;
   this->_timeoutTimer.start(NO_HEARTBEAT_TIMEOUT);
   if (this->_state == STATE::TRY_TOPIC_SERVICE_SETUP) {
@@ -518,6 +554,7 @@ void NemoInterface::Impl::_onHeartbeatReceived(const QNemoHeartbeat &hb) {
     this->_setState(STATE::READY);
     this->_doAction();
   }
+  promise.set_value(true);
 }
 
 void NemoInterface::Impl::_setInfoString(const QString &info) {
@@ -577,9 +614,15 @@ void NemoInterface::Impl::_doTopicServiceSetup() {
 
               auto p = std::make_shared<ProgressArray>();
               *p = std::move(progressArray.progress_array());
-              QMetaObject::invokeMethod(
+              std::promise<bool> promise;
+              auto future = promise.get_future();
+              bool value = QMetaObject::invokeMethod(
                   this->_parent,
-                  std::bind(&NemoInterface::Impl::_updateProgress, this, p));
+                  [this, p, promise = std::move(promise)]() mutable {
+                    this->_updateProgress(p, std::move(promise));
+                  });
+              Q_ASSERT(value == true);
+              future.wait();
             } else {
               qCWarning(NemoInterfaceLog) << "/nemo/progress not able to "
                                              "create ProgressArray form json: "
@@ -614,10 +657,15 @@ void NemoInterface::Impl::_doTopicServiceSetup() {
             // create obj from json
             nemo_msgs::heartbeat::Heartbeat heartbeat;
             if (nemo_msgs::heartbeat::fromJson(d["msg"], heartbeat)) {
-              QMetaObject::invokeMethod(
+              std::promise<bool> promise;
+              auto future = promise.get_future();
+              bool value = QMetaObject::invokeMethod(
                   this->_parent,
-                  std::bind(&NemoInterface::Impl::_onHeartbeatReceived, this,
-                            heartbeat));
+                  [this, heartbeat, promise = std::move(promise)]() mutable {
+                    this->_onHeartbeatReceived(heartbeat, std::move(promise));
+                  });
+              Q_ASSERT(value == true);
+              future.wait();
             } else {
               qCWarning(NemoInterfaceLog) << "/nemo/heartbeat not able to "
                                              "create Heartbeat form json: "
@@ -640,6 +688,9 @@ void NemoInterface::Impl::_trySynchronize() {
   if ((this->_state == STATE::READY || this->_state == STATE::SYS_SYNC ||
        this->_state == STATE::USER_SYNC) &&
       !_isSynchronized()) {
+
+    qCWarning(NemoInterfaceLog) << "trying to synchronize";
+
     this->_setState(STATE::SYS_SYNC);
     this->_doAction();
 
@@ -691,7 +742,7 @@ void NemoInterface::Impl::_trySynchronize() {
   }
 }
 
-bool NemoInterface::Impl::_isSynchronized() {
+bool NemoInterface::Impl::_isSynchronized() const {
   return _localTiles.size() > 0 && _remoteTiles.size() > 0 &&
          std::equal(
              _localTiles.begin(), _localTiles.end(), _remoteTiles.begin(),
@@ -704,7 +755,7 @@ void NemoInterface::Impl::_doAction() {
   case STATE::STOPPED:
     this->_connectionTimer.stop();
     this->_timeoutTimer.stop();
-    this->_clearTilesRemote();
+    this->_clearTilesRemote(std::promise<bool>());
     if (this->_pRosBridge->running()) {
       this->_pRosBridge->reset();
     }
@@ -731,7 +782,7 @@ void NemoInterface::Impl::_doAction() {
   case STATE::SYS_SYNC:
     break;
   case STATE::HEARTBEAT_TIMEOUT:
-    this->_clearTilesRemote();
+    this->_clearTilesRemote(std::promise<bool>());
     break;
   case STATE::WEBSOCKET_TIMEOUT:
     if (!resetDone) {
@@ -739,7 +790,8 @@ void NemoInterface::Impl::_doAction() {
       this->_pRosBridge->reset();
       this->_pRosBridge->run();
     }
-    this->_clearTilesRemote();
+    this->_timeoutTimer.stop();
+    this->_clearTilesRemote(std::promise<bool>());
     break;
   };
 }
@@ -747,6 +799,8 @@ void NemoInterface::Impl::_doAction() {
 QVariant NemoInterface::Impl::_callAddTiles(
     std::shared_ptr<QVector<std::shared_ptr<const Tile>>> pTileArray) {
 
+  qDebug() << "_callAddTiles called";
+
   this->_lastCall = CALL_NAME::ADD_TILES;
 
   // create json object
@@ -831,16 +885,22 @@ QVariant NemoInterface::Impl::_callAddTiles(
   }
 
   // add remote tiles (_remoteTiles)
-  QMetaObject::invokeMethod(this->_parent /* context */, [this, pTileArray] {
-    this->_addTilesRemote(pTileArray);
-  });
+  std::promise<bool> promise;
+  auto future = promise.get_future();
+  bool value = QMetaObject::invokeMethod(
+      this->_parent /* context */,
+      [this, pTileArray, promise = std::move(promise)]() mutable {
+        this->_addTilesRemote(pTileArray, std::move(promise));
+      });
+  Q_ASSERT(value == true);
 
   // return success
-  return QVariant(true);
+  return QVariant(future.get());
 }
 
 QVariant
 NemoInterface::Impl::_callRemoveTiles(std::shared_ptr<IDArray> pIdArray) {
+  qDebug() << "_callRemoveTiles called";
 
   this->_lastCall = CALL_NAME::REMOVE_TILES;
 
@@ -920,16 +980,22 @@ NemoInterface::Impl::_callRemoveTiles(std::shared_ptr<IDArray> pIdArray) {
   }
 
   // remove remote tiles (_remoteTiles)
-  QMetaObject::invokeMethod(this->_parent /* context */, [this, pIdArray] {
-    this->_removeTilesRemote(pIdArray);
-  });
+  std::promise<bool> promise;
+  auto future = promise.get_future();
+  bool value = QMetaObject::invokeMethod(
+      this->_parent /* context */,
+      [this, pIdArray, promise = std::move(promise)]() mutable {
+        this->_removeTilesRemote(pIdArray, std::move(promise));
+      });
+  Q_ASSERT(value == true);
 
   // return success
-  return QVariant(true);
+  return QVariant(future.get());
 }
 
 QVariant NemoInterface::Impl::_callClearTiles() {
 
+  qDebug() << "_callClearTiles called";
   this->_lastCall = CALL_NAME::CLEAR_TILES;
 
   // create response handler.
@@ -988,15 +1054,21 @@ QVariant NemoInterface::Impl::_callClearTiles() {
   }
 
   // clear remote tiles (_remoteTiles)
-  QMetaObject::invokeMethod(this->_parent,
-                            std::bind(&Impl::_clearTilesRemote, this));
+  std::promise<bool> promise;
+  auto future = promise.get_future();
+  bool value = QMetaObject::invokeMethod(
+      this->_parent, [this, promise = std::move(promise)]() mutable {
+        this->_clearTilesRemote(std::move(promise));
+      });
+  Q_ASSERT(value == true);
 
   // return success
-  return QVariant(true);
+  return QVariant(future.get());
 }
 
 QVariant
 NemoInterface::Impl::_callGetProgress(std::shared_ptr<IDArray> pIdArray) {
+  qDebug() << "_callGetProgress called";
 
   this->_lastCall = CALL_NAME::GET_PROGRESS;
 
@@ -1083,14 +1155,20 @@ NemoInterface::Impl::_callGetProgress(std::shared_ptr<IDArray> pIdArray) {
   }
 
   // remove remote tiles (_remoteTiles)
-  QMetaObject::invokeMethod(this->_parent /* context */,
-                            [this, pArray] { this->_updateProgress(pArray); });
+  std::promise<bool> promise;
+  auto future = promise.get_future();
+  bool value = QMetaObject::invokeMethod(
+      this->_parent, [this, pArray, promise = std::move(promise)]() mutable {
+        this->_updateProgress(pArray, std::move(promise));
+      });
+  Q_ASSERT(value == true);
 
   // return success
-  return QVariant(true);
+  return QVariant(future.get());
 }
 
 QVariant NemoInterface::Impl::_callGetAllProgress() {
+  qDebug() << "_callGetAllProgress called";
 
   this->_lastCall = CALL_NAME::GET_ALL_PROGRESS;
 
@@ -1168,26 +1246,56 @@ QVariant NemoInterface::Impl::_callGetAllProgress() {
   }
 
   // remove remote tiles (_remoteTiles)
-  QMetaObject::invokeMethod(this->_parent /* context */,
-                            [this, pArray] { this->_updateProgress(pArray); });
+  std::promise<bool> promise;
+  auto future = promise.get_future();
+  bool value = QMetaObject::invokeMethod(
+      this->_parent, [this, pArray, promise = std::move(promise)]() mutable {
+        this->_updateProgress(pArray, std::move(promise));
+      });
+  Q_ASSERT(value == true);
 
   // return success
-  return QVariant(true);
+  return QVariant(future.get());
+}
+
+QString NemoInterface::Impl::_toString(NemoInterface::Impl::CALL_NAME name) {
+  switch (name) {
+
+  case CALL_NAME::ADD_TILES:
+    return QString("ADD_TILES");
+  case CALL_NAME::REMOVE_TILES:
+    return QString("REMOVE_TILES");
+  case CALL_NAME::CLEAR_TILES:
+    return QString("CLEAR_TILES");
+  case CALL_NAME::GET_PROGRESS:
+    return QString("GET_PROGRESS");
+  case CALL_NAME::GET_ALL_PROGRESS:
+    return QString("GET_ALL_PROGRESS");
+  }
+  return QString("unknown CALL_NAME");
 }
 
 void NemoInterface::Impl::_addTilesRemote(
-    std::shared_ptr<QVector<std::shared_ptr<const Tile>>> pTileArray) {
+    std::shared_ptr<QVector<std::shared_ptr<const Tile>>> pTileArray,
+    std::promise<bool> promise) {
+
+  qDebug() << "_addTilesRemote called";
+
   auto pArrayDup = std::make_shared<QVector<std::shared_ptr<Tile>>>();
   for (auto pTile : *pTileArray) {
     pArrayDup->push_back(std::make_shared<Tile>(*pTile));
   }
-  _addTilesRemote(pArrayDup);
+  _addTilesRemote2(pArrayDup, std::move(promise));
 }
 
-void NemoInterface::Impl::_addTilesRemote(
-    std::shared_ptr<QVector<std::shared_ptr<Tile>>> pTileArray) {
+void NemoInterface::Impl::_addTilesRemote2(
+    std::shared_ptr<QVector<std::shared_ptr<Tile>>> pTileArray,
+    std::promise<bool> promise) {
+
+  qDebug() << "_addTilesRemote2 called";
 
   bool anyChange = false;
+  bool error = false;
 
   for (auto pTile : *pTileArray) {
     auto id = pTile->id();
@@ -1200,6 +1308,9 @@ void NemoInterface::Impl::_addTilesRemote(
     } else {
       qCWarning(NemoInterfaceLog)
           << "_addTilesRemote: tile with id " << id << " already added.";
+      if (pTile->tile() != it->second->tile()) {
+        error = true;
+      }
     }
   }
 
@@ -1208,11 +1319,14 @@ void NemoInterface::Impl::_addTilesRemote(
       this->_setState(STATE::READY);
       this->_doAction();
     }
-    this->_parent->tilesChanged();
   }
+
+  promise.set_value(!error);
 }
 
-void NemoInterface::Impl::_removeTilesRemote(std::shared_ptr<IDArray> idArray) {
+void NemoInterface::Impl::_removeTilesRemote(std::shared_ptr<IDArray> idArray,
+                                             std::promise<bool> promise) {
+  qDebug() << "_removeTilesRemote called";
   bool anyChange = false;
 
   for (const auto id : *idArray) {
@@ -1231,19 +1345,21 @@ void NemoInterface::Impl::_removeTilesRemote(std::shared_ptr<IDArray> idArray) {
       this->_setState(STATE::READY);
       this->_doAction();
     }
-    this->_parent->tilesChanged();
   }
+
+  promise.set_value(true);
 }
 
-void NemoInterface::Impl::_clearTilesRemote() {
+void NemoInterface::Impl::_clearTilesRemote(std::promise<bool> promise) {
+  qDebug() << "_clearTilesRemote called";
   if (_remoteTiles.size() > 0) {
     _remoteTiles.clear();
     if (this->_isSynchronized()) {
       this->_setState(STATE::READY);
       this->_doAction();
     }
-    this->_parent->tilesChanged();
   }
+  promise.set_value(true);
 }
 
 bool NemoInterface::Impl::_setState(STATE newState) {
@@ -1398,25 +1514,27 @@ std::shared_future<QVariant> NemoInterface::clearTiles() {
   return this->pImpl->clearTiles();
 }
 
-TileArray NemoInterface::getTiles(const IDArray &idArray) {
+TileArray NemoInterface::getTiles(const IDArray &idArray) const {
   return this->pImpl->getTiles(idArray);
 }
 
-TileArray NemoInterface::getAllTiles() { return this->pImpl->getAllTiles(); }
+TileArray NemoInterface::getAllTiles() const {
+  return this->pImpl->getAllTiles();
+}
 
-LogicalArray NemoInterface::containsTiles(const IDArray &idArray) {
+LogicalArray NemoInterface::containsTiles(const IDArray &idArray) const {
   return this->pImpl->containsTiles(idArray);
 }
 
-std::size_t NemoInterface::size() { return this->pImpl->size(); }
+std::size_t NemoInterface::size() const { return this->pImpl->size(); }
 
-bool NemoInterface::empty() { return this->pImpl->empty(); }
+bool NemoInterface::empty() const { return this->pImpl->empty(); }
 
-ProgressArray NemoInterface::getProgress() {
+ProgressArray NemoInterface::getProgress() const {
   return this->pImpl->getProgress();
 }
 
-ProgressArray NemoInterface::getProgress(const IDArray &idArray) {
+ProgressArray NemoInterface::getProgress(const IDArray &idArray) const {
   return this->pImpl->getProgress(idArray);
 }
 
@@ -1438,4 +1556,4 @@ QString NemoInterface::editorQml() {
   return QStringLiteral("NemoInterface.qml");
 }
 
-bool NemoInterface::running() { return this->pImpl->running(); }
+bool NemoInterface::running() const { return this->pImpl->running(); }
diff --git a/src/MeasurementComplexItem/NemoInterface.h b/src/MeasurementComplexItem/NemoInterface.h
index 7b221cc4983fdc0351a523d7778adf33f61e38d8..4cb4b66e780bd1767d0ee926241dd979d2bd0129 100644
--- a/src/MeasurementComplexItem/NemoInterface.h
+++ b/src/MeasurementComplexItem/NemoInterface.h
@@ -73,22 +73,22 @@ public:
   //!
   std::shared_future<QVariant> clearTiles();
 
-  TileArray getTiles(const IDArray &idArray);
-  TileArray getAllTiles();
-  LogicalArray containsTiles(const IDArray &idArray);
-  std::size_t size();
-  bool empty();
+  TileArray getTiles(const IDArray &idArray) const;
+  TileArray getAllTiles() const;
+  LogicalArray containsTiles(const IDArray &idArray) const;
+  std::size_t size() const;
+  bool empty() const;
 
   // Progress.
-  ProgressArray getProgress();
-  ProgressArray getProgress(const IDArray &idArray);
+  ProgressArray getProgress() const;
+  ProgressArray getProgress(const IDArray &idArray) const;
 
   // Status.
   STATUS status() const;
   QString statusString() const;
   QString infoString() const;
   QString warningString() const;
-  bool running();
+  bool running() const;
 
 signals:
   void statusChanged();
diff --git a/src/MeasurementComplexItem/geometry/MeasurementArea.cc b/src/MeasurementComplexItem/geometry/MeasurementArea.cc
index c00de70e7439958a868df469e018bf0646479cfe..d8f6e84b9ad9ef13ee6182182f514a976a28baad 100644
--- a/src/MeasurementComplexItem/geometry/MeasurementArea.cc
+++ b/src/MeasurementComplexItem/geometry/MeasurementArea.cc
@@ -55,8 +55,7 @@ MeasurementArea::MeasurementArea(QObject *parent)
                                        this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesKey],
                               this /* QObject parent */)),
-      _tiles(new QmlObjectListModel()), _holdProgress(false),
-      _state(STATE::IDLE) {
+      _tiles(new QmlObjectListModel()), _state(STATE::IDLE) {
   init();
 }
 
@@ -74,8 +73,7 @@ MeasurementArea::MeasurementArea(const MeasurementArea &other, QObject *parent)
                                        this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesKey],
                               this /* QObject parent */)),
-      _tiles(new QmlObjectListModel()), _holdProgress(false),
-      _state(STATE::IDLE) {
+      _tiles(new QmlObjectListModel()), _state(STATE::IDLE) {
   init();
   disableUpdate();
 
@@ -323,7 +321,7 @@ bool MeasurementArea::isCorrect() {
 }
 
 void MeasurementArea::updateProgress(const ProgressArray &array) {
-  if (ready() && !_holdProgress && array.size() > 0) {
+  if (ready() && array.size() > 0) {
     bool anyChanges = false;
     for (const auto &lp : array) {
       auto it = _indexMap.find(lp.id());
@@ -589,15 +587,6 @@ void MeasurementArea::setState(MeasurementArea::STATE s) {
   }
 }
 
-bool MeasurementArea::holdProgress() const { return _holdProgress; }
-
-void MeasurementArea::setHoldProgress(bool holdProgress) {
-  if (_holdProgress != holdProgress) {
-    _holdProgress = holdProgress;
-    emit holdProgressChanged();
-  }
-}
-
 void MeasurementArea::updateIds(const QList<TileDiff> &array) {
   for (const auto &diff : array) {
 
diff --git a/src/MeasurementComplexItem/geometry/MeasurementArea.h b/src/MeasurementComplexItem/geometry/MeasurementArea.h
index 0f17c9c0bed8d6931f80871fffdaef397094f43e..4f061fd1ae49ea41a7574378ef033f9be47ca453 100644
--- a/src/MeasurementComplexItem/geometry/MeasurementArea.h
+++ b/src/MeasurementComplexItem/geometry/MeasurementArea.h
@@ -48,8 +48,6 @@ public:
   Q_PROPERTY(Fact *showTiles READ showTiles CONSTANT)
   Q_PROPERTY(QmlObjectListModel *tiles READ tiles NOTIFY tilesChanged)
   Q_PROPERTY(int maxTiles READ maxTiles NOTIFY maxTilesChanged)
-  Q_PROPERTY(bool holdProgress READ holdProgress WRITE setHoldProgress NOTIFY
-                 holdProgressChanged)
 
   // Overrides from GeoArea
   QString mapVisualQML(void) const override;
@@ -75,23 +73,10 @@ public:
   static const char *settingsGroup;
   static const char *nameString;
 
-  //!
-  //! \brief holdProgress
-  //! \return Returns a copy of the holdProgress variable.
-  //!
-  bool holdProgress() const;
-  //!
-  //! \brief setHoldProgress Sets the holdProgress variable to \p holdProgress.
-  //! \note If holdProgress() == true, than setProgress() will do nothing, but
-  //! return false and emit the progressNotAccepted() signal.
-  //!
-  void setHoldProgress(bool holdProgress);
-
 signals:
   void tilesChanged();
   void maxTilesChanged();
   void readyChanged();
-  void holdProgressChanged();
   void progressChanged();
 
 public slots:
@@ -123,7 +108,6 @@ private:
   // Tile stuff.
   TilePtr _tiles;
   std::map<std::int64_t /*id*/, int> _indexMap;
-  bool _holdProgress;
   QTimer _timer;
   STATE _state;
   QFutureWatcher<TilePtr> _watcher;
diff --git a/src/MeasurementComplexItem/qml/NemoEditor.qml b/src/MeasurementComplexItem/qml/NemoEditor.qml
index a83f44453bfa6b91ab70d19d468d5d7033944783..26b36a9fecf70ea58c92d41ebc83e54097104c11 100644
--- a/src/MeasurementComplexItem/qml/NemoEditor.qml
+++ b/src/MeasurementComplexItem/qml/NemoEditor.qml
@@ -29,13 +29,10 @@ Rectangle {
     property var _areaData: missionItem.areaData
     property real _margin: ScreenTools.defaultFontPixelWidth / 2
     property var _nemoInterface: MCI.NemoInterface
-    property bool _holding
 
     Component.onCompleted: {
         console.assert(missionItem !== undefined,
                        "please set the missionItem property")
-        _holding = false
-        _stopHolding()
     }
 
     GridLayout {
@@ -93,16 +90,14 @@ Rectangle {
             visible: progressHeader.checked
 
             QGCButton {
-                text: !_holding ? qsTr("Hold") : qsTr("Stop Holding")
+                text: !missionItem.holdProgress ? qsTr("Hold") : qsTr("Stop Holding")
                 Layout.fillWidth: true
                 Layout.columnSpan: parent.columns
                 onPressed: {
-                    if (_holding) {
-                        _stopHolding()
-                        _holding = false
+                    if (missionItem.holdProgress) {
+                        missionItem.holdProgress = false
                     } else {
-                        _holdProgress()
-                        _holding = true
+                        missionItem.holdProgress = true
                     }
                 }
             }
@@ -187,30 +182,6 @@ Use the Random button to simulate measurement progress.")
         }
     } // GridLayout
 
-    function _holdProgress() {
-        var areaArray = _areaData.measurementAreaList
-        for (var i = 0; i < areaArray.count; ++i) {
-            var area = areaArray.get(i)
-            if (area) {
-                area.holdProgress = true
-            } else {
-                console.log("empty area!")
-            }
-        }
-    }
-
-    function _stopHolding() {
-        var areaArray = _areaData.measurementAreaList
-        for (var i = 0; i < areaArray.count; ++i) {
-            var area = areaArray.get(i)
-            if (area) {
-                area.holdProgress = false
-            } else {
-                console.log("empty area!")
-            }
-        }
-    }
-
     function _randomProgress() {
         var areaArray = _areaData.measurementAreaList
         for (var i = 0; i < areaArray.count; ++i) {