apiclient.h

Go to the documentation of this file.

/*
Sailfin: a Jellyfin client written using Qt
Copyright (C) 2021 Chris Josten
 
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
 
This library 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
Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#ifndef JELLYFIN_API_CLIENT
#define JELLYFIN_API_CLIENT
 
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonParseError>
#include <QJsonValue>
 
#include <QHostInfo>
#include <QObject>
#include <QQmlListProperty>
#include <QQmlParserStatus>
#include <QScopedPointer>
#include <QString>
#include <QSysInfo>
#include <QtQml>
#include <QUuid>
 
#include <QNetworkReply>
#include <QUrlQuery>
 
#include "dto/generalcommandtype.h"
#include "credentialmanager.h"
#include "model/controllablesession.h"
#include "model/deviceprofile.h"
#include "eventbus.h"
 
namespace Jellyfin {
class PlaybackManager;
class WebSocket;
 
namespace ViewModel {
class Settings;
}
 
namespace DTO {
    class UserItemDataDto; // Keep it as an opaque pointer
    using UserData = UserItemDataDto;
}
 
using namespace DTO;
 
class ApiClientPrivate;
 
class ApiClient : public QObject, public QQmlParserStatus {
    friend class WebSocket;
    friend class PlaybackManager;
    Q_OBJECT
    Q_INTERFACES(QQmlParserStatus)
    Q_DECLARE_PRIVATE(ApiClient);
public:
    explicit ApiClient(QObject *parent = nullptr);
    virtual ~ApiClient();
    Q_PROPERTY(QString baseUrl READ baseUrl WRITE setBaseUrl NOTIFY baseUrlChanged)
    Q_PROPERTY(QString appName READ appName WRITE setAppName NOTIFY appNameChanged)
    Q_PROPERTY(Jellyfin::Model::DeviceTypeClass::Value deviceType READ deviceType WRITE setDeviceType NOTIFY deviceTypeChanged)
    Q_PROPERTY(bool authenticated READ authenticated WRITE setAuthenticated NOTIFY authenticatedChanged)
    Q_PROPERTY(QString userId READ userId NOTIFY userIdChanged)
    Q_PROPERTY(QJsonObject deviceProfile READ deviceProfileJson NOTIFY deviceProfileChanged)
    Q_PROPERTY(QString version READ version)
    Q_PROPERTY(Jellyfin::EventBus *eventbus READ eventbus FINAL)
    Q_PROPERTY(Jellyfin::WebSocket *websocket READ websocket FINAL)
    Q_PROPERTY(QVariantList supportedCommands READ supportedCommands WRITE setSupportedCommands NOTIFY supportedCommandsChanged)
    Q_PROPERTY(Jellyfin::ViewModel::Settings *settings READ settings NOTIFY settingsChanged)
    Q_PROPERTY(bool online READ online NOTIFY onlineChanged)
 
    bool authenticated() const;
    void setBaseUrl(const QString &url);
    void setAppName(const QString &appName);
    void setDeviceType(Model::DeviceType deviceType);
 
    QNetworkReply *get(const QString &path, const QUrlQuery &params = QUrlQuery());
    QNetworkReply *post(const QString &path, const QJsonDocument &data, const QUrlQuery &params = QUrlQuery());
    QNetworkReply *post(const QString &path, const QByteArray &data = QByteArray(), const QUrlQuery &params = QUrlQuery());
 
    enum ApiError {
        JSON_ERROR,
        UNEXPECTED_REPLY,
        UNEXPECTED_STATUS,
        INVALID_PASSWORD
    };
    Q_ENUM(ApiError)
 
    const QString &baseUrl() const;
    const QString &appName() const;
    const QString &userId() const;
    const QString &deviceId() const;
    Model::DeviceType deviceType() const;
    QVariantList supportedCommands() const ;
    void setSupportedCommands(QVariantList newSupportedCommands);
    const QJsonObject deviceProfileJson() const;
    QSharedPointer<DTO::DeviceProfile> deviceProfile() const;
    const QJsonObject clientCapabilities() const;
    const QString &token() const;
    QString version() const;
    bool online() const;
 
    EventBus *eventbus() const;
    WebSocket *websocket() const;
    ViewModel::Settings * settings() const;
 
    void setDefaultErrorHandler(QNetworkReply *rep) {
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
        connect(rep, &QNetworkReply::errorOccurred, this, &ApiClient::defaultNetworkErrorHandler);
#else
        connect(rep, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
                this, &ApiClient::defaultNetworkErrorHandler);
#endif
    }
signals:
    /*
     * Emitted when the server requires authentication. Please authenticate your user via authenticate.
     */
    void authenticationRequired();
 
    void authenticationError(ApiError error);
 
    void connectionFailed(ApiError error);
    void connectionSuccess(QString loginMessage);
    void networkError(QNetworkReply::NetworkError error);
 
    void authenticatedChanged(bool authenticated);
    void baseUrlChanged(const QString &baseUrl);
    void appNameChanged(const QString &newAppName);
    void settingsChanged();
 
    void setupRequired();
 
    void userIdChanged(QString userId);
 
    void deviceProfileChanged();
    void deviceTypeChanged();
 
    void supportedCommandsChanged();
    void onlineChanged();
    void quickConnectAccepted();
    void quickConnectRejected();
 
    void userDataChanged(const QString &itemId, UserData *userData);
 
public slots:
    void restoreSavedSession();
    /*
     * Try to connect with the server. Tries to resolve redirects and retrieves information
     * about the login procedure. Emits connectionSuccess on success, networkError or ConnectionFailed
     * otherwise.
     */
    void setupConnection();
    void authenticate(QString username, QString password, bool storeCredentials = false);
    void submitQuickConnectCode(const QString &code);
 
    void deleteSession();
 
    void postCapabilities();
    QString downloadUrl(const QString &itemId) const;
 
protected slots:
    void defaultNetworkErrorHandler(QNetworkReply::NetworkError error);
    void onUserDataChanged(const QString &itemId, UserData *newData);
    void credManagerServersListed(QStringList users);
    void credManagerUsersListed(const QString &server, QStringList users);
    void credManagerTokenRetrieved(const QString &server, const QString &user, const QString &token);
 
    void classBegin() override;
    void componentComplete() override;
 
protected:
    void addBaseRequestHeaders(QNetworkRequest &request, const QString &path, const QUrlQuery &params = QUrlQuery()) const;
 
    void addTokenHeader(QNetworkRequest &request) const;
 
    void getBrandingConfiguration();
 
    void generateDeviceProfile();
 
 
private:
    QScopedPointer<ApiClientPrivate> d_ptr;
    QNetworkAccessManager m_naManager;
    /*
     * State information
     */
    /*
     * Setters
     */
    void setAuthenticated(bool authenticated);
    void setUserId(const QString &userId);
 
    static inline int statusCode(QNetworkReply *rep) {
        return rep->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    }
 
};
} // NS Jellyfin
 
#endif // JELLYFIN_API_CLIENT