Substitute video-play passive notification with an inline message

On mobile, the action of the video play notification was not properly shown. On top of that, an inline message seems more suitable for this purpose. An explicit cancel action has been added as well; previously it was accomplished by ignoring the notification.

CMakeLists.txt

@@ -36,7 +36,7 @@ kde_enable_exceptions()
 find_package(Qt5 ${QT5_MIN_VERSION} REQUIRED COMPONENTS Core Gui Qml QuickControls2 Svg)
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS Kirigami2 I18n CoreAddons Crash)
 find_package(pybind11 REQUIRED)
-find_package(YoutubeDL REQUIRED RUNTIME)
+find_package(Ytdlp REQUIRED RUNTIME)
 find_package(YTMusicAPI REQUIRED RUNTIME)
 
 add_subdirectory(src)

cmake/FindYtdlp.cmake

@@ -4,8 +4,8 @@
 
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
-execute_process(COMMAND ${Python3_EXECUTABLE} -c "import youtube_dl" RESULT_VARIABLE YTDL_CHECK_RESULT)
+execute_process(COMMAND ${Python3_EXECUTABLE} -c "import yt_dlp" RESULT_VARIABLE YTDLP_CHECK_RESULT)
 
-if (${YTDL_CHECK_RESULT} EQUAL 0)
-	set(YoutubeDL_FOUND TRUE)
+if (${YTDLP_CHECK_RESULT} EQUAL 0)
+	set(Ytdlp_FOUND TRUE)
 endif()

flatpak/python3-youtube_dl.json

@@ -1,14 +0,0 @@
-{
-    "name": "python3-youtube_dl",
-    "buildsystem": "simple",
-    "build-commands": [
-        "pip3 install --verbose --exists-action=i --no-index --find-links=\"file://${PWD}\" --prefix=${FLATPAK_DEST} \"youtube_dl\" --no-build-isolation"
-    ],
-    "sources": [
-        {
-            "type": "file",
-            "url": "https://files.pythonhosted.org/packages/c6/75/05979677d9abc76851d13d8db3951e39017ac223545adab6e8576fa0cbe7/youtube_dl-2021.6.6.tar.gz",
-            "sha256": "cb2d3ee002158ede783e97a82c95f3817594df54367ea6a77ce5ceea4772f0ab"
-        }
-    ]
-}

flatpak/python3-yt-dlp.json

@@ -0,0 +1,29 @@
+{
+    "name": "python3-yt-dlp",
+    "buildsystem": "simple",
+    "build-commands": [
+        "pip3 install --verbose --exists-action=i --no-index --find-links=\"file://${PWD}\" --prefix=${FLATPAK_DEST} \"yt-dlp\" --no-build-isolation"
+    ],
+    "sources": [
+        {
+            "type": "file",
+            "url": "https://files.pythonhosted.org/packages/5e/2a/3cbe2e29926784d8718eb2f92357d7e22caf393f24e19287746076ffc9f2/yt_dlp-2021.11.10.1-py2.py3-none-any.whl",
+            "sha256": "9c3d85fdeeac3d61cfc85fd72d55fe6b63fcf1d19d05e2841cf2e544922ed157"
+        },
+        {
+            "type": "file",
+            "url": "https://files.pythonhosted.org/packages/69/77/591bbc51a5ed6a906a7813e60a9627f988f9546513fcf9d250eb31ec8689/websockets-10.1.tar.gz",
+            "sha256": "181d2b25de5a437b36aefedaf006ecb6fa3aa1328ec0236cdde15f32f9d3ff6d"
+        },
+        {
+            "type": "file",
+            "url": "https://files.pythonhosted.org/packages/16/b3/f7aa8edf2ff4495116f95fd442b2a346aa55d1d46313143c8814886dbcdb/mutagen-1.45.1-py3-none-any.whl",
+            "sha256": "9c9f243fcec7f410f138cb12c21c84c64fde4195481a30c9bfb05b5f003adfed"
+        },
+        {
+            "type": "file",
+            "url": "https://files.pythonhosted.org/packages/47/14/dd9ad29cd29ea4cc521286f2cb401ca7ac6fd5db0791c5e9bacaf2c9ac78/pycryptodomex-3.11.0.tar.gz",
+            "sha256": "0398366656bb55ebdb1d1d493a7175fc48ade449283086db254ac44c7d318d6d"
+        }
+    ]
+}

flatpak/python3-ytmusicapi.json

@@ -7,33 +7,33 @@
     "sources": [
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/4f/5a/597ef5911cb8919efe4d86206aa8b2658616d676a7088f0825ca08bd7cb8/urllib3-1.26.6.tar.gz",
-            "sha256": "f57b4c16c62fa2760b7e3d97c35b255512fb6b59a259730f36ba32ce9f8e342f"
+            "url": "https://files.pythonhosted.org/packages/7b/77/f341b20e7307f18ede4625867cbb8e18c20199117e0c23f7c6b53fe6597d/ytmusicapi-0.19.4-py3-none-any.whl",
+            "sha256": "d0e980b35cf290eae409dcdc6ee31c5c358b28baebf1052e9fc9f446fc7901b7"
         },
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/ea/b7/e0e3c1c467636186c39925827be42f16fee389dc404ac29e930e9136be70/idna-2.10.tar.gz",
-            "sha256": "b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6"
+            "url": "https://files.pythonhosted.org/packages/92/96/144f70b972a9c0eabbd4391ef93ccd49d0f2747f4f6a2a2738e99e5adc65/requests-2.26.0-py2.py3-none-any.whl",
+            "sha256": "6c1246513ecd5ecd4528a0906f910e8f0f9c6b8ec72030dc9fd154dc1a6efd24"
         },
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/ee/2d/9cdc2b527e127b4c9db64b86647d567985940ac3698eeabc7ffaccb4ea61/chardet-4.0.0.tar.gz",
-            "sha256": "0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"
+            "url": "https://files.pythonhosted.org/packages/c8/27/141554fc0f42c05dd318fbb0be0e3e018da686544a3ff452762e49ccac58/charset_normalizer-2.0.8-py3-none-any.whl",
+            "sha256": "83fcdeb225499d6344c8f7f34684c2981270beacc32ede2e669e94f7fa544405"
         },
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/6d/78/f8db8d57f520a54f0b8a438319c342c61c22759d8f9a1cd2e2180b5e5ea9/certifi-2021.5.30.tar.gz",
-            "sha256": "2bbf76fd432960138b3ef6dda3dde0544f27cbf8546c458e60baf371917ba9ee"
+            "url": "https://files.pythonhosted.org/packages/37/45/946c02767aabb873146011e665728b680884cd8fe70dde973c640e45b775/certifi-2021.10.8-py2.py3-none-any.whl",
+            "sha256": "d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"
         },
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/6b/47/c14abc08432ab22dc18b9892252efaf005ab44066de871e72a38d6af464b/requests-2.25.1.tar.gz",
-            "sha256": "27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804"
+            "url": "https://files.pythonhosted.org/packages/04/a2/d918dcd22354d8958fe113e1a3630137e0fc8b44859ade3063982eacd2a4/idna-3.3-py3-none-any.whl",
+            "sha256": "84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"
         },
         {
             "type": "file",
-            "url": "https://files.pythonhosted.org/packages/83/aa/3e2c231fbef90d5bd75614e3739bb27e7e33e28c9891d6ee0561fe52a9df/ytmusicapi-0.18.0.tar.gz",
-            "sha256": "447d1b6a594f49942f7ac75412cba59c191b6f3540d98ac65a1333445beec16d"
+            "url": "https://files.pythonhosted.org/packages/af/f4/524415c0744552cce7d8bf3669af78e8a069514405ea4fcbd0cc44733744/urllib3-1.26.7-py2.py3-none-any.whl",
+            "sha256": "c4fdf4019605b6e5423637e01bc9fe4daef873709a7973e195ceba0a62bbc844"
         }
     ]
 }

flatpak/regenerate-sources.sh

@@ -16,5 +16,5 @@ else
 	git -C flatpak-builder-tools pull
 fi
 
-./flatpak-builder-tools/pip/flatpak-pip-generator youtube_dl
+./flatpak-builder-tools/pip/flatpak-pip-generator yt-dlp
 ./flatpak-builder-tools/pip/flatpak-pip-generator ytmusicapi

org.kde.audiotube.appdata.xml

@@ -30,8 +30,8 @@ SPDX-License-Identifier: CC0-1.0
   <name xml:lang="uk">AudioTube</name>
   <name xml:lang="x-test">xxAudioTubexx</name>
   <summary>Convergent YouTube Music client</summary>
-  <summary xml:lang="ca">Client convergent per a la música de YouTube</summary>
-  <summary xml:lang="ca-valencia">Client convergent per a la música de YouTube</summary>
+  <summary xml:lang="ca">Client convergent de música de YouTube</summary>
+  <summary xml:lang="ca-valencia">Client convergent de música de YouTube</summary>
   <summary xml:lang="de">Konvergentes YouTube-Musikprogramm</summary>
   <summary xml:lang="en-GB">Convergent YouTube Music client</summary>
   <summary xml:lang="es">Cliente de música de YouTube convergente</summary>

org.kde.audiotube.json

@@ -1,7 +1,7 @@
 {
     "id": "org.kde.audiotube",
     "runtime": "org.kde.Platform",
-    "runtime-version": "5.15",
+    "runtime-version": "5.15-21.08",
     "sdk": "org.kde.Sdk",
     "command": "audiotube",
     "tags": ["nightly"],
@@ -21,7 +21,7 @@
     ],
 
     "modules": [
-        "flatpak/python3-youtube_dl.json",
+        "flatpak/python3-yt-dlp.json",
         "flatpak/python3-ytmusicapi.json",
         {
             "name": "pybind11",

requirements.txt

@@ -3,5 +3,5 @@
 #
 # SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 
-ytmusicapi==0.18.0
-youtube_dl
+ytmusicapi==0.19.4
+ytdlp

src/albummodel.cpp

@@ -43,12 +43,7 @@ QVariant AlbumModel::data(const QModelIndex &index, int role) const
     case VideoId:
         return QString::fromStdString(m_album.tracks[index.row()].video_id.value_or(std::string()));
     case Artists:
-        return QVariant::fromValue(std::vector<meta::Artist> {
-            {
-                m_album.tracks[index.row()].artists,
-                std::nullopt
-            }
-        });
+        return QVariant::fromValue(m_album.tracks[index.row()].artists);
     }
 
     Q_UNREACHABLE();
@@ -92,5 +87,5 @@ QUrl AlbumModel::thumbnailUrl() const
 
 QString AlbumModel::playlistId() const
 {
-    return QString::fromStdString(m_album.playlist_id);
+    return QString::fromStdString(m_album.audio_playlist_id);
 }

src/asyncytmusic.cpp

@@ -16,7 +16,11 @@ namespace py = pybind11;
 template <typename R, typename T, typename OP>
 std::optional<R> map_optional(const std::optional<T> &optional, OP op) {
     if (optional.has_value()) {
-        return op(optional.value());
+        if constexpr (std::is_member_function_pointer<OP>::value) {
+            return (&optional.value()->*op)();
+        } else {
+            return op(optional.value());
+        }
     }
 
     return std::nullopt;
@@ -37,15 +41,6 @@ AsyncYTMusic::AsyncYTMusic(QObject *parent)
     qRegisterMetaType<std::vector<meta::Artist>>();
     qRegisterMetaType<meta::Artist>();
 
-    connect(this, &AsyncYTMusic::startSearch, this, &AsyncYTMusic::internalSearch);
-    connect(this, &AsyncYTMusic::startFetchArtist, this, &AsyncYTMusic::internalFetchArtist);
-    connect(this, &AsyncYTMusic::startFetchAlbum, this, &AsyncYTMusic::internalFetchAlbum);
-    connect(this, &AsyncYTMusic::startFetchSong, this, &AsyncYTMusic::internalFetchSong);
-    connect(this, &AsyncYTMusic::startFetchPlaylist, this, &AsyncYTMusic::internalFetchPlaylist);
-    connect(this, &AsyncYTMusic::startFetchArtistAlbums, this, &AsyncYTMusic::internalFetchArtistAlbums);
-    connect(this, &AsyncYTMusic::startExtractVideoInfo, this, &AsyncYTMusic::internalExtractVideoInfo);
-    connect(this, &AsyncYTMusic::startFetchWatchPlaylist, this, &AsyncYTMusic::internalFetchWatchPlaylist);
-
     connect(this, &AsyncYTMusic::errorOccurred, this, [](const QString &err) {
         std::cerr << qPrintable(err);
     });
@@ -56,16 +51,9 @@ AsyncYTMusic::AsyncYTMusic(QObject *parent)
 //
 void AsyncYTMusic::search(const QString &query)
 {
-    Q_EMIT startSearch(query);
-}
-
-void AsyncYTMusic::internalSearch(const QString &query)
-{
-    try {
+    invokeAndCatchOnThread([=]() {
         Q_EMIT searchFinished(m_ytm->search(query.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    });
 }
 
 //
@@ -73,16 +61,9 @@ void AsyncYTMusic::internalSearch(const QString &query)
 //
 void AsyncYTMusic::fetchArtist(const QString &channelId)
 {
-    Q_EMIT startFetchArtist(channelId);
-}
-
-void AsyncYTMusic::internalFetchArtist(const QString &channelId)
-{
-    try {
+    invokeAndCatchOnThread([=]() {
         Q_EMIT fetchArtistFinished(m_ytm->get_artist(channelId.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    });
 }
 
 //
@@ -90,16 +71,9 @@ void AsyncYTMusic::internalFetchArtist(const QString &channelId)
 //
 void AsyncYTMusic::fetchAlbum(const QString &browseId)
 {
-    Q_EMIT startFetchAlbum(browseId);
-}
-
-void AsyncYTMusic::internalFetchAlbum(const QString &browseId)
-{
-    try {
+    invokeAndCatchOnThread([=]() {
         Q_EMIT fetchAlbumFinished(m_ytm->get_album(browseId.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    });
 }
 
 //
@@ -107,32 +81,21 @@ void AsyncYTMusic::internalFetchAlbum(const QString &browseId)
 //
 void AsyncYTMusic::fetchSong(const QString &videoId)
 {
-    Q_EMIT startFetchSong(videoId);
-}
-
-void AsyncYTMusic::internalFetchSong(const QString &videoId)
-{
-    try {
-        Q_EMIT fetchSongFinished(m_ytm->get_song(videoId.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    invokeAndCatchOnThread([=]() {
+        auto maybeSong = m_ytm->get_song(videoId.toStdString());
+        if (maybeSong.has_value()) {
+            Q_EMIT fetchSongFinished(*maybeSong);
+        }
+    });
 }
 
 //
 // fetchPlaylist
 //
 void AsyncYTMusic::fetchPlaylist(const QString &playlistId) {
-    Q_EMIT startFetchPlaylist(playlistId);
-}
-
-void AsyncYTMusic::internalFetchPlaylist(const QString &playlistId)
-{
-    try {
+    invokeAndCatchOnThread([=]() {
         Q_EMIT fetchPlaylistFinished(m_ytm->get_playlist(playlistId.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    });
 }
 
 //
@@ -140,16 +103,9 @@ void AsyncYTMusic::internalFetchPlaylist(const QString &playlistId)
 //
 void AsyncYTMusic::fetchArtistAlbums(const QString &channelId, const QString &params)
 {
-    Q_EMIT startFetchArtistAlbums(channelId, params);
-}
-
-void AsyncYTMusic::internalFetchArtistAlbums(const QString &channelid, const QString &params)
-{
-    try {
-        Q_EMIT fetchArtistAlbumsFinished(m_ytm->get_artist_albums(channelid.toStdString(), params.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    invokeAndCatchOnThread([=]() {
+        Q_EMIT fetchArtistAlbumsFinished(m_ytm->get_artist_albums(channelId.toStdString(), params.toStdString()));
+    });
 }
 
 //
@@ -157,16 +113,9 @@ void AsyncYTMusic::internalFetchArtistAlbums(const QString &channelid, const QSt
 //
 void AsyncYTMusic::extractVideoInfo(const QString &videoId)
 {
-    Q_EMIT startExtractVideoInfo(videoId);
-}
-
-void AsyncYTMusic::internalExtractVideoInfo(const QString &videoId)
-{
-    try {
+    invokeAndCatchOnThread([=]() {
         Q_EMIT extractVideoInfoFinished(m_ytm->extract_video_info(videoId.toStdString()));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+    });
 }
 
 //
@@ -174,19 +123,22 @@ void AsyncYTMusic::internalExtractVideoInfo(const QString &videoId)
 //
 void AsyncYTMusic::fetchWatchPlaylist(const std::optional<QString> &videoId, const std::optional<QString> &playlistId)
 {
-    Q_EMIT startFetchWatchPlaylist(videoId, playlistId);
+    invokeAndCatchOnThread([=]() {
+        Q_EMIT fetchWatchPlaylistFinished(m_ytm->get_watch_playlist(
+            map_optional<std::string>(videoId, &QString::toStdString),
+            map_optional<std::string>(playlistId,  &QString::toStdString)
+        ));
+    });
 }
 
-void AsyncYTMusic::internalFetchWatchPlaylist(const std::optional<QString> &videoId, const std::optional<QString> &playlistId)
-{
-    try {
-        Q_EMIT fetchWatchPlaylistFinished(m_ytm->get_watch_playlist(
-            map_optional<std::string>(videoId, [](const QString &value) { return value.toStdString(); }),
-            map_optional<std::string>(playlistId, [](const QString &value) { return value.toStdString(); })
-        ));
-    } catch (const py::error_already_set &err) {
-        Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
-    }
+void AsyncYTMusic::invokeAndCatchOnThread(const std::function<void()> &fun) {
+    QMetaObject::invokeMethod(this, [=]() {
+        try {
+            fun();
+        } catch (const py::error_already_set &err) {
+            Q_EMIT errorOccurred(QString::fromLocal8Bit(err.what()));
+        }
+    });
 }
 
 YTMusicThread &YTMusicThread::instance()

src/asyncytmusic.h

@@ -84,29 +84,8 @@ protected:
     explicit AsyncYTMusic(QObject *parent = nullptr);
 
 private:
-    Q_SIGNAL void startSearch(const QString &query);
-    Q_SLOT void internalSearch(const QString &query);
-
-    Q_SIGNAL void startFetchArtist(const QString &channelId);
-    Q_SLOT void internalFetchArtist(const QString &channelId);
-
-    Q_SIGNAL void startFetchAlbum(const QString &browseId);
-    Q_SLOT void internalFetchAlbum(const QString &browseId);
-
-    Q_SIGNAL void startFetchSong(const QString &videoId);
-    Q_SLOT void internalFetchSong(const QString &videoId);
-
-    Q_SIGNAL void startFetchPlaylist(const QString &playlistId);
-    Q_SLOT void internalFetchPlaylist(const QString &playlistId);
-
-    Q_SIGNAL void startFetchArtistAlbums(const QString &channelid, const QString &params);
-    Q_SLOT void internalFetchArtistAlbums(const QString &channelid, const QString &params);
-
-    Q_SIGNAL void startExtractVideoInfo(const QString &videoId);
-    Q_SLOT void internalExtractVideoInfo(const QString &videoId);
-
-    Q_SIGNAL void startFetchWatchPlaylist(const std::optional<QString> &videoId, const std::optional<QString> &playlistId);
-    Q_SLOT void internalFetchWatchPlaylist(const std::optional<QString> &videoId, const std::optional<QString> &playlistId);
+    /// Invokes the given function on the thread of the YTMusic object, and handles exceptions that occur while invoking it.
+    void invokeAndCatchOnThread(const std::function<void()> &fun);
 
     // Python interpreter will be initialized from the thread calling the methods
     Lazy<YTMusic> m_ytm;

src/contents/ui/ArtistPage.qml

@@ -36,7 +36,15 @@ Kirigami.ScrollablePage {
             }
 
             onOpenVideo: (videoId, title) => {
-                askPlayVideoAudio(videoId, title)
+                videoPlayMessage.text = i18n("Video playback is not supported yet. Do you want to play only the audio of \"%1\"?", title)
+                videoPlayMessage.visible = true
+                videoPlayMessage.okAction = function() {
+                    play(videoId)
+                    videoPlayMessage.visible = false
+                }
+                videoPlayMessage.cancelAction = function() {
+                    videoPlayMessage.visible = false
+                }
             }
         }
         section.property: "type"
@@ -110,4 +118,8 @@ Kirigami.ScrollablePage {
             visible: artistModel.loading
         }
     }
+
+    footer: ConfirmationMessage {
+        id: videoPlayMessage
+    }
 }

src/contents/ui/ConfirmationMessage.qml

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2021 Dimitris Kardarakos <[email protected]>
+//
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+import QtQuick 2.15
+import org.kde.kirigami 2.14 as Kirigami
+
+Kirigami.InlineMessage {
+
+    property var okAction
+    property var cancelAction
+
+    visible: false
+    actions: [
+        Kirigami.Action {
+            text: i18n("OK")
+
+            onTriggered: okAction()
+        },
+        Kirigami.Action {
+            text: i18n("Cancel")
+
+            onTriggered: cancelAction()
+        }
+    ]
+}

src/contents/ui/PlayerFooter.qml

@@ -223,6 +223,7 @@ Item {
 
                         Behavior on value {
                             NumberAnimation {
+                                duration: 1000
                             }
 
                         }

src/contents/ui/SearchPage.qml

@@ -17,6 +17,27 @@ Kirigami.ScrollablePage {
     ListView {
         reuseItems: true
 
+        section.delegate: Kirigami.ListSectionHeader {
+            required property string section
+            text: {
+                switch (parseInt(section)) {
+                case SearchModel.Album:
+                    return i18n("Albums")
+                case SearchModel.Artist:
+                    return i18n("Artists")
+                case SearchModel.Playlist:
+                    return i18n("Playlists")
+                case SearchModel.Song:
+                    return i18n("Songs")
+                case SearchModel.Video:
+                    return i18n("Videos")
+                }
+
+                return i18n("Unknown")
+            }
+        }
+        section.property: "type"
+
         model: SearchModel {
             id: searchModel
 
@@ -43,7 +64,15 @@ Kirigami.ScrollablePage {
             }
 
             onOpenVideo: (videoId, title) => {
-                askPlayVideoAudio(videoId, title)
+                videoPlayMessage.text = i18n("Video playback is not supported yet. Do you want to play only the audio of \"%1\"?", title)
+                videoPlayMessage.visible = true
+                videoPlayMessage.okAction = function() {
+                    play(videoId)
+                    videoPlayMessage.visible = false
+                }
+                videoPlayMessage.cancelAction = function() {
+                    videoPlayMessage.visible = false
+                }
             }
         }
         delegate: Kirigami.SwipeListItem {
@@ -86,13 +115,13 @@ Kirigami.ScrollablePage {
                 Kirigami.Action {
                     icon.name: "go-next"
                     text: i18n("Play next")
-                    visible: delegateItem.type === SearchModel.Song
+                    visible: delegateItem.type === SearchModel.Song || delegateItem.type == SearchModel.Video
                     onTriggered: UserPlaylistModel.playNext(delegateItem.videoId, delegateItem.title, delegateItem.artists)
                 },
                 Kirigami.Action {
                     icon.name: "media-playlist-append"
                     text: i18n("Add to Playlist")
-                    visible: delegateItem.type === SearchModel.Song
+                    visible: delegateItem.type === SearchModel.Song || delegateItem.type == SearchModel.Video
                     onTriggered: UserPlaylistModel.append(delegateItem.videoId, delegateItem.title, delegateItem.artists)
                 },
                 Kirigami.Action {
@@ -123,4 +152,8 @@ Kirigami.ScrollablePage {
             }
         }
     }
+
+    footer: ConfirmationMessage {
+        id: videoPlayMessage
+    }
 }

src/contents/ui/main.qml

@@ -71,14 +71,6 @@ Kirigami.ApplicationWindow {
         UserPlaylistModel.playlistId = playlistId
     }
 
-    function askPlayVideoAudio(videoId, title) {
-        showPassiveNotification(i18n("Video playback is not supported yet. Do you want to play only the audio of \"%1\"?", title),
-                            "long",
-                            i18n("Play only Audio"),
-                            function() {
-                                play(videoId)
-                            })
-    }
 
     Connections {
         target: ErrorHandler

src/example/main.cpp

@@ -8,7 +8,7 @@
 
 int main() {
     const auto ytm = YTMusic();
-    const auto results = ytm.search("Thomas Bangalter");
+    const auto results = ytm.search("Another one bites the dust");
 
     std::cout << "Found " << results.size() << " results." << std::endl;
 

src/resources.qrc

@@ -12,5 +12,6 @@ SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted
         <file alias="PlayerFooter.qml">contents/ui/PlayerFooter.qml</file>
         <file alias="SearchPage.qml">contents/ui/SearchPage.qml</file>
         <file alias="PlaylistPage.qml">contents/ui/PlaylistPage.qml</file>
+        <file alias="ConfirmationMessage.qml">contents/ui/ConfirmationMessage.qml</file>
     </qresource>
 </RCC>

src/videoinfoextractor.cpp

@@ -81,7 +81,7 @@ QString VideoInfoExtractor::title() const
 
 QString VideoInfoExtractor::thumbnail() const
 {
-    return QString::fromStdString(m_videoInfo.thumnnail);
+    return QString::fromStdString(m_videoInfo.thumbnail);
 }
 
 bool VideoInfoExtractor::loading() const

src/ytmusic.cpp

@@ -13,9 +13,15 @@ namespace py = pybind11;
 
 using namespace py::literals;
 
+/// Useful for debugging
+void pyPrintPretty(py::handle obj) {
+    auto json = py::module::import("json");
+    py::print(json.attr("dumps")(obj, "indent"_a=py::int_(4)));
+}
+
 #define UNEXPORT __attribute__ ((visibility("hidden")))
 
-constexpr auto TESTED_YTMUSICAPI_VERSION = "0.18.0";
+constexpr auto TESTED_YTMUSICAPI_VERSION = "0.19.4";
 
 struct UNEXPORT YTMusicPrivate {
     py::scoped_interpreter guard {};
@@ -47,7 +53,7 @@ struct UNEXPORT YTMusicPrivate {
     py::object get_ytdl() {
         // lazy initialization
         if (ytdl.is_none()) {
-             ytdl = py::module::import("youtube_dl").attr("YoutubeDL")(py::dict());
+             ytdl = py::module::import("yt_dlp").attr("YoutubeDL")(py::dict());
         }
 
         return ytdl;
@@ -64,7 +70,7 @@ std::optional<T> optional_key(py::handle obj, const char *name) {
         return std::nullopt;
     }
 
-    return obj[name].cast<T>();
+    return obj[name].cast<std::optional<T>>();
 }
 
 meta::Thumbnail extract_thumbnail(py::handle thumbnail) {
@@ -82,28 +88,10 @@ meta::Artist extract_meta_artist(py::handle artist) {
     };
 };
 
-album::Track extract_album_track(py::handle track) {
-    return {
-        track["index"].cast<std::string>(),
-        track["title"].cast<std::string>(),
-        track["artists"].cast<std::string>(),
-        track["videoId"].cast<std::optional<std::string>>(),  // E rated songs don't have a videoId
-        track["lengthMs"].cast<std::optional<std::string>>(), //
-        track["likeStatus"].cast<std::optional<std::string>>()
-    };
-}
-
-video_info::Format extract_format(py::handle format) {
-    return {
-        optional_key<int>(format, "quality"),
-        format["url"].cast<std::string>(),
-        format["vcodec"].cast<std::string>(),
-        format["acodec"].cast<std::string>()
-    };
-}
-
 playlist::Track extract_playlist_track(py::handle track);
 watch::Playlist::Track extract_watch_track(py::handle track);
+album::Track extract_album_track(py::handle track);
+video_info::Format extract_format(py::handle format);
 
 template <typename T>
 inline auto extract_py_list(py::handle obj) {
@@ -135,6 +123,27 @@ inline auto extract_py_list(py::handle obj) {
     return output;
 }
 
+album::Track extract_album_track(py::handle track) {
+    return {
+        track["isExplicit"].cast<bool>(),
+        track["title"].cast<std::string>(),
+        extract_py_list<meta::Artist>(track["artists"]),
+        track["album"].cast<std::optional<std::string>>(),
+        track["videoId"].cast<std::optional<std::string>>(),  // E rated songs don't have a videoId
+        track["duration"].cast<std::optional<std::string>>(), //
+        track["likeStatus"].cast<std::optional<std::string>>()
+    };
+}
+
+video_info::Format extract_format(py::handle format) {
+    return {
+        optional_key<int>(format, "quality"),
+        format["url"].cast<std::string>(),
+        format["vcodec"].cast<std::string>(),
+        format["acodec"].cast<std::string>()
+    };
+}
+
 meta::Album extract_meta_album(py::handle album) {
     return meta::Album {
         album["name"].cast<std::string>(),
@@ -280,7 +289,7 @@ std::optional<search::SearchResultItem> extract_search_result(py::handle result)
             result["title"].cast<std::string>(),
             result["type"].cast<std::string>(),
             extract_py_list<meta::Artist>(result["artists"]),
-            result["year"].cast<std::string>(),
+            result["year"].cast<std::optional<std::string>>(),
             result["isExplicit"].cast<bool>()
         };
     } else if (resultType == "playlist") {
@@ -299,7 +308,8 @@ std::optional<search::SearchResultItem> extract_search_result(py::handle result)
         };
     } else {
         std::cerr << "Warning: Unsupported search result type found" << std::endl;
-        std::cerr << "It's called: " << resultType;
+        std::cerr << "It's called: " << resultType << std::endl;
+        pyPrintPretty(result);
         return std::nullopt;
     }
 }
@@ -324,10 +334,11 @@ YTMusic::~YTMusic() = default;
 std::vector<search::SearchResultItem> YTMusic::search(
         const std::string &query,
         const std::optional<std::string> &filter,
+        const std::optional<std::string> &scope,
         const int limit,
         const bool ignore_spelling) const
 {
-    const auto results = d->get_ytmusic().attr("search")(query, filter, limit, ignore_spelling).cast<py::list>();
+    const auto results = d->get_ytmusic().attr("search")("query"_a=query, "filter"_a=filter, "scope"_a=scope, "limit"_a = limit, "ignore_spelling"_a = ignore_spelling).cast<py::list>();
 
     std::vector<search::SearchResultItem> output;
     for (const auto &result : results) {
@@ -343,7 +354,7 @@ artist::Artist YTMusic::get_artist(const std::string &channel_id) const
 {
     const auto artist = d->get_ytmusic().attr("get_artist")(channel_id);
     return artist::Artist {
-        artist["description"].cast<std::optional<std::string>>(),
+        optional_key<std::string>(artist, "description"),
         artist["views"].cast<std::optional<std::string>>(),
         artist["name"].cast<std::string>(),
         artist["channelId"].cast<std::string>(),
@@ -360,31 +371,28 @@ artist::Artist YTMusic::get_artist(const std::string &channel_id) const
 album::Album YTMusic::get_album(const std::string &browseId) const
 {
     const auto album = d->get_ytmusic().attr("get_album")(browseId);
-
     return {
         album["title"].cast<std::string>(),
-        album["trackCount"].cast<std::string>(),
-        album["durationMs"].cast<std::string>(),
-        album["playlistId"].cast<std::string>(),
-        [&]() -> album::Album::ReleaseDate {
-            const auto date = album["releaseDate"];
-            return {
-                date["year"].cast<int>(),
-                date["month"].cast<int>(),
-                date["day"].cast<int>()
-            };
-        }(),
-        album["description"].cast<std::string>(),
+        album["trackCount"].cast<int>(),
+        album["duration"].cast<std::string>(),
+        album["audioPlaylistId"].cast<std::string>(),
+        album["year"].cast<std::string>(),
+        optional_key<std::string>(album, "description"),
         extract_py_list<meta::Thumbnail>(album["thumbnails"]),
-        extract_py_list<album::Track>(album["tracks"])
+        extract_py_list<album::Track>(album["tracks"]),
+        extract_py_list<meta::Artist>(album["artists"])
     };
 }
 
-song::Song YTMusic::get_song(const std::string &video_id) const
+std::optional<song::Song> YTMusic::get_song(const std::string &video_id) const
 {
     const auto song = d->get_ytmusic().attr("get_song")(video_id);
 
-    return {
+    if (!song.cast<py::dict>().contains("videoId")) {
+        return std::nullopt;
+    }
+
+    return song::Song {
         song["videoId"].cast<std::string>(),
         song["title"].cast<std::string>(),
         song["lengthSeconds"].cast<std::string>(),

src/ytmusic.h

@@ -67,7 +67,7 @@ struct Album {
     std::string title;
     std::string type;
     std::vector<meta::Artist> artists;
-    std::string year;
+    std::optional<std::string> year;
     bool is_explicit;
 };
 
@@ -122,7 +122,7 @@ struct Artist {
 
     struct Single {
         std::string title;
-        std::vector<meta::Thumbnail> thumnnails;
+        std::vector<meta::Thumbnail> thumbnails;
         std::string year;
         std::string browse_id;
     };
@@ -143,11 +143,12 @@ struct Artist {
 
 namespace album {
     struct Track {
-        std::string index;
+        bool is_explicit;
         std::string title;
-        std::string artists;
+        std::vector<meta::Artist> artists;
+        std::optional<std::string> album;
         std::optional<std::string> video_id;
-        std::optional<std::string> length_ms;
+        std::optional<std::string> duration;
         std::optional<std::string> like_status;
     };
 
@@ -159,13 +160,14 @@ namespace album {
         };
 
         std::string title;
-        std::string track_count;
-        std::string duration_ms;
-        std::string playlist_id;
-        ReleaseDate release_date;
-        std::string description;
+        int track_count;
+        std::string duration;
+        std::string audio_playlist_id;
+        std::string year;
+        std::optional<std::string> description;
         std::vector<meta::Thumbnail> thumbnails;
         std::vector<Track> tracks;
+        std::vector<meta::Artist> artists;
     };
 }
 
@@ -240,7 +242,7 @@ struct VideoInfo {
     std::string id;
     std::string title;
     std::vector<Format> formats;
-    std::string thumnnail;
+    std::string thumbnail;
 
     // More, but not interesting for us right now
 };
@@ -277,6 +279,7 @@ public:
 
     std::vector<search::SearchResultItem> search(const std::string &query,
                                                  const std::optional<std::string> &filter = std::nullopt,
+                                                 const std::optional<std::string> &scope = std::nullopt,
                                                  const int limit = 20,
                                                  const bool ignore_spelling = false) const;
 
@@ -287,7 +290,7 @@ public:
     album::Album get_album(const std::string &browse_id) const;
 
     /// https://ytmusicapi.readthedocs.io/en/latest/reference.html#ytmusicapi.YTMusic.get_song
-    song::Song get_song(const std::string &video_id) const;
+    std::optional<song::Song> get_song(const std::string &video_id) const;
 
     /// https://ytmusicapi.readthedocs.io/en/latest/reference.html#ytmusicapi.YTMusic.get_playlist
     playlist::Playlist get_playlist(const std::string &playlist_id, int limit = 100) const;