Initial commit

16 files changed, 1232 insertions, 0 deletions

diff --git a/transferengine-plugins/mastodonshareplugin/MastodonShareImage.qml b/transferengine-plugins/mastodonshareplugin/MastodonShareImage.qml
new file mode 100644
index 0000000..56b4b4b
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/MastodonShareImage.qml
@@ -0,0 +1,10 @@
+import QtQuick 2.6
+import Sailfish.Silica 1.0
+import Sailfish.TransferEngine 1.0
+
+ShareFilePreview {
+    id: root
+
+    metadataStripped: true
+    descriptionPlaceholderText: qsTr("Write a post")
+}
diff --git a/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.cpp b/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.cpp
new file mode 100644
index 0000000..405b86e
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.cpp
@@ -0,0 +1,52 @@
+#include "mastodonplugininfo.h"
+#include "mastodonshareservicestatus.h"
+
+MastodonPluginInfo::MastodonPluginInfo()
+    : SharingPluginInfo()
+    , m_mastodonShareServiceStatus(new MastodonShareServiceStatus(this))
+{
+    m_capabilities << QLatin1String("image/jpeg")
+                   << QLatin1String("image/png");
+
+    connect(m_mastodonShareServiceStatus, &MastodonShareServiceStatus::serviceReady,
+            this, &MastodonPluginInfo::serviceReady);
+    connect(m_mastodonShareServiceStatus, &MastodonShareServiceStatus::serviceError,
+            this, &MastodonPluginInfo::infoError);
+}
+
+MastodonPluginInfo::~MastodonPluginInfo()
+{
+}
+
+QList<SharingMethodInfo> MastodonPluginInfo::info() const
+{
+    return m_info;
+}
+
+void MastodonPluginInfo::query()
+{
+    m_mastodonShareServiceStatus->queryStatus(MastodonShareServiceStatus::PassiveMode);
+}
+
+void MastodonPluginInfo::serviceReady()
+{
+    m_info.clear();
+
+    for (int i = 0; i < m_mastodonShareServiceStatus->count(); ++i) {
+        SharingMethodInfo info;
+
+        const MastodonShareServiceStatus::AccountDetails details = m_mastodonShareServiceStatus->details(i);
+        info.setDisplayName(details.providerName);
+        info.setSubtitle(details.displayName);
+        info.setAccountId(details.accountId);
+
+        info.setMethodId(QLatin1String("Mastodon"));
+        info.setMethodIcon(QLatin1String("image://theme/graphic-m-service-mastodon"));
+        info.setShareUIPath(QLatin1String("/usr/share/nemo-transferengine/plugins/sharing/MastodonShareImage.qml"));
+        info.setCapabilities(m_capabilities);
+
+        m_info << info;
+    }
+
+    emit infoReady();
+}
diff --git a/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.h b/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.h
new file mode 100644
index 0000000..28eb479
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/mastodonplugininfo.h
@@ -0,0 +1,29 @@
+#ifndef MASTODONPLUGININFO_H
+#define MASTODONPLUGININFO_H
+
+#include <sharingplugininfo.h>
+#include <QStringList>
+
+class MastodonShareServiceStatus;
+
+class MastodonPluginInfo : public SharingPluginInfo
+{
+    Q_OBJECT
+
+public:
+    MastodonPluginInfo();
+    ~MastodonPluginInfo();
+
+    QList<SharingMethodInfo> info() const;
+    void query();
+
+private Q_SLOTS:
+    void serviceReady();
+
+private:
+    MastodonShareServiceStatus *m_mastodonShareServiceStatus;
+    QList<SharingMethodInfo> m_info;
+    QStringList m_capabilities;
+};
+
+#endif // MASTODONPLUGININFO_H
diff --git a/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.cpp b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.cpp
new file mode 100644
index 0000000..ec7a732
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.cpp
@@ -0,0 +1,23 @@
+#include "mastodonshareplugin.h"
+#include "mastodonplugininfo.h"
+
+#include <QtPlugin>
+
+MastodonSharePlugin::MastodonSharePlugin()
+    : QObject(), SharingPluginInterface()
+{
+}
+
+MastodonSharePlugin::~MastodonSharePlugin()
+{
+}
+
+SharingPluginInfo *MastodonSharePlugin::infoObject()
+{
+    return new MastodonPluginInfo;
+}
+
+QString MastodonSharePlugin::pluginId() const
+{
+    return QLatin1String("Mastodon");
+}
diff --git a/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.h b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.h
new file mode 100644
index 0000000..634d051
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.h
@@ -0,0 +1,22 @@
+#ifndef MASTODONSHAREPLUGIN_H
+#define MASTODONSHAREPLUGIN_H
+
+#include <QtCore/QObject>
+
+#include <sharingplugininterface.h>
+
+class Q_DECL_EXPORT MastodonSharePlugin : public QObject, public SharingPluginInterface
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.sailfishos.share.plugin.mastodon")
+    Q_INTERFACES(SharingPluginInterface)
+
+public:
+    MastodonSharePlugin();
+    ~MastodonSharePlugin();
+
+    SharingPluginInfo *infoObject();
+    QString pluginId() const;
+};
+
+#endif // MASTODONSHAREPLUGIN_H
diff --git a/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.pro b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.pro
new file mode 100644
index 0000000..6de949e
--- /dev/null
+++ b/transferengine-plugins/mastodonshareplugin/mastodonshareplugin.pro
@@ -0,0 +1,25 @@
+TEMPLATE = lib
+TARGET = $$qtLibraryTarget(mastodonshareplugin)
+CONFIG += plugin
+DEPENDPATH += .
+INCLUDEPATH += ..
+
+CONFIG += link_pkgconfig
+PKGCONFIG += nemotransferengine-qt5 accounts-qt5 sailfishaccounts libsignon-qt5
+
+HEADERS += mastodonshareplugin.h \
+           mastodonplugininfo.h \
+           ../mastodonshareservicestatus.h
+
+SOURCES += mastodonshareplugin.cpp \
+           mastodonplugininfo.cpp \
+           ../mastodonshareservicestatus.cpp
+
+target.path = $$[QT_INSTALL_LIBS]/nemo-transferengine/plugins/sharing
+
+OTHER_FILES += *.qml
+
+shareui.files = MastodonShareImage.qml
+shareui.path = /usr/share/nemo-transferengine/plugins/sharing
+
+INSTALLS += target shareui
diff --git a/transferengine-plugins/mastodonshareservicestatus.cpp b/transferengine-plugins/mastodonshareservicestatus.cpp
new file mode 100644
index 0000000..8c70e12
--- /dev/null
+++ b/transferengine-plugins/mastodonshareservicestatus.cpp
@@ -0,0 +1,367 @@
+#include "mastodonshareservicestatus.h"
+
+#include <Accounts/Account>
+#include <Accounts/AccountService>
+#include <Accounts/Manager>
+#include <Accounts/Service>
+
+#include <SignOn/AuthSession>
+#include <SignOn/Error>
+#include <SignOn/Identity>
+#include <SignOn/SessionData>
+
+#include <QtCore/QUrl>
+#include <QtCore/QVariantMap>
+#include <QtDebug>
+
+MastodonShareServiceStatus::MastodonShareServiceStatus(QObject *parent)
+    : QObject(parent)
+    , m_auth(new AccountAuthenticator(this))
+    , m_accountManager(new Accounts::Manager(this))
+    , m_serviceName(QStringLiteral("mastodon-sharing"))
+{
+}
+
+QString MastodonShareServiceStatus::normalizeApiHost(const QString &rawHost)
+{
+    QString host = rawHost.trimmed();
+    if (host.isEmpty()) {
+        host = QStringLiteral("https://mastodon.social");
+    }
+
+    if (!host.startsWith(QLatin1String("https://"))
+            && !host.startsWith(QLatin1String("http://"))) {
+        host.prepend(QStringLiteral("https://"));
+    }
+
+    QUrl url(host);
+    if (!url.isValid() || url.host().isEmpty()) {
+        return QStringLiteral("https://mastodon.social");
+    }
+
+    QString normalized = QString::fromLatin1(url.toEncoded(QUrl::RemovePath
+                                                            | QUrl::RemoveQuery
+                                                            | QUrl::RemoveFragment));
+    if (normalized.endsWith(QLatin1Char('/'))) {
+        normalized.chop(1);
+    }
+
+    return normalized;
+}
+
+void MastodonShareServiceStatus::signIn(int accountId)
+{
+    Accounts::Account *account = Accounts::Account::fromId(m_accountManager, accountId, this);
+    if (!account) {
+        qWarning() << Q_FUNC_INFO << "Failed to retrieve account for id:" << accountId;
+        setAccountDetailsState(accountId, Error);
+        return;
+    }
+
+    const Accounts::Service service(m_accountManager->service(m_serviceName));
+    if (!service.isValid()) {
+        qWarning() << Q_FUNC_INFO << "Invalid auth service" << m_serviceName;
+        account->deleteLater();
+        setAccountDetailsState(accountId, Error);
+        return;
+    }
+
+    account->selectService(service);
+
+    SignOn::Identity *identity = account->credentialsId() > 0
+            ? SignOn::Identity::existingIdentity(account->credentialsId())
+            : 0;
+    if (!identity) {
+        qWarning() << Q_FUNC_INFO << "account" << accountId << "has no valid credentials";
+        account->deleteLater();
+        setAccountDetailsState(accountId, Error);
+        return;
+    }
+
+    Accounts::AccountService accountService(account, service);
+    const QString method = accountService.authData().method();
+    const QString mechanism = accountService.authData().mechanism();
+
+    SignOn::AuthSession *session = identity->createSession(method);
+    if (!session) {
+        qWarning() << Q_FUNC_INFO << "could not create signon session for account" << accountId;
+        identity->deleteLater();
+        account->deleteLater();
+        setAccountDetailsState(accountId, Error);
+        return;
+    }
+
+    QVariantMap signonSessionData = accountService.authData().parameters();
+
+    QString configuredHost = account->value(QStringLiteral("auth/oauth2/web_server/Host")).toString().trimmed();
+    if (configuredHost.isEmpty()) {
+        configuredHost = normalizeApiHost(account->value(QStringLiteral("api/Host")).toString());
+    }
+
+    if (configuredHost.startsWith(QLatin1String("https://"))) {
+        configuredHost.remove(0, 8);
+    } else if (configuredHost.startsWith(QLatin1String("http://"))) {
+        configuredHost.remove(0, 7);
+    }
+
+    const int separator = configuredHost.indexOf(QLatin1Char('/'));
+    if (separator > -1) {
+        configuredHost.truncate(separator);
+    }
+    while (configuredHost.endsWith(QLatin1Char('/'))) {
+        configuredHost.chop(1);
+    }
+
+    if (configuredHost.isEmpty()) {
+        configuredHost = QStringLiteral("mastodon.social");
+    }
+    signonSessionData.insert(QStringLiteral("Host"), configuredHost);
+
+    const QString authPath = account->value(QStringLiteral("auth/oauth2/web_server/AuthPath")).toString().trimmed();
+    if (!authPath.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("AuthPath"), authPath);
+    }
+
+    const QString tokenPath = account->value(QStringLiteral("auth/oauth2/web_server/TokenPath")).toString().trimmed();
+    if (!tokenPath.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("TokenPath"), tokenPath);
+    }
+
+    const QString responseType = account->value(QStringLiteral("auth/oauth2/web_server/ResponseType")).toString().trimmed();
+    if (!responseType.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("ResponseType"), responseType);
+    }
+
+    const QString redirectUri = account->value(QStringLiteral("auth/oauth2/web_server/RedirectUri")).toString().trimmed();
+    if (!redirectUri.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("RedirectUri"), redirectUri);
+    }
+
+    const QVariant scopeValue = account->value(QStringLiteral("auth/oauth2/web_server/Scope"));
+    if (scopeValue.isValid()) {
+        signonSessionData.insert(QStringLiteral("Scope"), scopeValue);
+    }
+
+    const QString clientId = account->value(QStringLiteral("auth/oauth2/web_server/ClientId")).toString().trimmed();
+    if (!clientId.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("ClientId"), clientId);
+    }
+
+    const QString clientSecret = account->value(QStringLiteral("auth/oauth2/web_server/ClientSecret")).toString().trimmed();
+    if (!clientSecret.isEmpty()) {
+        signonSessionData.insert(QStringLiteral("ClientSecret"), clientSecret);
+    }
+
+    signonSessionData.insert(QStringLiteral("UiPolicy"), SignOn::NoUserInteractionPolicy);
+
+    connect(session, SIGNAL(response(SignOn::SessionData)),
+            this, SLOT(signOnResponse(SignOn::SessionData)),
+            Qt::UniqueConnection);
+    connect(session, SIGNAL(error(SignOn::Error)),
+            this, SLOT(signOnError(SignOn::Error)),
+            Qt::UniqueConnection);
+
+    session->setProperty("account", QVariant::fromValue<Accounts::Account *>(account));
+    session->setProperty("identity", QVariant::fromValue<SignOn::Identity *>(identity));
+    session->process(SignOn::SessionData(signonSessionData), mechanism);
+}
+
+void MastodonShareServiceStatus::signOnResponse(const SignOn::SessionData &responseData)
+{
+    QVariantMap data;
+    Q_FOREACH (const QString &key, responseData.propertyNames()) {
+        data.insert(key, responseData.getProperty(key));
+    }
+
+    SignOn::AuthSession *session = qobject_cast<SignOn::AuthSession *>(sender());
+    Accounts::Account *account = session->property("account").value<Accounts::Account *>();
+    SignOn::Identity *identity = session->property("identity").value<SignOn::Identity *>();
+    const int accountId = account ? account->id() : 0;
+
+    QString accessToken = data.value(QLatin1String("AccessToken")).toString().trimmed();
+    if (accessToken.isEmpty()) {
+        accessToken = data.value(QLatin1String("access_token")).toString().trimmed();
+    }
+
+    if (accountId > 0 && m_accountIdToDetailsIdx.contains(accountId)) {
+        AccountDetails &accountDetails(m_accountDetails[m_accountIdToDetailsIdx[accountId]]);
+        accountDetails.accessToken = accessToken;
+        setAccountDetailsState(accountId, accessToken.isEmpty() ? Error : Populated);
+    }
+
+    session->disconnect(this);
+    if (identity) {
+        identity->destroySession(session);
+        identity->deleteLater();
+    }
+    if (account) {
+        account->deleteLater();
+    }
+}
+
+void MastodonShareServiceStatus::signOnError(const SignOn::Error &error)
+{
+    SignOn::AuthSession *session = qobject_cast<SignOn::AuthSession *>(sender());
+    Accounts::Account *account = session->property("account").value<Accounts::Account *>();
+    SignOn::Identity *identity = session->property("identity").value<SignOn::Identity *>();
+    const int accountId = account ? account->id() : 0;
+
+    qWarning() << Q_FUNC_INFO << "failed to retrieve credentials for account" << accountId
+               << error.type() << error.message();
+
+    if (accountId > 0 && error.type() == SignOn::Error::UserInteraction) {
+        setCredentialsNeedUpdate(accountId, m_serviceName);
+    }
+
+    session->disconnect(this);
+    if (identity) {
+        identity->destroySession(session);
+        identity->deleteLater();
+    }
+    if (account) {
+        account->deleteLater();
+    }
+
+    if (accountId > 0) {
+        setAccountDetailsState(accountId, Error);
+    }
+}
+
+void MastodonShareServiceStatus::setAccountDetailsState(int accountId, AccountDetailsState state)
+{
+    if (!m_accountIdToDetailsIdx.contains(accountId)) {
+        return;
+    }
+
+    m_accountDetailsState[accountId] = state;
+
+    bool anyWaiting = false;
+    bool anyPopulated = false;
+    Q_FOREACH (int id, m_accountDetailsState.keys()) {
+        AccountDetailsState accountState = m_accountDetailsState.value(id, Waiting);
+        if (accountState == Waiting) {
+            anyWaiting = true;
+        } else if (accountState == Populated) {
+            anyPopulated = true;
+        }
+    }
+
+    if (!anyWaiting) {
+        if (anyPopulated) {
+            emit serviceReady();
+        } else {
+            emit serviceError(QStringLiteral("Unable to retrieve Mastodon account credentials"));
+        }
+    }
+}
+
+int MastodonShareServiceStatus::count() const
+{
+    return m_accountDetails.count();
+}
+
+bool MastodonShareServiceStatus::setCredentialsNeedUpdate(int accountId, const QString &serviceName)
+{
+    return m_auth->setCredentialsNeedUpdate(accountId, serviceName);
+}
+
+void MastodonShareServiceStatus::queryStatus(QueryStatusMode mode)
+{
+    m_accountDetails.clear();
+    m_accountIdToDetailsIdx.clear();
+    m_accountDetailsState.clear();
+
+    bool signInActive = false;
+    Q_FOREACH (Accounts::AccountId id, m_accountManager->accountList()) {
+        Accounts::Account *acc = m_accountManager->account(id);
+
+        if (!acc) {
+            qWarning() << Q_FUNC_INFO << "Failed to get account for id:" << id;
+            continue;
+        }
+
+        acc->selectService(Accounts::Service());
+
+        const Accounts::Service service(m_accountManager->service(m_serviceName));
+        const Accounts::ServiceList services = acc->services();
+        bool serviceFound = false;
+        Q_FOREACH (const Accounts::Service &s, services) {
+            if (s.name() == m_serviceName) {
+                serviceFound = true;
+                break;
+            }
+        }
+
+        if (acc->enabled() && service.isValid() && serviceFound) {
+            if (acc->value(QStringLiteral("CredentialsNeedUpdate")).toBool()) {
+                qWarning() << Q_FUNC_INFO << "Credentials need update for account id:" << id;
+                continue;
+            }
+
+            acc->selectService(service);
+            if (acc->value(QStringLiteral("CredentialsNeedUpdate")).toBool()) {
+                qWarning() << Q_FUNC_INFO << "Credentials need update for account id:" << id;
+                acc->selectService(Accounts::Service());
+                continue;
+            }
+
+            if (!m_accountIdToDetailsIdx.contains(id)) {
+                AccountDetails details;
+                details.accountId = id;
+                details.apiHost = normalizeApiHost(acc->value(QStringLiteral("api/Host")).toString());
+
+                QUrl apiUrl(details.apiHost);
+                details.providerName = apiUrl.host();
+                if (details.providerName.isEmpty()) {
+                    details.providerName = details.apiHost;
+                    if (details.providerName.startsWith(QLatin1String("https://"))) {
+                        details.providerName.remove(0, 8);
+                    } else if (details.providerName.startsWith(QLatin1String("http://"))) {
+                        details.providerName.remove(0, 7);
+                    }
+                    const int separator = details.providerName.indexOf(QLatin1Char('/'));
+                    if (separator > 0) {
+                        details.providerName.truncate(separator);
+                    }
+                }
+
+                details.displayName = acc->displayName();
+
+                m_accountIdToDetailsIdx.insert(id, m_accountDetails.size());
+                m_accountDetails.append(details);
+            }
+
+            if (mode == SignInMode) {
+                signInActive = true;
+                m_accountDetailsState.insert(id, Waiting);
+                signIn(id);
+            }
+
+            acc->selectService(Accounts::Service());
+        }
+    }
+
+    if (!signInActive) {
+        emit serviceReady();
+    }
+}
+
+MastodonShareServiceStatus::AccountDetails MastodonShareServiceStatus::details(int index) const
+{
+    if (index < 0 || index >= m_accountDetails.size()) {
+        qWarning() << Q_FUNC_INFO << "Index out of range";
+        return AccountDetails();
+    }
+
+    return m_accountDetails.at(index);
+}
+
+MastodonShareServiceStatus::AccountDetails MastodonShareServiceStatus::detailsByIdentifier(int accountIdentifier) const
+{
+    if (!m_accountIdToDetailsIdx.contains(accountIdentifier)) {
+        qWarning() << Q_FUNC_INFO << "No details known for account with identifier" << accountIdentifier;
+        return AccountDetails();
+    }
+
+    return m_accountDetails[m_accountIdToDetailsIdx[accountIdentifier]];
+}
diff --git a/transferengine-plugins/mastodonshareservicestatus.h b/transferengine-plugins/mastodonshareservicestatus.h
new file mode 100644
index 0000000..571efd5
--- /dev/null
+++ b/transferengine-plugins/mastodonshareservicestatus.h
@@ -0,0 +1,75 @@
+#ifndef MASTODONSHARESERVICESTATUS_H
+#define MASTODONSHARESERVICESTATUS_H
+
+#include <QtCore/QHash>
+#include <QtCore/QObject>
+#include <QtCore/QVector>
+
+#include <accountauthenticator.h>
+
+namespace Accounts {
+class Account;
+class Manager;
+}
+
+namespace SignOn {
+class Error;
+class SessionData;
+}
+
+class MastodonShareServiceStatus : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit MastodonShareServiceStatus(QObject *parent = 0);
+
+    enum QueryStatusMode {
+        PassiveMode = 0,
+        SignInMode = 1
+    };
+
+    void queryStatus(QueryStatusMode mode = SignInMode);
+
+    struct AccountDetails {
+        int accountId = 0;
+        QString providerName;
+        QString displayName;
+        QString accessToken;
+        QString apiHost;
+    };
+
+    AccountDetails details(int index = 0) const;
+    AccountDetails detailsByIdentifier(int accountIdentifier) const;
+    int count() const;
+
+    bool setCredentialsNeedUpdate(int accountId, const QString &serviceName);
+
+Q_SIGNALS:
+    void serviceReady();
+    void serviceError(const QString &message);
+
+private Q_SLOTS:
+    void signOnResponse(const SignOn::SessionData &responseData);
+    void signOnError(const SignOn::Error &error);
+
+private:
+    enum AccountDetailsState {
+        Waiting,
+        Populated,
+        Error
+    };
+
+    static QString normalizeApiHost(const QString &rawHost);
+    void setAccountDetailsState(int accountId, AccountDetailsState state);
+    void signIn(int accountId);
+
+    AccountAuthenticator *m_auth;
+    Accounts::Manager *m_accountManager;
+    QString m_serviceName;
+    QVector<AccountDetails> m_accountDetails;
+    QHash<int, int> m_accountIdToDetailsIdx;
+    QHash<int, AccountDetailsState> m_accountDetailsState;
+};
+
+#endif // MASTODONSHARESERVICESTATUS_H
diff --git a/transferengine-plugins/mastodontransferplugin/mastodonapi.cpp b/transferengine-plugins/mastodontransferplugin/mastodonapi.cpp
new file mode 100644
index 0000000..a4b40a9
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodonapi.cpp
@@ -0,0 +1,244 @@
+#include "mastodonapi.h"
+
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtNetwork/QHttpMultiPart>
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonObject>
+#include <QtCore/QUrl>
+#include <QtCore/QUrlQuery>
+
+#include <QtNetwork/QNetworkRequest>
+
+#include <QtDebug>
+
+MastodonApi::MastodonApi(QNetworkAccessManager *qnam, QObject *parent)
+    : QObject(parent)
+    , m_qnam(qnam)
+{
+}
+
+MastodonApi::~MastodonApi()
+{
+}
+
+QString MastodonApi::normalizeApiHost(const QString &rawHost)
+{
+    QString host = rawHost.trimmed();
+    if (host.isEmpty()) {
+        host = QStringLiteral("https://mastodon.social");
+    }
+
+    if (!host.startsWith(QLatin1String("https://"))
+            && !host.startsWith(QLatin1String("http://"))) {
+        host.prepend(QStringLiteral("https://"));
+    }
+
+    QUrl url(host);
+    if (!url.isValid() || url.host().isEmpty()) {
+        return QStringLiteral("https://mastodon.social");
+    }
+
+    QString normalized = QString::fromLatin1(url.toEncoded(QUrl::RemovePath
+                                                            | QUrl::RemoveQuery
+                                                            | QUrl::RemoveFragment));
+    if (normalized.endsWith(QLatin1Char('/'))) {
+        normalized.chop(1);
+    }
+
+    return normalized;
+}
+
+bool MastodonApi::uploadImage(const QString &filePath,
+                              const QString &statusText,
+                              const QString &mimeType,
+                              const QString &apiHost,
+                              const QString &accessToken)
+{
+    QFile file(filePath);
+    if (filePath.isEmpty() || !file.open(QIODevice::ReadOnly)) {
+        qWarning() << Q_FUNC_INFO << "error opening file:" << filePath;
+        return false;
+    }
+
+    m_apiHost = normalizeApiHost(apiHost);
+    m_accessToken = accessToken;
+    m_statusText = statusText;
+
+    if (m_accessToken.isEmpty()) {
+        qWarning() << Q_FUNC_INFO << "missing access token";
+        return false;
+    }
+
+    const QByteArray imageData = file.readAll();
+    const QFileInfo fileInfo(filePath);
+
+    QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
+
+    QHttpPart filePart;
+    filePart.setHeader(QNetworkRequest::ContentDispositionHeader,
+                       QVariant(QStringLiteral("form-data; name=\"file\"; filename=\"%1\"")
+                                .arg(fileInfo.fileName())));
+    if (!mimeType.isEmpty()) {
+        filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(mimeType));
+    }
+    filePart.setBody(imageData);
+    multiPart->append(filePart);
+
+    QNetworkRequest request(QUrl(m_apiHost + QStringLiteral("/api/v1/media")));
+    request.setRawHeader(QByteArrayLiteral("Authorization"),
+                         QByteArrayLiteral("Bearer ") + m_accessToken.toUtf8());
+
+    QNetworkReply *reply = m_qnam->post(request, multiPart);
+    if (!reply) {
+        delete multiPart;
+        return false;
+    }
+
+    multiPart->setParent(reply);
+    m_replies.insert(reply, UPLOAD_MEDIA);
+
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(reply, &QNetworkReply::uploadProgress,
+            this, &MastodonApi::uploadProgress);
+    connect(reply, &QNetworkReply::finished,
+            this, &MastodonApi::finished);
+
+    return true;
+}
+
+bool MastodonApi::postStatus(const QString &mediaId)
+{
+    if (mediaId.isEmpty()) {
+        qWarning() << Q_FUNC_INFO << "media id is empty";
+        return false;
+    }
+
+    QUrlQuery query;
+    if (!m_statusText.isEmpty()) {
+        query.addQueryItem(QStringLiteral("status"), m_statusText);
+    }
+    query.addQueryItem(QStringLiteral("media_ids[]"), mediaId);
+
+    const QByteArray postData = query.query(QUrl::FullyEncoded).toUtf8();
+
+    QNetworkRequest request(QUrl(m_apiHost + QStringLiteral("/api/v1/statuses")));
+    request.setRawHeader(QByteArrayLiteral("Authorization"),
+                         QByteArrayLiteral("Bearer ") + m_accessToken.toUtf8());
+    request.setHeader(QNetworkRequest::ContentTypeHeader,
+                      QVariant(QStringLiteral("application/x-www-form-urlencoded")));
+
+    QNetworkReply *reply = m_qnam->post(request, postData);
+    if (!reply) {
+        return false;
+    }
+
+    m_replies.insert(reply, POST_STATUS);
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(reply, &QNetworkReply::finished,
+            this, &MastodonApi::finished);
+
+    return true;
+}
+
+void MastodonApi::cancelUpload()
+{
+    if (m_replies.isEmpty()) {
+        qWarning() << Q_FUNC_INFO << "can't cancel upload";
+        return;
+    }
+
+    const QList<QNetworkReply*> replies = m_replies.keys();
+    Q_FOREACH (QNetworkReply *reply, replies) {
+        reply->abort();
+    }
+    m_replies.clear();
+}
+
+void MastodonApi::replyError(QNetworkReply::NetworkError error)
+{
+    Q_UNUSED(error)
+}
+
+void MastodonApi::uploadProgress(qint64 sent, qint64 total)
+{
+    if (total > 0) {
+        emit transferProgressUpdated(sent / static_cast<qreal>(total));
+    }
+}
+
+void MastodonApi::finished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
+    if (!reply || !m_replies.contains(reply)) {
+        return;
+    }
+
+    const API_CALL apiCall = m_replies.take(reply);
+    const QByteArray data = reply->readAll();
+    const int httpCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    const QNetworkReply::NetworkError error = reply->error();
+
+    reply->deleteLater();
+
+    if (apiCall == UPLOAD_MEDIA) {
+        if (error != QNetworkReply::NoError || httpCode < 200 || httpCode >= 300) {
+            finishTransfer(error == QNetworkReply::NoError ? QNetworkReply::UnknownNetworkError : error,
+                           httpCode,
+                           data);
+            return;
+        }
+
+        QString mediaId;
+        const QJsonDocument doc = QJsonDocument::fromJson(data);
+        if (doc.isObject()) {
+            const QJsonValue idValue = doc.object().value(QStringLiteral("id"));
+            if (idValue.isString()) {
+                mediaId = idValue.toString();
+            } else if (idValue.isDouble()) {
+                mediaId = QString::number(static_cast<qint64>(idValue.toDouble()));
+            }
+        }
+
+        if (!postStatus(mediaId)) {
+            qWarning() << Q_FUNC_INFO << "unable to create mastodon status";
+            emit transferError();
+        }
+        return;
+    }
+
+    if (apiCall == POST_STATUS) {
+        finishTransfer(error, httpCode, data);
+        return;
+    }
+
+    emit transferError();
+}
+
+void MastodonApi::finishTransfer(QNetworkReply::NetworkError error, int httpCode, const QByteArray &data)
+{
+    if (httpCode == 401) {
+        emit credentialsExpired();
+    }
+
+    if (error != QNetworkReply::NoError) {
+        if (error == QNetworkReply::OperationCanceledError) {
+            emit transferCanceled();
+            return;
+        }
+
+        qWarning() << Q_FUNC_INFO << "network error:" << error << "httpCode:" << httpCode << "data:" << data;
+        emit transferError();
+        return;
+    }
+
+    if (httpCode < 200 || httpCode >= 300) {
+        qWarning() << Q_FUNC_INFO << "http error:" << httpCode << "data:" << data;
+        emit transferError();
+        return;
+    }
+
+    emit transferFinished();
+}
diff --git a/transferengine-plugins/mastodontransferplugin/mastodonapi.h b/transferengine-plugins/mastodontransferplugin/mastodonapi.h
new file mode 100644
index 0000000..0ec3653
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodonapi.h
@@ -0,0 +1,56 @@
+#ifndef MASTODONAPI_H
+#define MASTODONAPI_H
+
+#include <QtCore/QMap>
+#include <QtCore/QObject>
+
+#include <QtNetwork/QNetworkAccessManager>
+#include <QtNetwork/QNetworkReply>
+
+class MastodonApi : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum API_CALL {
+        NONE,
+        UPLOAD_MEDIA,
+        POST_STATUS
+    };
+
+    explicit MastodonApi(QNetworkAccessManager *qnam, QObject *parent = 0);
+    ~MastodonApi();
+
+    bool uploadImage(const QString &filePath,
+                     const QString &statusText,
+                     const QString &mimeType,
+                     const QString &apiHost,
+                     const QString &accessToken);
+
+    void cancelUpload();
+
+Q_SIGNALS:
+    void transferProgressUpdated(qreal progress);
+    void transferFinished();
+    void transferError();
+    void transferCanceled();
+    void credentialsExpired();
+
+private Q_SLOTS:
+    void replyError(QNetworkReply::NetworkError error);
+    void finished();
+    void uploadProgress(qint64 received, qint64 total);
+
+private:
+    static QString normalizeApiHost(const QString &rawHost);
+    bool postStatus(const QString &mediaId);
+    void finishTransfer(QNetworkReply::NetworkError error, int httpCode, const QByteArray &data);
+
+    QMap<QNetworkReply*, API_CALL> m_replies;
+    QNetworkAccessManager *m_qnam;
+    QString m_accessToken;
+    QString m_apiHost;
+    QString m_statusText;
+};
+
+#endif // MASTODONAPI_H
diff --git a/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.cpp b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.cpp
new file mode 100644
index 0000000..2ee4cd0
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.cpp
@@ -0,0 +1,25 @@
+#include "mastodontransferplugin.h"
+#include "mastodonuploader.h"
+
+#include <QtPlugin>
+#include <QNetworkAccessManager>
+
+MastodonTransferPlugin::MastodonTransferPlugin()
+    : QObject(), TransferPluginInterface()
+    , m_qnam(new QNetworkAccessManager(this))
+{
+}
+
+MastodonTransferPlugin::~MastodonTransferPlugin()
+{
+}
+
+MediaTransferInterface *MastodonTransferPlugin::transferObject()
+{
+    return new MastodonUploader(m_qnam, this);
+}
+
+QString MastodonTransferPlugin::pluginId() const
+{
+    return QLatin1String("Mastodon");
+}
diff --git a/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.h b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.h
new file mode 100644
index 0000000..68cf188
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.h
@@ -0,0 +1,27 @@
+#ifndef MASTODONTRANSFERPLUGIN_H
+#define MASTODONTRANSFERPLUGIN_H
+
+#include <QtCore/QObject>
+
+#include <transferplugininterface.h>
+
+class QNetworkAccessManager;
+
+class Q_DECL_EXPORT MastodonTransferPlugin : public QObject, public TransferPluginInterface
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.sailfishos.transfer.plugin.mastodon")
+    Q_INTERFACES(TransferPluginInterface)
+
+public:
+    MastodonTransferPlugin();
+    ~MastodonTransferPlugin();
+
+    MediaTransferInterface *transferObject();
+    QString pluginId() const;
+
+private:
+    QNetworkAccessManager *m_qnam;
+};
+
+#endif // MASTODONTRANSFERPLUGIN_H
diff --git a/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.pro b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.pro
new file mode 100644
index 0000000..b37bf17
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodontransferplugin.pro
@@ -0,0 +1,24 @@
+TEMPLATE = lib
+TARGET = $$qtLibraryTarget(mastodontransferplugin)
+CONFIG += plugin
+DEPENDPATH += .
+INCLUDEPATH += ..
+
+QT += network
+
+CONFIG += link_pkgconfig
+PKGCONFIG += nemotransferengine-qt5 accounts-qt5 sailfishaccounts libsignon-qt5
+
+HEADERS += mastodontransferplugin.h \
+           mastodonuploader.h \
+           ../mastodonshareservicestatus.h \
+           mastodonapi.h
+
+SOURCES += mastodontransferplugin.cpp \
+           mastodonuploader.cpp \
+           ../mastodonshareservicestatus.cpp \
+           mastodonapi.cpp
+
+target.path = $$[QT_INSTALL_LIBS]/nemo-transferengine/plugins/transfer
+
+INSTALLS += target
diff --git a/transferengine-plugins/mastodontransferplugin/mastodonuploader.cpp b/transferengine-plugins/mastodontransferplugin/mastodonuploader.cpp
new file mode 100644
index 0000000..9e2fa1a
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodonuploader.cpp
@@ -0,0 +1,200 @@
+#include "mastodonuploader.h"
+#include "mastodonapi.h"
+
+#include <imageoperation.h>
+#include <mediaitem.h>
+
+#include <QtCore/QFile>
+#include <QtCore/QMimeDatabase>
+#include <QtCore/QMimeType>
+
+#include <QtDebug>
+
+MastodonUploader::MastodonUploader(QNetworkAccessManager *qnam, QObject *parent)
+    : MediaTransferInterface(parent)
+    , m_api(0)
+    , m_mastodonShareServiceStatus(0)
+    , m_qnam(qnam)
+    , m_useTmpFile(false)
+{
+}
+
+MastodonUploader::~MastodonUploader()
+{
+}
+
+QString MastodonUploader::displayName() const
+{
+    return tr("Mastodon");
+}
+
+QUrl MastodonUploader::serviceIcon() const
+{
+    return QUrl(QStringLiteral("image://theme/graphic-s-service-mastodon"));
+}
+
+bool MastodonUploader::cancelEnabled() const
+{
+    return true;
+}
+
+bool MastodonUploader::restartEnabled() const
+{
+    return true;
+}
+
+void MastodonUploader::start()
+{
+    if (!mediaItem()) {
+        qWarning() << Q_FUNC_INFO << "NULL MediaItem. Can't continue";
+        setStatus(MediaTransferInterface::TransferInterrupted);
+        return;
+    }
+
+    if (!m_mastodonShareServiceStatus) {
+        m_mastodonShareServiceStatus = new MastodonShareServiceStatus(this);
+        connect(m_mastodonShareServiceStatus, &MastodonShareServiceStatus::serviceReady,
+                this, &MastodonUploader::startUploading);
+        connect(m_mastodonShareServiceStatus, &MastodonShareServiceStatus::serviceError,
+                this, [this] (const QString &) {
+            transferError();
+        });
+    }
+
+    m_mastodonShareServiceStatus->queryStatus();
+}
+
+void MastodonUploader::cancel()
+{
+    if (m_api) {
+        m_api->cancelUpload();
+    } else {
+        qWarning() << Q_FUNC_INFO << "Can't cancel. NULL MastodonApi object!";
+    }
+}
+
+void MastodonUploader::startUploading()
+{
+    if (!m_mastodonShareServiceStatus) {
+        qWarning() << Q_FUNC_INFO << "NULL MastodonShareServiceStatus object!";
+        return;
+    }
+
+    const quint32 accountId = mediaItem()->value(MediaItem::AccountId).toInt();
+    m_accountDetails = m_mastodonShareServiceStatus->detailsByIdentifier(accountId);
+    if (m_accountDetails.accountId <= 0 || m_accountDetails.accessToken.isEmpty()) {
+        qWarning() << Q_FUNC_INFO << "Mastodon account details missing for id" << accountId;
+        transferError();
+        return;
+    }
+
+    postImage();
+}
+
+void MastodonUploader::transferFinished()
+{
+    setStatus(MediaTransferInterface::TransferFinished);
+}
+
+void MastodonUploader::transferProgress(qreal progress)
+{
+    setProgress(progress);
+}
+
+void MastodonUploader::transferError()
+{
+    setStatus(MediaTransferInterface::TransferInterrupted);
+    qWarning() << Q_FUNC_INFO << "Transfer interrupted";
+}
+
+void MastodonUploader::transferCanceled()
+{
+    setStatus(MediaTransferInterface::TransferCanceled);
+}
+
+void MastodonUploader::credentialsExpired()
+{
+    const quint32 accountId = mediaItem()->value(MediaItem::AccountId).toInt();
+    m_mastodonShareServiceStatus->setCredentialsNeedUpdate(accountId, QStringLiteral("mastodon-sharing"));
+}
+
+void MastodonUploader::setStatus(MediaTransferInterface::TransferStatus status)
+{
+    const bool finished = (status == TransferCanceled
+                           || status == TransferInterrupted
+                           || status == TransferFinished);
+    if (m_useTmpFile && finished) {
+        QFile::remove(m_filePath);
+        m_useTmpFile = false;
+        m_filePath.clear();
+    }
+
+    MediaTransferInterface::setStatus(status);
+}
+
+void MastodonUploader::postImage()
+{
+    m_useTmpFile = false;
+    m_filePath.clear();
+    const QString sourceFile = mediaItem()->value(MediaItem::Url).toUrl().toLocalFile();
+    if (sourceFile.isEmpty()) {
+        qWarning() << Q_FUNC_INFO << "Empty source file";
+        setStatus(MediaTransferInterface::TransferInterrupted);
+        return;
+    }
+
+    QMimeDatabase db;
+    const QMimeType mime = db.mimeTypeForFile(sourceFile);
+    const bool isJpeg = mime.name() == QLatin1String("image/jpeg");
+
+    if (isJpeg && mediaItem()->value(MediaItem::MetadataStripped).toBool()) {
+        m_useTmpFile = true;
+        m_filePath = ImageOperation::removeImageMetadata(sourceFile);
+        if (m_filePath.isEmpty()) {
+            qWarning() << Q_FUNC_INFO << "Failed to remove metadata";
+            MediaTransferInterface::setStatus(MediaTransferInterface::TransferInterrupted);
+            return;
+        }
+    }
+
+    const qreal scale = mediaItem()->value(MediaItem::ScalePercent).toReal();
+    if (0 < scale && scale < 1) {
+        m_useTmpFile = true;
+        m_filePath = ImageOperation::scaleImage(sourceFile, scale, m_filePath);
+        if (m_filePath.isEmpty()) {
+            qWarning() << Q_FUNC_INFO << "Failed to scale image";
+            MediaTransferInterface::setStatus(MediaTransferInterface::TransferInterrupted);
+            return;
+        }
+    }
+
+    if (!m_useTmpFile) {
+        m_filePath = sourceFile;
+    }
+
+    if (!m_api) {
+        m_api = new MastodonApi(m_qnam, this);
+        connect(m_api, &MastodonApi::transferProgressUpdated,
+                this, &MastodonUploader::transferProgress);
+        connect(m_api, &MastodonApi::transferFinished,
+                this, &MastodonUploader::transferFinished);
+        connect(m_api, &MastodonApi::transferError,
+                this, &MastodonUploader::transferError);
+        connect(m_api, &MastodonApi::transferCanceled,
+                this, &MastodonUploader::transferCanceled);
+        connect(m_api, &MastodonApi::credentialsExpired,
+                this, &MastodonUploader::credentialsExpired);
+    }
+
+    const bool ok = m_api->uploadImage(m_filePath,
+                                       mediaItem()->value(MediaItem::Description).toString(),
+                                       mediaItem()->value(MediaItem::MimeType).toString(),
+                                       m_accountDetails.apiHost,
+                                       m_accountDetails.accessToken);
+    if (ok) {
+        setStatus(MediaTransferInterface::TransferStarted);
+    } else {
+        setStatus(MediaTransferInterface::TransferInterrupted);
+        qWarning() << Q_FUNC_INFO << "Failed to upload image";
+    }
+}
diff --git a/transferengine-plugins/mastodontransferplugin/mastodonuploader.h b/transferengine-plugins/mastodontransferplugin/mastodonuploader.h
new file mode 100644
index 0000000..b0ea263
--- /dev/null
+++ b/transferengine-plugins/mastodontransferplugin/mastodonuploader.h
@@ -0,0 +1,51 @@
+#ifndef MASTODONUPLOADER_H
+#define MASTODONUPLOADER_H
+
+#include <QtNetwork/QNetworkAccessManager>
+
+#include <mediatransferinterface.h>
+
+#include "mastodonshareservicestatus.h"
+
+class MastodonApi;
+
+class MastodonUploader : public MediaTransferInterface
+{
+    Q_OBJECT
+
+public:
+    MastodonUploader(QNetworkAccessManager *qnam, QObject *parent = 0);
+    ~MastodonUploader();
+
+    QString displayName() const;
+    QUrl serviceIcon() const;
+    bool cancelEnabled() const;
+    bool restartEnabled() const;
+
+public Q_SLOTS:
+    void start();
+    void cancel();
+
+private Q_SLOTS:
+    void startUploading();
+    void transferFinished();
+    void transferProgress(qreal progress);
+    void transferError();
+    void transferCanceled();
+    void credentialsExpired();
+
+protected:
+    void setStatus(MediaTransferInterface::TransferStatus status);
+
+private:
+    void postImage();
+
+    MastodonApi *m_api;
+    MastodonShareServiceStatus *m_mastodonShareServiceStatus;
+    QNetworkAccessManager *m_qnam;
+    MastodonShareServiceStatus::AccountDetails m_accountDetails;
+    bool m_useTmpFile;
+    QString m_filePath;
+};
+
+#endif // MASTODONUPLOADER_H
diff --git a/transferengine-plugins/transferengine-plugins.pro b/transferengine-plugins/transferengine-plugins.pro
new file mode 100644
index 0000000..fef3cf5
--- /dev/null
+++ b/transferengine-plugins/transferengine-plugins.pro
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS = mastodonshareplugin mastodontransferplugin