mirror of https://github.com/nymea/nymea.git
596 lines
27 KiB
C++
596 lines
27 KiB
C++
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* *
|
|
* Copyright (C) 2017 Michael Zanetti <michael.zanetti@guh.io> *
|
|
* *
|
|
* This file is part of nymea. *
|
|
* *
|
|
* nymea is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation, version 2 of the License. *
|
|
* *
|
|
* nymea is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with nymea. If not, see <http://www.gnu.org/licenses/>. *
|
|
* *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "awsconnector.h"
|
|
#include "loggingcategories.h"
|
|
#include "nymeasettings.h"
|
|
|
|
#include <QDebug>
|
|
#include <QDateTime>
|
|
#include <QJsonDocument>
|
|
#include <QtConcurrent/QtConcurrentRun>
|
|
#include <QUuid>
|
|
#include <QSettings>
|
|
#include <QSslCertificate>
|
|
#include <QFile>
|
|
|
|
using namespace awsiotsdk;
|
|
using namespace awsiotsdk::network;
|
|
using namespace awsiotsdk::mqtt;
|
|
|
|
QHash<quint16, AWSConnector*> AWSConnector::s_requestMap;
|
|
|
|
// Somehow the linker fails to find this... missing in awsiotsdk?
|
|
DisconnectCallbackContextData::~DisconnectCallbackContextData() {}
|
|
|
|
AWSConnector::AWSConnector(QObject *parent) : QObject(parent)
|
|
{
|
|
// Enable some AWS logging (does not regard our logging categories)
|
|
std::shared_ptr<awsiotsdk::util::Logging::ConsoleLogSystem> p_log_system =
|
|
std::make_shared<awsiotsdk::util::Logging::ConsoleLogSystem>(awsiotsdk::util::Logging::LogLevel::Info);
|
|
awsiotsdk::util::Logging::InitializeAWSLogging(p_log_system);
|
|
m_disconnectContextData = std::shared_ptr<awsiotsdk::DisconnectCallbackContextData>(new DisconnectContext(this));
|
|
m_subscriptionContextData = std::shared_ptr<awsiotsdk::mqtt::SubscriptionHandlerContextData>(new SubscriptionContext(this));
|
|
|
|
qRegisterMetaType<AWSConnector::PushNotificationsEndpoint>();
|
|
m_clientName = readSyncedNameCache();
|
|
}
|
|
|
|
AWSConnector::~AWSConnector()
|
|
{
|
|
qCDebug(dcAWS()) << "Stopping AWS connection. This might take a while...";
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
qCDebug(dcAWS()) << "AWS connection stopped.";
|
|
}
|
|
|
|
void AWSConnector::connect2AWS(const QString &endpoint, const QString &clientId, const QString &clientName, const QString &caFile, const QString &clientCertFile, const QString &clientPrivKeyFile)
|
|
{
|
|
m_shouldReconnect = true;
|
|
m_currentEndpoint = endpoint;
|
|
m_caFile = caFile;
|
|
m_clientCertFile = clientCertFile;
|
|
m_clientPrivKeyFile = clientPrivKeyFile;
|
|
m_clientId = clientId;
|
|
m_clientName = clientName;
|
|
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
|
|
doConnect();
|
|
}
|
|
|
|
void AWSConnector::doConnect()
|
|
{
|
|
m_setupInProgress = true;
|
|
m_subscriptionCache.clear();
|
|
m_networkConnection = std::shared_ptr<OpenSSLConnection>(new OpenSSLConnection(
|
|
m_currentEndpoint.toStdString(),
|
|
8883,
|
|
m_caFile.toStdString(),
|
|
m_clientCertFile.toStdString(),
|
|
m_clientPrivKeyFile.toStdString(),
|
|
std::chrono::milliseconds(3000),
|
|
std::chrono::milliseconds(3000),
|
|
std::chrono::milliseconds(3000),
|
|
true
|
|
));
|
|
m_networkConnection->Initialize();
|
|
m_client = MqttClient::Create(m_networkConnection, std::chrono::milliseconds(2800), &onDisconnectedCallback, m_disconnectContextData);
|
|
|
|
m_client->SetAutoReconnectEnabled(false);
|
|
m_client->SetMaxReconnectBackoffTimeout(std::chrono::seconds(10));
|
|
|
|
qCDebug(dcAWS()) << "Connecting to AWS with ID:" << m_clientId << "endpoint:" << m_currentEndpoint << "Certificate file:" << m_clientCertFile << "Fingerprint:" << getCertificateFingerprint(m_clientCertFile);
|
|
m_connectingFuture = QtConcurrent::run([&]() {
|
|
ResponseCode rc = m_client->Connect(std::chrono::milliseconds(10000), true, mqtt::Version::MQTT_3_1_1, std::chrono::seconds(30), Utf8String::Create(m_clientId.toStdString()), nullptr, nullptr, nullptr);
|
|
if (rc == ResponseCode::MQTT_CONNACK_CONNECTION_ACCEPTED) {
|
|
staticMetaObject.invokeMethod(this, "onConnected", Qt::QueuedConnection);
|
|
} else {
|
|
qCWarning(dcAWS) << "Error connecting to AWS. Response code:" << QString::fromStdString(ResponseHelper::ToString(rc));
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
QTimer::singleShot(10000, this, &AWSConnector::doConnect);
|
|
}
|
|
});
|
|
}
|
|
|
|
void AWSConnector::onConnected()
|
|
{
|
|
if (!readRegisteredFlag()) {
|
|
qCDebug(dcAWS()) << "AWS connected. Device not registered yet. Registering...";
|
|
registerDevice();
|
|
return;
|
|
}
|
|
qCDebug(dcAWS()) << "AWS connected. Device already registered in cloud.";
|
|
|
|
// OK, we're registerd already, go straight to subscription setup
|
|
setupSubscriptions();
|
|
}
|
|
|
|
void AWSConnector::registerDevice()
|
|
{
|
|
// We create a temporary UUID for which will be used by the server to post the reply to our create/device call.
|
|
// Before the first create/device call the cloud doesn't know about us. In order to receive the reply for the
|
|
// call we need to subscribe to a topic every device can subscribe to. If we'd use our deviceId, a potential
|
|
// black hat could snoop in all the devices we register on the system. So in case someone actually does that
|
|
// let's give him meaningless IDs instead of real device ids.
|
|
m_createDeviceId = QUuid::createUuid().toString().remove(QRegExp("[{}]*"));
|
|
|
|
// first subscribe to this tmp id topic
|
|
m_createDeviceSubscriptionId = subscribe({QString("create/device/%1").arg(m_createDeviceId)});
|
|
}
|
|
|
|
void AWSConnector::onDeviceRegistered(bool needsReconnect)
|
|
{
|
|
storeRegisteredFlag(true);
|
|
|
|
if (needsReconnect) {
|
|
qCDebug(dcAWS()) << "Disconnecting from AWS and reconnecting to use new policies";
|
|
QtConcurrent::run([&]() {
|
|
m_client->Disconnect(std::chrono::milliseconds(500));
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
QTimer::singleShot(1000, this, &AWSConnector::doConnect);
|
|
});
|
|
return;
|
|
}
|
|
|
|
setupSubscriptions();
|
|
}
|
|
|
|
void AWSConnector::setupSubscriptions()
|
|
{
|
|
// Subscribe to pairing info topics
|
|
QStringList subscriptions;
|
|
subscriptions.append(QString("%1/device/name/response").arg(m_clientId));
|
|
subscriptions.append(QString("%1/device/users/response").arg(m_clientId));
|
|
subscriptions.append(QString("%1/pair/response").arg(m_clientId));
|
|
subscriptions.append(QString("%1/notify/response").arg(m_clientId));
|
|
subscriptions.append(QString("%1/notify/info/endpoint").arg(m_clientId));
|
|
subscriptions.append(QString("%1/services/turn/response").arg(m_clientId));
|
|
subscribe(subscriptions);
|
|
|
|
// fetch previous pairings
|
|
fetchPairings();
|
|
}
|
|
|
|
void AWSConnector::fetchPairings()
|
|
{
|
|
QVariantMap params;
|
|
params.insert("timestamp", QDateTime::currentMSecsSinceEpoch());
|
|
params.insert("id", ++m_transactionId);
|
|
params.insert("command", "getUsers");
|
|
publish(QString("%1/device/users").arg(m_clientId), params);
|
|
}
|
|
|
|
void AWSConnector::onPairingsRetrieved(const QVariantMap &pairings)
|
|
{
|
|
qCDebug(dcAWS) << pairings.value("users").toList().count() << "devices paired in cloud.";
|
|
if (pairings.value("users").toList().count() > 0) {
|
|
QStringList topics;
|
|
foreach (const QVariant &pairing, pairings.value("users").toList()) {
|
|
topics << QString("%1/%2/#").arg(m_clientId).arg(pairing.toString());
|
|
}
|
|
subscribe(topics);
|
|
}
|
|
|
|
qCDebug(dcAWS) << pairings.value("pushNotificationsEndpoints").toList().count() << "push notification enabled users paired in cloud.";
|
|
QList<PushNotificationsEndpoint> pushNotificationEndpoints;
|
|
if (pairings.value("pushNotificationsEndpoints").toList().count() > 0) {
|
|
foreach (const QVariant &pairing, pairings.value("pushNotificationsEndpoints").toList()) {
|
|
foreach (const QString &cognitoUserId, pairing.toMap().keys()) {
|
|
qCDebug(dcAWS()) << "User:" << cognitoUserId << "has" << pairing.toMap().value(cognitoUserId).toList().count() << "push notifications enabled devices.";
|
|
foreach (const QVariant &endpoint, pairing.toMap().value(cognitoUserId).toList()) {
|
|
PushNotificationsEndpoint ep;
|
|
ep.userId = cognitoUserId;
|
|
ep.endpointId = endpoint.toMap().value("endpointId").toString();
|
|
ep.displayName = endpoint.toMap().value("displayName").toString();
|
|
pushNotificationEndpoints.append(ep);
|
|
qCDebug(dcAWS) << "Device:" << ep.displayName << "endpoint:" << ep.endpointId << "user:" << ep.userId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
emit pushNotificationEndpointsUpdated(pushNotificationEndpoints);
|
|
|
|
if (readSyncedNameCache() != m_clientName) {
|
|
setName();
|
|
}
|
|
|
|
m_setupInProgress = false;
|
|
emit connected();
|
|
|
|
requestTURNCredentials();
|
|
}
|
|
|
|
void AWSConnector::disconnectAWS()
|
|
{
|
|
m_shouldReconnect = false;
|
|
if (isConnected()) {
|
|
m_client->Disconnect(std::chrono::milliseconds(2000));
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
qCDebug(dcAWS()) << "Disconnected from AWS.";
|
|
emit disconnected();
|
|
}
|
|
}
|
|
|
|
bool AWSConnector::isConnected() const
|
|
{
|
|
return m_connectingFuture.isFinished() && m_networkConnection && m_client && m_client->IsConnected() && !m_setupInProgress;
|
|
}
|
|
|
|
void AWSConnector::setDeviceName(const QString &deviceName)
|
|
{
|
|
if (m_clientName != deviceName) {
|
|
m_clientName = deviceName;
|
|
storeSyncedNameCache(QString());
|
|
if (isConnected()) {
|
|
setName();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AWSConnector::pairDevice(const QString &idToken, const QString &userId)
|
|
{
|
|
QVariantMap map;
|
|
map.insert("idToken", idToken);
|
|
map.insert("userId", userId);
|
|
map.insert("id", ++m_transactionId);
|
|
map.insert("timestamp", QDateTime::currentMSecsSinceEpoch());
|
|
publish(QString("%1/pair").arg(m_clientId), map);
|
|
m_pairingRequests.insert(m_transactionId, userId);
|
|
}
|
|
|
|
void AWSConnector::sendWebRtcHandshakeMessage(const QString &sessionId, const QVariantMap &map)
|
|
{
|
|
publish(sessionId + "/reply", map);
|
|
}
|
|
|
|
int AWSConnector::sendPushNotification(const QString &userId, const QString &endpointId, const QString &title, const QString &text)
|
|
{
|
|
QVariantMap params;
|
|
params.insert("id", ++m_transactionId);
|
|
params.insert("command", "sendPushNotification");
|
|
params.insert("title", title);
|
|
params.insert("body", text);
|
|
params.insert("timestamp", QDateTime::currentMSecsSinceEpoch());
|
|
// publish(QString("%1/notify/user/%2/%3").arg(m_clientId, userId, endpointId), params);
|
|
Q_UNUSED(userId)
|
|
publish(QString("%1/notify/user/%2").arg(m_clientId, endpointId), params);
|
|
return m_transactionId;
|
|
}
|
|
|
|
void AWSConnector::requestTURNCredentials()
|
|
{
|
|
if (!isConnected()) {
|
|
qCWarning(dcAWS()) << "Not connected. Cannot request TURN credentials.";
|
|
emit turnCredentialsReceived(QVariantMap());
|
|
return;
|
|
}
|
|
if (!m_cachedTURNCredentials.first.isEmpty() && QDateTime::currentDateTime().secsTo(m_cachedTURNCredentials.second) > 0) {
|
|
emit turnCredentialsReceived(m_cachedTURNCredentials.first);
|
|
return;
|
|
}
|
|
qCDebug(dcAWS()) << "Requesting TURN credentials";
|
|
QVariantMap params;
|
|
params.insert("id", QUuid::createUuid());
|
|
params.insert("command", "getTurnCredentials");
|
|
params.insert("timestamp", QDateTime::currentMSecsSinceEpoch());
|
|
publish(QString("%1/services/turn").arg(m_clientId), params);
|
|
}
|
|
|
|
quint16 AWSConnector::publish(const QString &topic, const QVariantMap &message)
|
|
{
|
|
if (!m_setupInProgress && !isConnected()) {
|
|
qCWarning(dcAWS()) << "Can't publish to AWS: Not connected.";
|
|
return -1;
|
|
}
|
|
QString fullTopic = topic;
|
|
QJsonDocument jsonDoc = QJsonDocument::fromVariant(message);
|
|
|
|
uint16_t packetId = 0;
|
|
ResponseCode res = m_client->PublishAsync(Utf8String::Create(fullTopic.toStdString()), false, false, mqtt::QoS::QOS1, jsonDoc.toJson(QJsonDocument::Compact).toStdString(), &publishCallback, packetId);
|
|
qCDebug(dcAWSTraffic()) << "publish call queued with status:" << QString::fromStdString(ResponseHelper::ToString(res)) << packetId << "for topic" << topic << jsonDoc.toJson();
|
|
s_requestMap.insert(packetId, this);
|
|
return packetId;
|
|
}
|
|
|
|
void AWSConnector::onDisconnected()
|
|
{
|
|
qCDebug(dcAWS) << "AWS disconnected.";
|
|
m_client.reset();
|
|
m_networkConnection.reset();
|
|
emit disconnected();
|
|
|
|
bool needReRegistering = false;
|
|
if (m_setupInProgress) {
|
|
qCWarning(dcAWS()) << "Setup process interrupted by disconnect.";
|
|
needReRegistering = true;
|
|
} else {
|
|
if (m_lastConnectionDrop.addSecs(60) > QDateTime::currentDateTime()) {
|
|
m_reconnectCounter++;
|
|
} else {
|
|
m_reconnectCounter = 0;
|
|
}
|
|
m_lastConnectionDrop = QDateTime::currentDateTime();
|
|
if (m_reconnectCounter > 5) {
|
|
qCWarning(dcAWS()) << "Connection dropped 5 times in a row within a minute.";
|
|
needReRegistering = true;
|
|
}
|
|
}
|
|
|
|
if (needReRegistering) {
|
|
qCDebug(dcAWS) << "Trying to reregister the device in the cloud";
|
|
storeRegisteredFlag(false);
|
|
storeSyncedNameCache(QString());
|
|
}
|
|
|
|
if (m_shouldReconnect) {
|
|
qCDebug(dcAWS()) << "Reconnecting to AWS...";
|
|
doConnect();
|
|
}
|
|
}
|
|
|
|
void AWSConnector::onTurnCredentialsReceived(const QVariantMap &turnCredentials)
|
|
{
|
|
qCDebug(dcAWS()) << "Dynamic TURN credentials received";
|
|
|
|
m_cachedTURNCredentials.first = turnCredentials;
|
|
m_cachedTURNCredentials.second = QDateTime::currentDateTime().addSecs(turnCredentials.value("ttl").toInt());
|
|
emit turnCredentialsReceived(turnCredentials);
|
|
|
|
// refresh the cache
|
|
QTimer::singleShot((turnCredentials.value("ttl").toInt() - 10) * 1000, this, &AWSConnector::requestTURNCredentials);
|
|
qCDebug(dcAWS()) << "Refreshing TURN credentials in" << (turnCredentials.value("ttl").toInt() - 10) << "seconds.";
|
|
}
|
|
|
|
void AWSConnector::setName()
|
|
{
|
|
QVariantMap params;
|
|
params.insert("id", ++m_transactionId);
|
|
params.insert("timestamp", QDateTime::currentMSecsSinceEpoch() / 1000);
|
|
params.insert("command", "postName");
|
|
params.insert("name", m_clientName);
|
|
publish(QString("%1/device/name").arg(m_clientId), params);
|
|
}
|
|
|
|
quint16 AWSConnector::subscribe(const QStringList &topics)
|
|
{
|
|
util::Vector<std::shared_ptr<mqtt::Subscription>> subscription_list;
|
|
foreach (const QString &topic, topics) {
|
|
if (m_subscriptionCache.contains(topic)) {
|
|
qCDebug(dcAWS()) << "Already subscribed to topic:" << topic << ". Not resubscribing";
|
|
continue;
|
|
}
|
|
qCDebug(dcAWSTraffic()) << "Topic to subscribe is" << topic;
|
|
if (!Subscription::IsValidTopicName(topic.toStdString())) {
|
|
qCWarning(dcAWS()) << "Trying to subscribe to invalid topic:" << topic;
|
|
continue;
|
|
}
|
|
auto subscription = mqtt::Subscription::Create(Utf8String::Create(topic.toStdString()), mqtt::QoS::QOS1, &onSubscriptionReceivedCallback, m_subscriptionContextData);
|
|
subscription_list.push_back(subscription);
|
|
m_subscriptionCache.append(topic);
|
|
}
|
|
if (subscription_list.size() == 0) {
|
|
return 0;
|
|
}
|
|
|
|
uint16_t packetId;
|
|
ResponseCode res = m_client->SubscribeAsync(subscription_list, subscribeCallback, packetId);
|
|
qCDebug(dcAWSTraffic()) << "Subscribe call queued with status:" << QString::fromStdString(ResponseHelper::ToString(res)) << "Packet ID:" << packetId;
|
|
s_requestMap.insert(packetId, this);
|
|
return packetId;
|
|
}
|
|
|
|
void AWSConnector::publishCallback(uint16_t actionId, ResponseCode rc)
|
|
{
|
|
AWSConnector* obj = s_requestMap.take(actionId);
|
|
if (!obj) {
|
|
qCWarning(dcAWS())<< "Received a response callback but don't have an object waiting for it.";
|
|
return;
|
|
}
|
|
|
|
switch (rc) {
|
|
case ResponseCode::SUCCESS:
|
|
qCDebug(dcAWSTraffic()) << "Successfully published" << actionId;
|
|
break;
|
|
default:
|
|
qCDebug(dcAWS())<< "Error publishing data to AWS:" << QString::fromStdString(ResponseHelper::ToString(rc));
|
|
}
|
|
}
|
|
|
|
void AWSConnector::subscribeCallback(uint16_t actionId, ResponseCode rc)
|
|
{
|
|
if (rc != ResponseCode::SUCCESS) {
|
|
qCWarning(dcAWS()) << "Error subscribing to" << actionId << QString::fromStdString(ResponseHelper::ToString(rc));
|
|
return;
|
|
}
|
|
|
|
AWSConnector *connector = s_requestMap.take(actionId);
|
|
if (!connector) {
|
|
qCWarning(dcAWS()) << "Received a subscribe callback but don't have a request id for it.";
|
|
return;
|
|
}
|
|
|
|
if (actionId == connector->m_createDeviceSubscriptionId) {
|
|
qCDebug(dcAWS()) << "Subscribed to create/device/response";
|
|
// We might get this callback even if we didn't explicitly ask for it as the
|
|
// library automatically resubscribes to all the topics upon reconnect.
|
|
if (!connector->readRegisteredFlag()) {
|
|
QVariantMap params;
|
|
params.insert("id", connector->m_createDeviceId);
|
|
params.insert("UUID", connector->m_clientId);
|
|
connector->publish("create/device", params);
|
|
}
|
|
return;
|
|
}
|
|
|
|
qCDebug(dcAWSTraffic()) << "Successfully subscribed (actionId:" << actionId << ")";
|
|
}
|
|
|
|
ResponseCode AWSConnector::onSubscriptionReceivedCallback(util::String topic_name, util::String payload, std::shared_ptr<SubscriptionHandlerContextData> p_app_handler_data)
|
|
{
|
|
QJsonParseError error;
|
|
QJsonDocument jsonDoc = QJsonDocument::fromJson(QByteArray::fromStdString(payload), &error);
|
|
if (error.error != QJsonParseError::NoError) {
|
|
qCDebug(dcAWS()) << "Failed to parse JSON from AWS subscription on topic" << QString::fromStdString(topic_name) << ":" << error.errorString() << "\n" << QString::fromStdString(payload);
|
|
return ResponseCode::JSON_PARSING_ERROR;
|
|
}
|
|
|
|
qCDebug(dcAWSTraffic()) << "Subscription received: Topic:" << QString::fromStdString(topic_name) << "payload:" << QString::fromStdString(payload);
|
|
|
|
AWSConnector *connector = dynamic_cast<SubscriptionContext*>(p_app_handler_data.get())->c;
|
|
QString topic = QString::fromStdString(topic_name);
|
|
if (topic.startsWith("create/device/")) {
|
|
int statusCode = jsonDoc.toVariant().toMap().value("result").toMap().value("code").toInt();
|
|
switch (statusCode) {
|
|
case 201:
|
|
qCDebug(dcAWS()) << "Device successfully registered to the cloud server:" << statusCode << jsonDoc.toVariant().toMap().value("result").toMap().value("message").toString();
|
|
connector->staticMetaObject.invokeMethod(connector, "onDeviceRegistered", Qt::QueuedConnection, Q_ARG(bool, true));
|
|
return ResponseCode::SUCCESS;
|
|
case 200:
|
|
qCDebug(dcAWS()) << "Device already known to the cloud server:" << statusCode << jsonDoc.toVariant().toMap().value("result").toMap().value("message").toString();
|
|
// Ok, we have confirmation that everything went fine and we can proceed, let's remember that to minimize traffic.
|
|
connector->staticMetaObject.invokeMethod(connector, "onDeviceRegistered", Qt::QueuedConnection, Q_ARG(bool, false));
|
|
break;
|
|
default:
|
|
qCWarning(dcAWS()) << "Error registering device in the cloud. AWS connetion will not work:" << statusCode << jsonDoc.toVariant().toMap().value("result").toMap().value("message").toString();
|
|
return ResponseCode::SUCCESS;
|
|
}
|
|
} else if (topic == QString("%1/pair/response").arg(connector->m_clientId)) {
|
|
int statusCode = jsonDoc.toVariant().toMap().value("status").toInt();
|
|
int id = jsonDoc.toVariant().toMap().value("id").toInt();
|
|
QString message = jsonDoc.toVariant().toMap().value("result").toMap().value("message").toString();
|
|
QString userId = connector->m_pairingRequests.take(id);
|
|
if (statusCode != 200) {
|
|
qCWarning(dcAWS()) << "Pairing failed:" << statusCode << message;
|
|
emit connector->devicePaired(userId, statusCode, message);
|
|
} else if (!userId.isEmpty()) {
|
|
qCDebug(dcAWS()) << "Pairing response for id:" << userId << statusCode;
|
|
emit connector->devicePaired(userId, statusCode, message);
|
|
connector->staticMetaObject.invokeMethod(connector, "fetchPairings", Qt::QueuedConnection);
|
|
} else {
|
|
qCWarning(dcAWS()) << "Received a pairing response for a transaction we didn't start";
|
|
}
|
|
} else if (topic == QString("%1/device/users/response").arg(connector->m_clientId)) {
|
|
connector->staticMetaObject.invokeMethod(connector, "onPairingsRetrieved", Qt::QueuedConnection, Q_ARG(QVariantMap, jsonDoc.toVariant().toMap()));
|
|
} else if (topic == QString("%1/device/name/response").arg(connector->m_clientId)) {
|
|
qCDebug(dcAWS) << "Set device name in cloud with status:" << jsonDoc.toVariant().toMap().value("status").toInt();
|
|
if (jsonDoc.toVariant().toMap().value("status").toInt() == 200) {
|
|
connector->storeSyncedNameCache(connector->m_clientName);
|
|
}
|
|
} else if (topic.startsWith(QString("%1/eu-west-1:").arg(connector->m_clientId)) && !topic.contains("reply") && !topic.contains("proxy")) {
|
|
static QStringList dupes;
|
|
QString id = jsonDoc.toVariant().toMap().value("id").toString();
|
|
QString type = jsonDoc.toVariant().toMap().value("type").toString();
|
|
if (dupes.contains(id+type)) {
|
|
qCDebug(dcAWS()) << "Dropping duplicate packet";
|
|
return ResponseCode::SUCCESS;
|
|
}
|
|
dupes.append(id+type);
|
|
|
|
qCDebug(dcAWS) << "received webrtc handshake message.";
|
|
connector->webRtcHandshakeMessageReceived(topic, jsonDoc.toVariant().toMap());
|
|
} else if (topic.startsWith(QString("%1/eu-west-1:").arg(connector->m_clientId)) && topic.contains("reply")) {
|
|
// silently drop our own things (should not be subscribed to that in the first place)
|
|
} else if (topic.startsWith(QString("%1/eu-west-1:").arg(connector->m_clientId)) && topic.contains("proxy")) {
|
|
qCDebug(dcAWS) << "Proxy remote connection request received";
|
|
QString token = jsonDoc.toVariant().toMap().value("token").toString();
|
|
connector->staticMetaObject.invokeMethod(connector, "proxyConnectionRequestReceived", Qt::QueuedConnection, Q_ARG(QString, token));
|
|
} else if (topic == QString("%1/notify/response").arg(connector->m_clientId)) {
|
|
int transactionId = jsonDoc.toVariant().toMap().value("id").toInt();
|
|
int status = jsonDoc.toVariant().toMap().value("status").toInt();
|
|
qCDebug(dcAWS()) << "Push notification reply for transaction" << transactionId << " Status:" << status << jsonDoc.toVariant().toMap().value("message").toString();
|
|
emit connector->pushNotificationSent(transactionId, status);
|
|
} else if (topic == QString("%1/notify/info/endpoint").arg(connector->m_clientId)) {
|
|
QVariantMap endpoint = jsonDoc.toVariant().toMap().value("newPushNotificationsEndpoint").toMap();
|
|
Q_ASSERT(endpoint.keys().count() == 1);
|
|
QString cognitoId = endpoint.keys().first();
|
|
PushNotificationsEndpoint ep;
|
|
ep.userId = cognitoId;
|
|
ep.endpointId = endpoint.value(cognitoId).toMap().value("endpointId").toString();
|
|
ep.displayName = endpoint.value(cognitoId).toMap().value("displayName").toString();
|
|
emit connector->pushNotificationEndpointAdded(ep);
|
|
} else if (topic == QString("%1/services/turn/response").arg(connector->m_clientId)) {
|
|
QVariantMap turnCreds = jsonDoc.toVariant().toMap();
|
|
if (turnCreds.value("result").toMap().value("code").toInt() != 201) {
|
|
qCWarning(dcAWS()) << "Error retrieving TURN credentials:" << turnCreds.value("result").toMap().value("code").toInt() << turnCreds.value("result").toMap().value("message").toString();
|
|
return ResponseCode::SUCCESS;
|
|
}
|
|
connector->staticMetaObject.invokeMethod(connector, "onTurnCredentialsReceived", Qt::QueuedConnection, Q_ARG(QVariantMap, turnCreds.value("turnCredentials").toMap()));
|
|
} else {
|
|
qCWarning(dcAWS()) << "Unhandled subscription received!" << topic << QString::fromStdString(payload);
|
|
}
|
|
return ResponseCode::SUCCESS;
|
|
}
|
|
|
|
ResponseCode AWSConnector::onDisconnectedCallback(util::String mqtt_client_id, std::shared_ptr<DisconnectCallbackContextData> p_app_handler_data)
|
|
{
|
|
Q_UNUSED(mqtt_client_id)
|
|
AWSConnector* connector = dynamic_cast<DisconnectContext*>(p_app_handler_data.get())->c;
|
|
connector->staticMetaObject.invokeMethod(connector, "onDisconnected", Qt::QueuedConnection);
|
|
return ResponseCode::SUCCESS;
|
|
}
|
|
|
|
void AWSConnector::storeRegisteredFlag(bool registered)
|
|
{
|
|
QSettings settings(NymeaSettings::storagePath() + "/cloudstatus.conf", QSettings::IniFormat);
|
|
settings.setValue("registered", registered);
|
|
}
|
|
|
|
bool AWSConnector::readRegisteredFlag() const
|
|
{
|
|
QSettings settings(NymeaSettings::storagePath() + "/cloudstatus.conf", QSettings::IniFormat);
|
|
return settings.value("registered", false).toBool();
|
|
}
|
|
|
|
void AWSConnector::storeSyncedNameCache(const QString &syncedName)
|
|
{
|
|
QSettings settings(NymeaSettings::storagePath() + "/cloudstatus.conf", QSettings::IniFormat);
|
|
settings.setValue("syncedName", syncedName);
|
|
}
|
|
|
|
QString AWSConnector::readSyncedNameCache()
|
|
{
|
|
QSettings settings(NymeaSettings::storagePath() + "/cloudstatus.conf", QSettings::IniFormat);
|
|
return settings.value("syncedName", QString()).toString();
|
|
}
|
|
|
|
QString AWSConnector::getCertificateFingerprint(const QString &certificateFile) const
|
|
{
|
|
QFile certFile(certificateFile);
|
|
if (!certFile.open(QFile::ReadOnly)) {
|
|
qCWarning(dcAWS()) << "Error opening certificate file" << certificateFile;
|
|
return QString();
|
|
}
|
|
QSslCertificate crt = QSslCertificate(certFile.readAll());
|
|
QByteArray output;
|
|
QByteArray digest = crt.digest(QCryptographicHash::Sha256);
|
|
for (int i = 0; i < digest.length(); i++) {
|
|
if (output.length() > 0) {
|
|
output.append(":");
|
|
}
|
|
output.append(digest.mid(i,1).toHex().toUpper());
|
|
}
|
|
return output;
|
|
}
|