launchpad ~mzanetti/rockwork/trunk r87

1 files changed, 242 insertions, 0 deletions

diff --git a/rockworkd/libpebble/watchconnection.cpp b/rockworkd/libpebble/watchconnection.cpp
new file mode 100644
index 0000000..0778a1d
--- /dev/null
+++ b/rockworkd/libpebble/watchconnection.cpp
@@ -0,0 +1,242 @@
+#include "watchconnection.h"
+#include "watchdatareader.h"
+#include "watchdatawriter.h"
+#include "uploadmanager.h"
+
+#include <QDBusConnection>
+#include <QDBusReply>
+#include <QDebug>
+#include <QBluetoothAddress>
+#include <QBluetoothLocalDevice>
+#include <QBluetoothSocket>
+#include <QtEndian>
+#include <QDateTime>
+
+WatchConnection::WatchConnection(QObject *parent) :
+    QObject(parent),
+    m_socket(nullptr)
+{
+    m_reconnectTimer.setSingleShot(true);
+    QObject::connect(&m_reconnectTimer, &QTimer::timeout, this, &WatchConnection::reconnect);
+
+    m_localDevice = new QBluetoothLocalDevice(this);
+    connect(m_localDevice, &QBluetoothLocalDevice::hostModeStateChanged, this, &WatchConnection::hostModeStateChanged);
+
+    m_uploadManager = new UploadManager(this, this);
+}
+
+UploadManager *WatchConnection::uploadManager() const
+{
+    return m_uploadManager;
+}
+
+void WatchConnection::scheduleReconnect()
+{
+    if (m_connectionAttempts == 0) {
+        reconnect();
+    } else if (m_connectionAttempts < 25) {
+        qDebug() << "Attempting to reconnect in 10 seconds";
+        m_reconnectTimer.start(1000 * 10);
+    } else if (m_connectionAttempts < 35) {
+        qDebug() << "Attempting to reconnect in 1 minute";
+        m_reconnectTimer.start(1000 * 60);
+    } else {
+        qDebug() << "Attempting to reconnect in 15 minutes";
+        m_reconnectTimer.start(1000 * 60 * 15);
+    }
+}
+
+void WatchConnection::reconnect()
+{
+    QBluetoothLocalDevice localBtDev;
+    if (localBtDev.pairingStatus(m_pebbleAddress) == QBluetoothLocalDevice::Unpaired) {
+        // Try again in one 10 secs, give the user some time to pair it
+        m_connectionAttempts = 1;
+        scheduleReconnect();
+        return;
+    }
+
+    if (m_socket) {
+        if (m_socket->state() == QBluetoothSocket::ConnectedState) {
+            qDebug() << "Already connected.";
+            return;
+        }
+        delete m_socket;
+    }
+
+    m_socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol, this);
+    connect(m_socket, &QBluetoothSocket::connected, this, &WatchConnection::pebbleConnected);
+    connect(m_socket, &QBluetoothSocket::readyRead, this, &WatchConnection::readyRead);
+    connect(m_socket, SIGNAL(error(QBluetoothSocket::SocketError)), this, SLOT(socketError(QBluetoothSocket::SocketError)));
+    connect(m_socket, &QBluetoothSocket::disconnected, this, &WatchConnection::pebbleDisconnected);
+    //connect(socket, SIGNAL(bytesWritten(qint64)), SLOT(onBytesWritten(qint64)));
+
+    m_connectionAttempts++;
+
+    // FIXME: Assuming port 1 (with Pebble)
+    m_socket->connectToService(m_pebbleAddress, 1);
+}
+
+void WatchConnection::connectPebble(const QBluetoothAddress &pebble)
+{
+    m_pebbleAddress = pebble;
+    m_connectionAttempts = 0;
+    scheduleReconnect();
+}
+
+bool WatchConnection::isConnected()
+{
+    return m_socket && m_socket->state() == QBluetoothSocket::ConnectedState;
+}
+
+void WatchConnection::writeToPebble(Endpoint endpoint, const QByteArray &data)
+{
+    if (!m_socket || m_socket->state() != QBluetoothSocket::ConnectedState) {
+        qWarning() << "Socket not open. Cannot send data to Pebble. (Endpoint:" << endpoint << ")";
+        return;
+    }
+
+    //qDebug() << "sending message to endpoint" << endpoint;
+    QByteArray msg;
+
+    msg.append((data.length() & 0xFF00) >> 8);
+    msg.append(data.length() & 0xFF);
+
+    msg.append((endpoint & 0xFF00) >> 8);
+    msg.append(endpoint & 0xFF);
+
+    msg.append(data);
+
+    //qDebug() << "Writing:" << msg.toHex();
+    m_socket->write(msg);
+}
+
+void WatchConnection::systemMessage(WatchConnection::SystemMessage msg)
+{
+    QByteArray data;
+    data.append((char)0);
+    data.append((char)msg);
+    writeToPebble(EndpointSystemMessage, data);
+}
+
+bool WatchConnection::registerEndpointHandler(WatchConnection::Endpoint endpoint, QObject *handler, const QString &method)
+{
+    if (m_endpointHandlers.contains(endpoint)) {
+        qWarning() << "Already have a handlder for endpoint" << endpoint;
+        return false;
+    }
+    Callback cb;
+    cb.obj = handler;
+    cb.method = method;
+    m_endpointHandlers.insert(endpoint, cb);
+    return true;
+}
+
+void WatchConnection::pebbleConnected()
+{
+    m_connectionAttempts = 0;
+    emit watchConnected();
+}
+
+void WatchConnection::pebbleDisconnected()
+{
+    qDebug() << "Disconnected";
+    m_socket->close();
+    emit watchDisconnected();
+    if (!m_reconnectTimer.isActive()) {
+        scheduleReconnect();
+    }
+}
+
+void WatchConnection::socketError(QBluetoothSocket::SocketError error)
+{
+    Q_UNUSED(error); // We seem to get UnknownError anyways all the time
+    qDebug() << "SocketError" << error;
+    m_socket->close();
+    emit watchConnectionFailed();
+    if (!m_reconnectTimer.isActive()) {
+        scheduleReconnect();
+    }
+}
+
+void WatchConnection::readyRead()
+{
+//    QByteArray data = m_socket->readAll();
+//    qDebug() << "data from pebble" << data.toHex();
+
+//    QByteArray header = data.left(4);
+//    qDebug() << "header:" << header.toHex();
+    if (!m_socket) {
+        return;
+    }
+    int headerLength = 4;
+    uchar header[4];
+    m_socket->peek(reinterpret_cast<char*>(header), headerLength);
+
+    quint16 messageLength = qFromBigEndian<quint16>(&header[0]);
+    Endpoint endpoint = (Endpoint)qFromBigEndian<quint16>(&header[2]);
+
+    if (m_socket->bytesAvailable() < headerLength + messageLength) {
+//        qDebug() << "not enough data... waiting for more";
+        return;
+    }
+
+    QByteArray data = m_socket->read(headerLength + messageLength);
+//    qDebug() << "Have message for endpoint:" << endpoint << "data:" << data.toHex();
+
+    data = data.right(data.length() - 4);
+
+    if (m_endpointHandlers.contains(endpoint)) {
+        if (m_endpointHandlers.contains(endpoint)) {
+            Callback cb = m_endpointHandlers.value(endpoint);
+            QMetaObject::invokeMethod(cb.obj.data(), cb.method.toLatin1(), Q_ARG(QByteArray, data));
+        }
+    } else {
+        qWarning() << "Have message for unhandled endpoint" << endpoint << data.toHex();
+    }
+
+    if (m_socket->bytesAvailable() > 0) {
+        readyRead();
+    }
+}
+
+void WatchConnection::hostModeStateChanged(QBluetoothLocalDevice::HostMode state)
+{
+    switch (state) {
+    case QBluetoothLocalDevice::HostPoweredOff:
+        qDebug() << "Bluetooth turned off. Stopping any reconnect attempts.";
+        m_reconnectTimer.stop();
+        break;
+    case QBluetoothLocalDevice::HostConnectable:
+    case QBluetoothLocalDevice::HostDiscoverable:
+    case QBluetoothLocalDevice::HostDiscoverableLimitedInquiry:
+        if (m_socket && m_socket->state() != QBluetoothSocket::ConnectedState
+                && m_socket->state() != QBluetoothSocket::ConnectingState
+                && !m_reconnectTimer.isActive()) {
+            qDebug() << "Bluetooth now active. Trying to reconnect";
+            m_connectionAttempts = 0;
+            scheduleReconnect();
+        }
+    }
+}
+
+QByteArray WatchConnection::buildData(QStringList data)
+{
+    QByteArray res;
+    for (QString d : data)
+    {
+        QByteArray tmp = d.left(0xEF).toUtf8();
+        res.append((tmp.length() + 1) & 0xFF);
+        res.append(tmp);
+        res.append('\0');
+    }
+    return res;
+}
+
+QByteArray WatchConnection::buildMessageData(uint lead, QStringList data)
+{
+    QByteArray res;
+    res.append(lead & 0xFF);
+    res.append(buildData(data));
+    return res;
+}