Method callbackTaskFinished

src/network/ProtocolClient.cpp:816–893

		}

		void ProtocolClient::callbackTaskFinished(openmittsu::tasks::CallbackTask* callbackTask) {
			if (dynamic_cast<openmittsu::tasks::IdentityReceiverCallbackTask*>(callbackTask) != nullptr) {
				openmittsu::utility::UniquePtrWithDelayedThreadDeletion<openmittsu::tasks::IdentityReceiverCallbackTask> irct(dynamic_cast<openmittsu::tasks::IdentityReceiverCallbackTask*>(callbackTask));
				if (!missingIdentityProcessors.contains(irct->getContactIdOfFetchedPublicKey())) {
					LOGGER()->warn("IdentityReceiver CallbackTask finished for ID {}, but no MissingIdentityProcessor is registered for this ID.", irct->getContactIdOfFetchedPublicKey().toString());
				} else {
					std::shared_ptr<MissingIdentityProcessor> missingIdentityProcessor = missingIdentityProcessors.value(irct->getContactIdOfFetchedPublicKey());
					missingIdentityProcessors.remove(irct->getContactIdOfFetchedPublicKey());
					LOGGER_DEBUG("IdentityReceiverCallbackTask finished for ID {}, removing related MissingIdentityProcessor.", irct->getContactIdOfFetchedPublicKey().toString());

					if (!irct->hasFinishedSuccessfully()) {
						LOGGER()->warn("Received a message from user {} that we can not decrypt since the Identity could not be retrieved. Error: {}", irct->getContactIdOfFetchedPublicKey().toString(), irct->getErrorMessage().toStdString());
						missingIdentityProcessor->identityFetcherTaskFinished(irct->getContactIdOfFetchedPublicKey(), false);
					} else {
						missingIdentityProcessor->identityFetcherTaskFinished(irct->getContactIdOfFetchedPublicKey(), true);
						if (m_cryptoBox->getKeyRegistry().hasIdentity(irct->getContactIdOfFetchedPublicKey())) {
							LOGGER()->warn("Identity {} is already known to KeyRegistry, ignoring result of IdentityReceiverCallbackTask.", irct->getContactIdOfFetchedPublicKey().toString());
						} else {
							// TODO FIXME: Add new identity to database!
							//m_cryptoBox->getKeyRegistry().addIdentity(irct->getContactIdOfFetchedPublicKey(), irct->getFetchedPublicKey());

							LOGGER_DEBUG("PublicKey for Identity {} is {}.", irct->getContactIdOfFetchedPublicKey().toString(), irct->getFetchedPublicKey().toString());
							m_messageCenterWrapper->addNewContact(irct->getContactIdOfFetchedPublicKey(), irct->getFetchedPublicKey());
						}
					}

					if (missingIdentityProcessor->hasFinished()) {
						if (missingIdentityProcessor->hasAssociatedGroupId()) {
							groupsWithMissingIdentities.remove(missingIdentityProcessor->getAssociatedGroupId());
						}
						if (missingIdentityProcessor->hasFinishedSuccessfully()) {
							LOGGER()->info("MissingIdentityProcessor finished successfully, now processing {} queued messages.", missingIdentityProcessor->getQueuedMessages().size());
							std::list<openmittsu::messages::MessageWithEncryptedPayload> queuedMessages(missingIdentityProcessor->getQueuedMessages());
							auto it = queuedMessages.cbegin();
							auto const end = queuedMessages.cend();
							for (; it != end; ++it) {
								handleIncomingMessage(*it);
							}
						} else {
							LOGGER()->warn("MissingIdentityProcessor failed, will now discard {} messages.", missingIdentityProcessor->getQueuedMessages().size());
						}
					}
				}
			} else if (dynamic_cast<openmittsu::tasks::MessageCallbackTask*>(callbackTask) != nullptr) {
				openmittsu::utility::UniquePtrWithDelayedThreadDeletion<openmittsu::tasks::MessageCallbackTask> messageCallbackTask(dynamic_cast<openmittsu::tasks::MessageCallbackTask*>(callbackTask));
				if (messageCallbackTask->getInitialMessage()->getMessageHeader().getSender() == m_ourContactId) {
					// Sending
					if (!messageCallbackTask->hasFinishedSuccessfully()) {
						LOGGER()->warn("Tried sending a message to user {} that triggered a Callback Task which did not succeed. Error: {}", messageCallbackTask->getInitialMessage()->getMessageHeader().getReceiver().toString(), messageCallbackTask->getErrorMessage().toStdString());
						messageCallbackTask->getAcknowledgmentProcessor()->sendFailed(this, messageCallbackTask->getInitialMessage()->getMessageHeader().getMessageId());
					} else {
						openmittsu::messages::Message* nextMessage = messageCallbackTask->getResultMessage();
						if (dynamic_cast<openmittsu::messages::contact::ContactMessage*>(nextMessage) != nullptr) {
							handleOutgoingMessage(dynamic_cast<openmittsu::messages::contact::ContactMessage*>(nextMessage), messageCallbackTask->getAcknowledgmentProcessor());
						} else if (dynamic_cast<openmittsu::messages::group::UnspecializedGroupMessage*>(nextMessage) != nullptr) {
							handleOutgoingMessage(dynamic_cast<openmittsu::messages::group::UnspecializedGroupMessage*>(nextMessage), messageCallbackTask->getAcknowledgmentProcessor());
						} else {
							LOGGER()->critical("MessageCallbackTask finished for an unknown and unhandled Message type.");