launchpad ~mzanetti/rockwork/trunk r87

1 files changed, 432 insertions, 0 deletions

diff --git a/rockwork/pebble.cpp b/rockwork/pebble.cpp
new file mode 100644
index 0000000..cba97d3
--- /dev/null
+++ b/rockwork/pebble.cpp
@@ -0,0 +1,432 @@
+#include "pebble.h"
+#include "notificationsourcemodel.h"
+#include "applicationsmodel.h"
+#include "screenshotmodel.h"
+
+#include <QDBusArgument>
+#include <QDebug>
+
+Pebble::Pebble(const QDBusObjectPath &path, QObject *parent):
+    QObject(parent),
+    m_path(path)
+{
+    m_iface = new QDBusInterface("org.rockwork", path.path(), "org.rockwork.Pebble", QDBusConnection::sessionBus(), this);
+    m_notifications = new NotificationSourceModel(this);
+    m_installedApps = new ApplicationsModel(this);
+    connect(m_installedApps, &ApplicationsModel::appsSorted, this, &Pebble::appsSorted);
+    m_installedWatchfaces = new ApplicationsModel(this);
+    m_screenshotModel = new ScreenshotModel(this);
+
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "Connected", this, SLOT(pebbleConnected()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "Disconnected", this, SLOT(pebbleDisconnected()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "InstalledAppsChanged", this, SLOT(refreshApps()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "OpenURL", this, SIGNAL(openURL(const QString&, const QString&)));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "NotificationFilterChanged", this, SLOT(notificationFilterChanged(const QString &, bool)));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "ScreenshotAdded", this, SLOT(screenshotAdded(const QString &)));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "ScreenshotRemoved", this, SLOT(screenshotRemoved(const QString &)));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "FirmwareUpgradeAvailableChanged", this, SLOT(refreshFirmwareUpdateInfo()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "UpgradingFirmwareChanged", this, SIGNAL(refreshFirmwareUpdateInfo()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "LogsDumped", this, SIGNAL(logsDumped(bool)));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "HealthParamsChanged", this, SIGNAL(healthParamsChanged()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "ImperialUnitsChanged", this, SIGNAL(imperialUnitsChanged()));
+    QDBusConnection::sessionBus().connect("org.rockwork", path.path(), "org.rockwork.Pebble", "CalendarSyncEnabledChanged", this, SIGNAL(calendarSyncEnabledChanged()));
+
+    dataChanged();
+    refreshApps();
+    refreshNotifications();
+    refreshScreenshots();
+    refreshFirmwareUpdateInfo();
+}
+
+bool Pebble::connected() const
+{
+    return m_connected;
+}
+
+QDBusObjectPath Pebble::path()
+{
+    return m_path;
+}
+
+QString Pebble::address() const
+{
+    return m_address;
+}
+
+QString Pebble::name() const
+{
+    return m_name;
+}
+
+QString Pebble::hardwarePlatform() const
+{
+    return m_hardwarePlatform;
+}
+
+QString Pebble::serialNumber() const
+{
+    return m_serialNumber;
+}
+
+QString Pebble::softwareVersion() const
+{
+    return m_softwareVersion;
+}
+
+int Pebble::model() const
+{
+    return m_model;
+}
+
+bool Pebble::recovery() const
+{
+    return m_recovery;
+}
+
+bool Pebble::upgradingFirmware() const
+{
+    qDebug() << "upgrading firmware" << m_upgradingFirmware;
+    return m_upgradingFirmware;
+}
+
+NotificationSourceModel *Pebble::notifications() const
+{
+    return m_notifications;
+}
+
+ApplicationsModel *Pebble::installedApps() const
+{
+    return m_installedApps;
+}
+
+ApplicationsModel *Pebble::installedWatchfaces() const
+{
+    return m_installedWatchfaces;
+}
+
+ScreenshotModel *Pebble::screenshots() const
+{
+    return m_screenshotModel;
+}
+
+bool Pebble::firmwareUpgradeAvailable() const
+{
+    return m_firmwareUpgradeAvailable;
+}
+
+QString Pebble::firmwareReleaseNotes() const
+{
+    return m_firmwareReleaseNotes;
+}
+
+QString Pebble::candidateVersion() const
+{
+    return m_candidateVersion;
+}
+
+QVariantMap Pebble::healthParams() const
+{
+    QDBusMessage m = m_iface->call("HealthParams");
+    if (m.type() == QDBusMessage::ErrorMessage || m.arguments().count() == 0) {
+        qWarning() << "Could not fetch health params" << m.errorMessage();
+        return QVariantMap();
+    }
+
+    const QDBusArgument &arg = m.arguments().first().value<QDBusArgument>();
+
+    QVariantMap mapEntryVariant;
+    arg >> mapEntryVariant;
+
+    qDebug() << "have health params" << mapEntryVariant;
+    return mapEntryVariant;
+}
+
+void Pebble::setHealthParams(const QVariantMap &healthParams)
+{
+    m_iface->call("SetHealthParams", healthParams);
+}
+
+bool Pebble::imperialUnits() const
+{
+    return fetchProperty("ImperialUnits").toBool();
+}
+
+void Pebble::setImperialUnits(bool imperialUnits)
+{
+    qDebug() << "setting im units" << imperialUnits;
+    m_iface->call("SetImperialUnits", imperialUnits);
+}
+
+bool Pebble::calendarSyncEnabled() const
+{
+    return fetchProperty("CalendarSyncEnabled").toBool();
+}
+
+void Pebble::setCalendarSyncEnabled(bool enabled)
+{
+    m_iface->call("SetCalendarSyncEnabled", enabled);
+}
+
+void Pebble::configurationClosed(const QString &uuid, const QString &url)
+{
+    m_iface->call("ConfigurationClosed", uuid, url.mid(17));
+}
+
+void Pebble::launchApp(const QString &uuid)
+{
+    m_iface->call("LaunchApp", uuid);
+}
+
+void Pebble::requestConfigurationURL(const QString &uuid)
+{
+    m_iface->call("ConfigurationURL", uuid);
+}
+
+void Pebble::removeApp(const QString &uuid)
+{
+    qDebug() << "should remove app" << uuid;
+    m_iface->call("RemoveApp", uuid);
+}
+
+void Pebble::installApp(const QString &storeId)
+{
+    qDebug() << "should install app" << storeId;
+    m_iface->call("InstallApp", storeId);
+}
+
+void Pebble::sideloadApp(const QString &packageFile)
+{
+    m_iface->call("SideloadApp", packageFile);
+}
+
+QVariant Pebble::fetchProperty(const QString &propertyName) const
+{
+    QDBusMessage m = m_iface->call(propertyName);
+    if (m.type() != QDBusMessage::ErrorMessage && m.arguments().count() == 1) {
+        qDebug() << "property" << propertyName << m.arguments().first();
+        return m.arguments().first();
+
+    }
+    qDebug() << "error getting property:" << propertyName << m.errorMessage();
+    return QVariant();
+}
+
+void Pebble::dataChanged()
+{
+    qDebug() << "data changed";
+    m_name = fetchProperty("Name").toString();
+    m_address = fetchProperty("Address").toString();
+    m_serialNumber = fetchProperty("SerialNumber").toString();
+    m_serialNumber = fetchProperty("SerialNumber").toString();
+    QString hardwarePlatform = fetchProperty("HardwarePlatform").toString();
+    if (hardwarePlatform != m_hardwarePlatform) {
+        m_hardwarePlatform = hardwarePlatform;
+        emit hardwarePlatformChanged();
+    }
+    m_softwareVersion = fetchProperty("SoftwareVersion").toString();
+    m_model = fetchProperty("Model").toInt();
+    m_recovery = fetchProperty("Recovery").toBool();
+    qDebug() << "model is" << m_model;
+    emit modelChanged();
+
+    bool connected = fetchProperty("IsConnected").toBool();
+    if (connected != m_connected) {
+        m_connected = connected;
+        emit connectedChanged();
+    }
+}
+
+void Pebble::pebbleConnected()
+{
+
+    dataChanged();
+    m_connected = true;
+    emit connectedChanged();
+
+    refreshApps();
+    refreshNotifications();
+    refreshScreenshots();
+}
+
+void Pebble::pebbleDisconnected()
+{
+    m_connected = false;
+    emit connectedChanged();
+}
+
+void Pebble::notificationFilterChanged(const QString &sourceId, bool enabled)
+{
+    m_notifications->insert(sourceId, enabled);
+}
+
+void Pebble::refreshNotifications()
+{
+    QDBusMessage m = m_iface->call("NotificationsFilter");
+    if (m.type() == QDBusMessage::ErrorMessage || m.arguments().count() == 0) {
+        qWarning() << "Could not fetch notifications filter" << m.errorMessage();
+        return;
+    }
+
+    const QDBusArgument &arg = m.arguments().first().value<QDBusArgument>();
+
+    QVariantMap mapEntryVariant;
+    arg >> mapEntryVariant;
+
+    foreach (const QString &sourceId, mapEntryVariant.keys()) {
+        m_notifications->insert(sourceId, mapEntryVariant.value(sourceId).toBool());
+    }
+}
+
+void Pebble::setNotificationFilter(const QString &sourceId, bool enabled)
+{
+    m_iface->call("SetNotificationFilter", sourceId, enabled);
+}
+
+void Pebble::moveApp(const QString &uuid, int toIndex)
+{
+    // This is a bit tricky:
+    AppItem *item = m_installedApps->findByUuid(uuid);
+    if (!item) {
+        qWarning() << "item not found";
+        return;
+    }
+    int realToIndex = 0;
+    for (int i = 0; i < m_installedApps->rowCount(); i++) {
+        if (item->isWatchFace() && m_installedApps->get(i)->isWatchFace()) {
+            realToIndex++;
+        } else if (!item->isWatchFace() && !m_installedApps->get(i)->isWatchFace()) {
+            realToIndex++;
+        }
+        if (realToIndex == toIndex) {
+            realToIndex = i+1;
+            break;
+        }
+    }
+    m_iface->call("MoveApp", m_installedApps->indexOf(item), realToIndex);
+}
+
+void Pebble::refreshApps()
+{
+
+    QDBusMessage m = m_iface->call("InstalledApps");
+    if (m.type() == QDBusMessage::ErrorMessage || m.arguments().count() == 0) {
+        qWarning() << "Could not fetch installed apps" << m.errorMessage();
+        return;
+    }
+
+    m_installedApps->clear();
+    m_installedWatchfaces->clear();
+
+    const QDBusArgument &arg = m.arguments().first().value<QDBusArgument>();
+
+    QVariantList appList;
+
+    arg.beginArray();
+    while (!arg.atEnd()) {
+        QVariant mapEntryVariant;
+        arg >> mapEntryVariant;
+
+        QDBusArgument mapEntry = mapEntryVariant.value<QDBusArgument>();
+        QVariantMap appMap;
+        mapEntry >> appMap;
+        appList.append(appMap);
+
+    }
+    arg.endArray();
+
+
+    qDebug() << "have apps" << appList;
+    foreach (const QVariant &v, appList) {
+        AppItem *app = new AppItem(this);
+        app->setStoreId(v.toMap().value("storeId").toString());
+        app->setUuid(v.toMap().value("uuid").toString());
+        app->setName(v.toMap().value("name").toString());
+        app->setIcon(v.toMap().value("icon").toString());
+        app->setVendor(v.toMap().value("vendor").toString());
+        app->setVersion(v.toMap().value("version").toString());
+        app->setIsWatchFace(v.toMap().value("watchface").toBool());
+        app->setHasSettings(v.toMap().value("hasSettings").toBool());
+        app->setIsSystemApp(v.toMap().value("systemApp").toBool());
+
+        if (app->isWatchFace()) {
+            m_installedWatchfaces->insert(app);
+        } else {
+            m_installedApps->insert(app);
+        }
+    }
+}
+
+void Pebble::appsSorted()
+{
+    QStringList newList;
+    for (int i = 0; i < m_installedApps->rowCount(); i++) {
+        newList << m_installedApps->get(i)->uuid();
+    }
+    for (int i = 0; i < m_installedWatchfaces->rowCount(); i++) {
+        newList << m_installedWatchfaces->get(i)->uuid();
+    }
+    m_iface->call("SetAppOrder", newList);
+}
+
+void Pebble::refreshScreenshots()
+{
+    m_screenshotModel->clear();
+    QStringList screenshots = fetchProperty("Screenshots").toStringList();
+    foreach (const QString &filename, screenshots) {
+        m_screenshotModel->insert(filename);
+    }
+}
+
+void Pebble::screenshotAdded(const QString &filename)
+{
+    qDebug() << "screenshot added" << filename;
+    m_screenshotModel->insert(filename);
+}
+
+void Pebble::screenshotRemoved(const QString &filename)
+{
+    m_screenshotModel->remove(filename);
+}
+
+void Pebble::refreshFirmwareUpdateInfo()
+{
+    bool firmwareUpgradeAvailable = fetchProperty("FirmwareUpgradeAvailable").toBool();
+    if (firmwareUpgradeAvailable && !m_firmwareUpgradeAvailable) {
+        m_firmwareUpgradeAvailable = true;
+        m_firmwareReleaseNotes = fetchProperty("FirmwareReleaseNotes").toString();
+        m_candidateVersion = fetchProperty("CandidateFirmwareVersion").toString();
+        qDebug() << "firmare upgrade" << m_firmwareUpgradeAvailable << m_firmwareReleaseNotes << m_candidateVersion;
+        emit firmwareUpgradeAvailableChanged();
+    } else if (!firmwareUpgradeAvailable && m_firmwareUpgradeAvailable) {
+        m_firmwareUpgradeAvailable = false;
+        m_firmwareReleaseNotes.clear();;
+        m_candidateVersion.clear();
+        emit firmwareUpgradeAvailableChanged();
+    }
+    bool upgradingFirmware = fetchProperty("UpgradingFirmware").toBool();
+    if (m_upgradingFirmware != upgradingFirmware) {
+        m_upgradingFirmware = upgradingFirmware;
+        emit upgradingFirmwareChanged();
+    }
+}
+
+void Pebble::requestScreenshot()
+{
+    m_iface->call("RequestScreenshot");
+}
+
+void Pebble::removeScreenshot(const QString &filename)
+{
+    qDebug() << "removing screenshot" << filename;
+    m_iface->call("RemoveScreenshot", filename);
+}
+
+void Pebble::performFirmwareUpgrade()
+{
+    m_iface->call("PerformFirmwareUpgrade");
+}
+
+void Pebble::dumpLogs(const QString &filename)
+{
+    m_iface->call("DumpLogs", filename);
+}