Rewire more of Sailfish frontend into new backend

This should encompass most simple things, besides some larger, trickier
things, like the video streams and the now-broken userdata

core/src/apiclient.cpp

@@ -35,6 +35,7 @@ ApiClient::ApiClient(QObject *parent)
     m_credManager = CredentialsManager::newInstance(this);
     connect(m_credManager, &CredentialsManager::serversListed, this, &ApiClient::credManagerServersListed);
     connect(m_credManager, &CredentialsManager::usersListed, this, &ApiClient::credManagerUsersListed);
+    connect(m_credManager, &CredentialsManager::tokenRetrieved, this, &ApiClient::credManagerTokenRetrieved);
     generateDeviceProfile();
 }
 
@@ -118,20 +119,14 @@ void ApiClient::credManagerUsersListed(const QString &server, QStringList users)
     QString user = users[0];
     qDebug() << "Chosen user: " << user;
 
-    QObject *ctx3 = new QObject(this);
-    connect(m_credManager, &CredentialsManager::tokenRetrieved, ctx3, [this, ctx3]
-            (const QString &server, const QString &user, const QString &token) {
-        Q_UNUSED(server)
-        this->m_token = token;
-        this->setUserId(user);
-        this->setAuthenticated(true);
-        this->postCapabilities();
-        disconnect(ctx3);
-    }, Qt::UniqueConnection);
     m_credManager->get(server, user);
 }
 void ApiClient::credManagerTokenRetrieved(const QString &server, const QString &user, const QString &token) {
-
+    this->m_token = token;
+    qDebug() << "Token retreived, logged in as user " << user;
+    this->setUserId(user);
+    this->setAuthenticated(true);
+    this->postCapabilities();
 }
 
 void ApiClient::setupConnection() {

core/src/apimodel.cpp

@@ -71,6 +71,10 @@ void BaseModelLoader::setAutoReload(bool newAutoReload) {
     if (m_autoReload != newAutoReload) {
         m_autoReload = newAutoReload;
         emit autoReloadChanged(newAutoReload);
+
+        if (canReload()) {
+            reload();
+        }
     }
 }
 

core/src/credentialmanager.cpp

@@ -42,11 +42,6 @@ QString FallbackCredentialsManager::urlToGroupName(const QString &url) const {
     return QString::number(qHash(url), 16);
 }
 
-QString FallbackCredentialsManager::groupNameToUrl(const QString &group) const {
-    QString tmp = QString(group);
-    return tmp.replace('|', "/");
-}
-
 void FallbackCredentialsManager::store(const QString &server, const QString &user, const QString &token) {
     m_settings.setValue(urlToGroupName(server) + "/users/" + user + "/accessToken", token);
     m_settings.setValue(urlToGroupName(server) + "/address", server);

core/src/jellyfin.cpp

@@ -38,11 +38,15 @@ void registerTypes(const char *uri) {
     qmlRegisterType<ViewModel::LatestMediaLoader>(uri, 1, 0, "LatestMediaLoader");
     qmlRegisterType<ViewModel::UserItemsLoader>(uri, 1, 0, "UserItemsLoader");
     qmlRegisterType<ViewModel::UserViewsLoader>(uri, 1, 0, "UsersViewsLoader");
+    qmlRegisterType<ViewModel::ResumeItemsLoader>(uri, 1, 0, "ResumeItemsLoader");
+    qmlRegisterType<ViewModel::ShowSeasonsLoader>(uri, 1, 0, "ShowSeasonsLoader");
+    qmlRegisterType<ViewModel::ShowEpisodesLoader>(uri, 1, 0, "ShowEpisodesLoader");
 
     // Enumerations
     qmlRegisterUncreatableType<Jellyfin::DTO::GeneralCommandTypeClass>(uri, 1, 0, "GeneralCommandType", "Is an enum");
     qmlRegisterUncreatableType<Jellyfin::ViewModel::ModelStatusClass>(uri, 1, 0, "ModelStatus", "Is an enum");
     qmlRegisterUncreatableType<Jellyfin::DTO::PlayMethodClass>(uri, 1, 0, "PlayMethod", "Is an enum");
+    qmlRegisterUncreatableType<Jellyfin::DTO::ItemFieldsClass>(uri, 1, 0, "ItemFields", "Is an enum");
 
     qRegisterMetaType<Jellyfin::DTO::PlayMethodClass::Value>();
 }

core/src/model/item.cpp

@@ -23,25 +23,14 @@ namespace Jellyfin {
 namespace Model {
 
 
-Item::Item()
-    : Item(DTO::BaseItemDto(), nullptr) { }
+Item::Item(QObject *parent)
+    : Item(DTO::BaseItemDto(), nullptr, parent) { }
 
-Item::Item(const DTO::BaseItemDto &data, ApiClient *apiClient)
-    : DTO::BaseItemDto(data), m_apiClient(apiClient) {
-    if (m_apiClient != nullptr) {
-        m_apiClientConnections.append(QObject::connect(
-                                          m_apiClient->eventbus(),
-                                          &EventBus::itemUserDataUpdated,
-                                          [&](auto itemId, auto userData) {
-                                              onUserDataUpdated(itemId, userData);
-                                          }));
-    }
-}
-
-Item::~Item() {
-    for(auto it = m_apiClientConnections.begin(); it != m_apiClientConnections.end(); it++) {
-        QObject::disconnect(*it);
-    }
+Item::Item(const DTO::BaseItemDto &data, ApiClient *apiClient, QObject *parent)
+    : DTO::BaseItemDto(data),
+      QObject(parent),
+      m_apiClient(nullptr) {
+    setApiClient(apiClient);
 }
 
 bool Item::sameAs(const DTO::BaseItemDto &other) {
@@ -50,23 +39,20 @@ bool Item::sameAs(const DTO::BaseItemDto &other) {
 
 void Item::setApiClient(ApiClient *apiClient) {
     if (m_apiClient != nullptr) {
-        for(auto it = m_apiClientConnections.begin(); it != m_apiClientConnections.end(); it++) {
-            QObject::disconnect(*it);
-        }
-        m_apiClientConnections.clear();
+        disconnect(m_apiClient->eventbus(), &EventBus::itemUserDataUpdated,
+                   this, &Item::updateUserData);
     }
     this->m_apiClient = apiClient;
     if (apiClient != nullptr) {
-        m_apiClientConnections.append(QObject::connect(
-                                          m_apiClient->eventbus(),
-                                          &EventBus::itemUserDataUpdated,
-                                          [&](auto itemId, auto userData) {
-                                              onUserDataUpdated(itemId, userData);
-                                          }));
+        QObject::connect(m_apiClient->eventbus(), &EventBus::itemUserDataUpdated,
+                         this, &Item::updateUserData);
     }
 }
-void Item::onUserDataUpdated(const QString &itemId, const DTO::UserItemDataDto &userData) {
 
+void Item::updateUserData(const QString &itemId, const DTO::UserItemDataDto &userData) {
+    if (itemId == this->jellyfinId()) {
+        emit userDataChanged(userData);
+    }
 }
 
 }

core/src/model/playlist.cpp

@@ -103,12 +103,12 @@ QSharedPointer<Item> Playlist::nextItem() {
     return m_nextItem;
 }
 
-void Playlist::appendToList(const ViewModel::ItemModel &model) {
+void Playlist::appendToList(ViewModel::ItemModel &model) {
     int start = m_list.size();
     int count = model.size();
     m_list.reserve(count);
     for (int i = 0; i < count; i++) {
-        m_list.append(QSharedPointer<Model::Item>::create(model.at(i)));
+        m_list.append(QSharedPointer<Model::Item>(model.at(i)));
     }
     emit itemsAddedToList(start, count);
     reshuffle();

core/src/viewmodel/item.cpp

@@ -17,17 +17,39 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "JellyfinQt/viewmodel/item.h"
+#include "JellyfinQt/viewmodel/userdata.h"
 
 namespace Jellyfin {
 namespace ViewModel {
 
 Item::Item(QObject *parent, QSharedPointer<Model::Item> data)
-    : QObject(parent), m_data(data){
-
+    : QObject(parent),
+      m_data(data),
+      m_userData(new UserData(this)){
+    connect(m_data.data(), &Model::Item::userDataChanged, this, &Item::onUserDataChanged);
 }
 
 void Item::setData(QSharedPointer<Model::Item> newData) {
+    if (!m_data.isNull()) {
+        disconnect(m_data.data(), &Model::Item::userDataChanged, this, &Item::onUserDataChanged);
+    }
     m_data = newData;
+    if (!m_data.isNull()) {
+        connect(m_data.data(), &Model::Item::userDataChanged, this, &Item::onUserDataChanged);
+    }
+}
+
+void Item::setUserData(DTO::UserItemDataDto &newData) {
+    setUserData(QSharedPointer<DTO::UserItemDataDto>::create(newData));
+}
+
+void Item::setUserData(QSharedPointer<DTO::UserItemDataDto> newData)  {
+    m_userData->setData(newData);
+    emit userDataChanged(m_userData);
+}
+
+void Item::onUserDataChanged(const DTO::UserItemDataDto &newData) {
+    setUserData(QSharedPointer<DTO::UserItemDataDto>::create(newData));
 }
 
 

core/src/viewmodel/itemmodel.cpp

@@ -18,12 +18,15 @@
  */
 #include "JellyfinQt/viewmodel/itemmodel.h"
 
+#include "JellyfinQt/loader/http/getepisodes.h"
 #include "JellyfinQt/loader/http/getlatestmedia.h"
 #include "JellyfinQt/loader/http/getitemsbyuserid.h"
+#include "JellyfinQt/loader/http/getresumeitems.h"
+#include "JellyfinQt/loader/http/getseasons.h"
 
 #define JF_CASE(roleName) case roleName: \
     try { \
-        return QVariant(item.roleName()); \
+        return QVariant(item->roleName()); \
     } catch(std::bad_optional_access &e) { \
         return QVariant(); \
     }
@@ -41,6 +44,15 @@ LatestMediaLoader::LatestMediaLoader(QObject *parent)
 UserItemsLoader::UserItemsLoader(QObject *parent)
     : UserItemsLoaderBase(new Jellyfin::Loader::HTTP::GetItemsByUserIdLoader(), parent) {}
 
+ResumeItemsLoader::ResumeItemsLoader(QObject *parent)
+    : ResumeItemsLoaderBase(new Jellyfin::Loader::HTTP::GetResumeItemsLoader(), parent) {}
+
+ShowSeasonsLoader::ShowSeasonsLoader(QObject *parent)
+    : ShowSeasonsLoaderBase(new Jellyfin::Loader::HTTP::GetSeasonsLoader(), parent) {}
+
+ShowEpisodesLoader::ShowEpisodesLoader(QObject *parent)
+    : ShowEpisodesLoaderBase(new Jellyfin::Loader::HTTP::GetEpisodesLoader(), parent) {}
+
 ItemModel::ItemModel(QObject *parent)
     : ApiModel<Model::Item>(parent) { }
 
@@ -48,7 +60,7 @@ QVariant ItemModel::data(const QModelIndex &index, int role) const {
     if (role <= Qt::UserRole || !index.isValid()) return QVariant();
     int row = index.row();
     if (row < 0 || row >= m_array.size()) return QVariant();
-    Model::Item item = m_array[row];
+    QSharedPointer<Model::Item> item = m_array[row];
     switch(role) {
     JF_CASE(jellyfinId)
     JF_CASE(name)
@@ -66,6 +78,15 @@ QVariant ItemModel::data(const QModelIndex &index, int role) const {
     JF_CASE(mediaType)
     JF_CASE(type)
     JF_CASE(collectionType)
+    case RoleNames::indexNumber:
+        return QVariant(item->indexNumber().value_or(0));
+    case RoleNames::runTimeTicks:
+        return QVariant(item->runTimeTicks().value_or(0));
+    JF_CASE(artists)
+    case RoleNames::isFolder:
+        return QVariant(item->isFolder().value_or(false));
+    case RoleNames::parentIndexNumber:
+        return QVariant(item->parentIndexNumber().value_or(1));
     default:
         return QVariant();
     }
@@ -73,7 +94,7 @@ QVariant ItemModel::data(const QModelIndex &index, int role) const {
 }
 
 QSharedPointer<Model::Item> ItemModel::itemAt(int index) {
-    return QSharedPointer<Model::Item>::create(m_array[index]);
+    return m_array[index];
 }
 
 } // NS ViewModel

core/src/viewmodel/playbackmanager.cpp

@@ -56,6 +56,7 @@ PlaybackManager::PlaybackManager(QObject *parent)
     connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, &PlaybackManager::mediaPlayerDurationChanged);
     connect(m_mediaPlayer, &QMediaPlayer::mediaStatusChanged, this, &PlaybackManager::mediaPlayerMediaStatusChanged);
     connect(m_mediaPlayer, &QMediaPlayer::videoAvailableChanged, this, &PlaybackManager::hasVideoChanged);
+    connect(m_mediaPlayer, &QMediaPlayer::seekableChanged, this, &PlaybackManager::seekableChanged);
     //                     I do not like the complicated overload cast
     connect(m_mediaPlayer, SIGNAL(error(QMediaPlayer::Error)), this, SLOT(mediaPlayerError(QMediaPlayer::Error)));
 
@@ -142,6 +143,7 @@ void PlaybackManager::mediaPlayerStateChanged(QMediaPlayer::State newState) {
         postPlaybackInfo(Progress);
     }
     m_oldState = newState;
+    emit playbackStateChanged(newState);
 }
 
 void PlaybackManager::mediaPlayerMediaStatusChanged(QMediaPlayer::MediaStatus newStatus) {
@@ -352,6 +354,9 @@ void ItemUrlFetcherThread::run() {
                 playMethod = PlayMethod::DirectPlay;
             } else if (source.supportsDirectStream()) {
                 QString mediaType = item->mediaType();
+                if (mediaType == "Video") {
+                    mediaType.append('s');
+                }
                 QUrlQuery query;
                 query.addQueryItem("mediaSourceId", source.jellyfinId());
                 query.addQueryItem("deviceId", m_parent->m_apiClient->deviceId());

core/src/viewmodel/userdata.cpp

@@ -0,0 +1,39 @@
+/*
+ * Sailfin: a Jellyfin client written using Qt
+ * Copyright (C) 2021 Chris Josten and the Sailfin Contributors.
+ *
+ * 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
+ */
+#include <JellyfinQt/viewmodel/userdata.h>
+
+namespace Jellyfin {
+namespace ViewModel {
+
+UserData::UserData(QObject *parent)
+    : QObject(parent),
+      m_data(QSharedPointer<DTO::UserItemDataDto>::create()) {
+}
+
+UserData::UserData(QSharedPointer<DTO::UserItemDataDto> data, QObject *parent)
+    : QObject(parent),
+      m_data(data) {
+}
+
+void UserData::setData(QSharedPointer<DTO::UserItemDataDto> data) {
+    m_data = data;
+}
+
+} // NS ViewModel
+} // NS Jellyfin