refactor: resync with qbqt baseline and restore genre browser

.github/workflows/windows.yml

@@ -0,0 +1,49 @@
+name: Build for Windows
+
+on:
+  push:
+    branches: [ "main", "feature/cross-platform" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Setup Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: stable
+        target: x86_64-pc-windows-msvc
+
+    - name: Install Qt 6
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: '6.5.3'
+        host: 'windows'
+        target: 'desktop'
+        arch: 'win64_msvc2019_64'
+
+    - name: Configure CMake
+      run: cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
+
+    - name: Build Application
+      run: cmake --build build --config Release -j %NUMBER_OF_PROCESSORS%
+
+    - name: Bundle Executable (windeployqt)
+      run: |
+        mkdir release
+        copy build\Release\qobuz-qt.exe release\
+        windeployqt release\qobuz-qt.exe
+      shell: cmd
+
+    - name: Upload Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: qobuz-qt-windows-x64
+        path: release/

CMakeLists.txt

@@ -38,7 +38,11 @@ else()
     set(CARGO_PROFILE_FLAG "")
 endif()
 
-set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/libqobuz_backend.a")
+if(WIN32 AND MSVC)
+    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/qobuz_backend.lib")
+else()
+    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/libqobuz_backend.a")
+endif()
 
 add_custom_target(rust_backend ALL
     COMMAND ${CARGO_CMD} build ${CARGO_PROFILE_FLAG}
@@ -83,23 +87,37 @@ target_link_libraries(qobuz-qt PRIVATE
     qobuz_backend_lib
 )
 
-# Platform-specific system libs needed by the Rust audio stack (cpal/ALSA)
+# Platform-specific system libs needed by the Rust audio stack (cpal/backend internals)
 if (UNIX AND NOT APPLE)
     target_link_libraries(qobuz-qt PRIVATE asound)
+elseif (APPLE)
+    find_library(COREAUDIO CoreAudio)
+    find_library(AUDIOTOOLBOX AudioToolbox)
+    find_library(SECURITY Security)
+    find_library(COREFOUNDATION CoreFoundation)
+    target_link_libraries(qobuz-qt PRIVATE ${COREAUDIO} ${AUDIOTOOLBOX} ${SECURITY} ${COREFOUNDATION})
+elseif (WIN32)
+    target_link_libraries(qobuz-qt PRIVATE ws2_32 userenv bcrypt advapi32 ntdll ole32)
 endif ()
 
 # Compiler warnings + hardening
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     target_compile_options(qobuz-qt PRIVATE
         -Wall -Wextra -Wno-unused-parameter
-        -fstack-protector-strong
-        -D_FORTIFY_SOURCE=2
-        -fPIE
-    )
-    target_link_options(qobuz-qt PRIVATE
-        -pie
-        -Wl,-z,relro,-z,now
     )
+    if (UNIX AND NOT APPLE)
+        target_compile_options(qobuz-qt PRIVATE
+            -fstack-protector-strong
+            -D_FORTIFY_SOURCE=2
+            -fPIE
+        )
+        target_link_options(qobuz-qt PRIVATE
+            -pie
+            -Wl,-z,relro,-z,now
+        )
+    endif ()
+elseif (MSVC)
+    target_compile_options(qobuz-qt PRIVATE /W3 /Zc:__cplusplus /permissive-)
 endif ()
 
 # D-Bus
@@ -118,7 +136,7 @@ if (USE_LTO)
 endif ()
 
 # Install
-if (UNIX)
+if (UNIX AND NOT APPLE)
     install(FILES res/logo/qobuz-qt.svg DESTINATION share/icons/hicolor/scalable/apps)
     install(FILES res/app/qobuz-qt.desktop DESTINATION share/applications)
     install(TARGETS qobuz-qt RUNTIME DESTINATION bin)

rust/include/qobuz_backend.h

@@ -37,6 +37,8 @@ enum QobuzEvent {
     EV_USER_OK               = 23,
     EV_ARTIST_RELEASES_OK    = 24,
     EV_DEEP_SHUFFLE_OK       = 25,
+    EV_GENRES_OK             = 27,
+    EV_FEATURED_ALBUMS_OK    = 28,
 };
 
 // Callback signature
@@ -53,7 +55,6 @@ void qobuz_backend_get_user(QobuzBackendOpaque *backend);
 
 // Catalog
 void qobuz_backend_search(QobuzBackendOpaque *backend, const char *query, uint32_t offset, uint32_t limit);
-void qobuz_backend_most_popular_search(QobuzBackendOpaque *backend, const char *query, uint32_t limit);
 void qobuz_backend_get_album(QobuzBackendOpaque *backend, const char *album_id);
 void qobuz_backend_get_artist(QobuzBackendOpaque *backend, int64_t artist_id);
 void qobuz_backend_get_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, uint32_t offset, uint32_t limit);
@@ -89,6 +90,10 @@ void qobuz_backend_get_artist_releases(QobuzBackendOpaque *backend, int64_t arti
 // Deep shuffle: fetch tracks from multiple albums (album_ids_json is a JSON array of strings)
 void qobuz_backend_get_albums_tracks(QobuzBackendOpaque *backend, const char *album_ids_json);
 
+// Browse
+void qobuz_backend_get_genres(QobuzBackendOpaque *backend);
+void qobuz_backend_get_featured_albums(QobuzBackendOpaque *backend, int64_t genre_id, const char *kind, uint32_t limit, uint32_t offset);
+
 // Playlist management
 void qobuz_backend_create_playlist(QobuzBackendOpaque *backend, const char *name);
 void qobuz_backend_delete_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);

rust/src/api/client.rs

@@ -40,7 +40,11 @@ fn b64url_decode(s: &str) -> Result<Vec<u8>> {
 /// Full qbz-1 key derivation:
 ///   Phase 1: HKDF-SHA256(ikm=hex(app_secret), salt=b64url(infos[0]), info=b64url(infos[1])) → 16-byte KEK
 ///   Phase 2: AES-128-CBC/NoPadding(key=KEK, iv=b64url(key_field[2])).decrypt(b64url(key_field[1]))[..16]
-fn derive_track_key(session_infos: &str, app_secret_hex: &str, key_field: &str) -> Result<[u8; 16]> {
+fn derive_track_key(
+    session_infos: &str,
+    app_secret_hex: &str,
+    key_field: &str,
+) -> Result<[u8; 16]> {
     // Phase 1: HKDF
     let infos_parts: Vec<&str> = session_infos.splitn(2, '.').collect();
     if infos_parts.len() != 2 {
@@ -63,7 +67,11 @@ fn derive_track_key(session_infos: &str, app_secret_hex: &str, key_field: &str)
     let ct = b64url_decode(key_parts[1])?;
     let iv_bytes = b64url_decode(key_parts[2])?;
     if ct.len() < 16 || iv_bytes.len() < 16 {
-        bail!("key field ciphertext/iv too short ({} / {} bytes)", ct.len(), iv_bytes.len());
+        bail!(
+            "key field ciphertext/iv too short ({} / {} bytes)",
+            ct.len(),
+            iv_bytes.len()
+        );
     }
 
     let iv: [u8; 16] = iv_bytes[..16].try_into()?;
@@ -202,7 +210,10 @@ impl QobuzClient {
         let status = resp.status();
         let body: Value = resp.json().await?;
         if !status.is_success() {
-            let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
+            let msg = body
+                .get("message")
+                .and_then(|m| m.as_str())
+                .unwrap_or("login failed");
             bail!("login failed ({}): {}", status, msg);
         }
 
@@ -238,9 +249,7 @@ impl QobuzClient {
         }
 
         let ts = Self::ts();
-        let mut sign_params: Vec<(&str, String)> = vec![
+        let mut sign_params: Vec<(&str, String)> = vec![("profile", "qbz-1".to_string())];
-            ("profile", "qbz-1".to_string()),
-        ];
         let sig = self.request_sig("sessionstart", &mut sign_params, ts);
 
         let resp = self
@@ -251,7 +260,10 @@ impl QobuzClient {
                 ("request_ts", ts.to_string().as_str()),
                 ("request_sig", sig.as_str()),
             ])
-            .header("Authorization", format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")))
+            .header(
+                "Authorization",
+                format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")),
+            )
             .form(&[("profile", "qbz-1")])
             .send()
             .await?;
@@ -263,7 +275,12 @@ impl QobuzClient {
             .to_string();
         let expires_at = body["expires_at"].as_u64().unwrap_or(now + 3600);
         let infos = body["infos"].as_str().map(|s| s.to_string());
-        eprintln!("[session] started session_id={}... expires_at={} infos={:?}", &session_id[..session_id.len().min(8)], expires_at, infos);
+        eprintln!(
+            "[session] started session_id={}... expires_at={} infos={:?}",
+            &session_id[..session_id.len().min(8)],
+            expires_at,
+            infos
+        );
         self.session_id = Some(session_id);
         self.session_expires_at = Some(expires_at);
         self.session_infos = infos;
@@ -292,7 +309,11 @@ impl QobuzClient {
         Ok(serde_json::from_value(body)?)
     }
 
-    pub async fn get_track_url(&mut self, track_id: i64, format: Format) -> Result<TrackFileUrlDto> {
+    pub async fn get_track_url(
+        &mut self,
+        track_id: i64,
+        format: Format,
+    ) -> Result<TrackFileUrlDto> {
         self.ensure_session().await?;
 
         let ts = Self::ts();
@@ -317,11 +338,15 @@ impl QobuzClient {
             .await?;
 
         let body = Self::check_response(resp).await?;
-        eprintln!("[file/url] response: {}", serde_json::to_string(&body).unwrap_or_default());
+        eprintln!(
+            "[file/url] response: {}",
+            serde_json::to_string(&body).unwrap_or_default()
+        );
         let mut url_dto: TrackFileUrlDto = serde_json::from_value(body)?;
 
         // Unwrap the per-track key: decrypt the CBC-wrapped key using HKDF-derived KEK.
-        if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref()) {
+        if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref())
+        {
             match derive_track_key(infos, &self.app_secret, &key_field) {
                 Ok(track_key) => {
                     url_dto.key = Some(hex::encode(track_key));
@@ -370,12 +395,39 @@ impl QobuzClient {
         let resp = self
             .get_request("artist/getReleasesList")
             .query(&[
-                ("artist_id",    artist_id.to_string()),
+                ("artist_id", artist_id.to_string()),
                 ("release_type", release_type.to_string()),
-                ("sort",         "release_date".to_string()),
+                ("sort", "release_date".to_string()),
-                ("order",        "desc".to_string()),
+                ("order", "desc".to_string()),
-                ("limit",        limit.to_string()),
+                ("limit", limit.to_string()),
-                ("offset",       offset.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    // --- Browse ---
+
+    pub async fn get_genres(&self) -> Result<Value> {
+        let resp = self.get_request("genre/list").send().await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_featured_albums(
+        &self,
+        genre_id: i64,
+        kind: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("album/getFeatured")
+            .query(&[
+                ("type", kind.to_string()),
+                ("genre_id", genre_id.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
             ])
             .send()
             .await?;
@@ -384,54 +436,74 @@ impl QobuzClient {
 
     // --- Search ---
 
-    pub async fn most_popular_search(&self, query: &str, limit: u32) -> Result<serde_json::Value> {
-        let resp = self
-            .get_request("most-popular/get")
-            .query(&[("query", query), ("offset", "0"), ("limit", &limit.to_string())])
-            .send()
-            .await?;
-        Self::check_response(resp).await
-    }
-
     pub async fn search(&self, query: &str, offset: u32, limit: u32) -> Result<SearchCatalogDto> {
-        let (tracks, albums, artists) = tokio::try_join!(
+        let (tracks_res, albums_res, artists_res) = tokio::join!(
             self.search_tracks(query, offset, limit),
             self.search_albums(query, offset, limit),
             self.search_artists(query, offset, limit),
-        )?;
+        );
+
+        // Convert successful Results into Some(value) and Errors into None
         Ok(SearchCatalogDto {
             query: Some(query.to_string()),
-            albums: Some(albums),
+            tracks: tracks_res.ok(),
-            tracks: Some(tracks),
+            albums: albums_res.ok(),
-            artists: Some(artists),
+            artists: artists_res.ok(),
             playlists: None,
         })
     }
 
-    async fn search_tracks(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
+    async fn search_tracks(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
         let resp = self
             .get_request("track/search")
-            .query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
         Ok(serde_json::from_value(body["tracks"].clone())?)
     }
 
-    async fn search_albums(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
+    async fn search_albums(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
         let resp = self
             .get_request("album/search")
-            .query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
         Ok(serde_json::from_value(body["albums"].clone())?)
     }
 
-    async fn search_artists(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<ArtistDto>> {
+    async fn search_artists(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<ArtistDto>> {
         let resp = self
             .get_request("artist/search")
-            .query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
@@ -443,14 +515,22 @@ impl QobuzClient {
     pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
         let resp = self
             .get_request("playlist/getUserPlaylists")
-            .query(&[("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            .query(&[
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
         Ok(serde_json::from_value(body)?)
     }
 
-    pub async fn get_playlist(&self, playlist_id: i64, offset: u32, limit: u32) -> Result<PlaylistDto> {
+    pub async fn get_playlist(
+        &self,
+        playlist_id: i64,
+        offset: u32,
+        limit: u32,
+    ) -> Result<PlaylistDto> {
         let resp = self
             .get_request("playlist/get")
             .query(&[
@@ -486,14 +566,16 @@ impl QobuzClient {
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
-        let items: Vec<TrackDto> = serde_json::from_value(
+        let items: Vec<TrackDto> =
-            body["tracks"]["items"].clone(),
+            serde_json::from_value(body["tracks"]["items"].clone()).unwrap_or_default();
-        )
-        .unwrap_or_default();
         Ok(items)
     }
 
-    pub async fn get_fav_tracks(&self, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
+    pub async fn get_fav_tracks(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
         let ids = self.get_fav_ids().await?;
         let all_ids = ids.tracks.unwrap_or_default();
         let total = all_ids.len() as i32;
@@ -511,7 +593,11 @@ impl QobuzClient {
         })
     }
 
-    pub async fn get_fav_albums(&self, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
+    pub async fn get_fav_albums(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
         let ids = self.get_fav_ids().await?;
         let all_ids = ids.albums.unwrap_or_default();
         let total = all_ids.len() as i32;
@@ -536,7 +622,11 @@ impl QobuzClient {
         })
     }
 
-    pub async fn get_fav_artists(&self, offset: u32, limit: u32) -> Result<SearchResultItems<FavArtistDto>> {
+    pub async fn get_fav_artists(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<FavArtistDto>> {
         let ids = self.get_fav_ids().await?;
         let all_ids = ids.artists.unwrap_or_default();
         let total = all_ids.len() as i32;
@@ -549,8 +639,40 @@ impl QobuzClient {
         for artist_id in page {
             match self.get_artist_page(artist_id).await {
                 Ok(v) => {
-                    if let Ok(a) = serde_json::from_value::<FavArtistDto>(v) {
+                    let id = v.get("id").and_then(|i| i.as_i64());
-                        items.push(a);
+                    let name = v
+                        .get("name")
+                        .and_then(|n| n.get("display"))
+                        .and_then(|d| d.as_str())
+                        .map(|s| s.to_string());
+
+                    let mut image_dto = None;
+                    if let Some(imgs) = v.get("images") {
+                        if let Some(portrait) = imgs.get("portrait") {
+                            if let (Some(hash), Some(format)) = (
+                                portrait.get("hash").and_then(|h| h.as_str()),
+                                portrait.get("format").and_then(|f| f.as_str()),
+                            ) {
+                                image_dto = Some(ImageDto {
+                                    small: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    thumbnail: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    large: Some(format!("https://static.qobuz.com/images/artists/covers/large/{}.{}", hash, format)),
+                                    back: None,
+                                });
+                            }
+                        }
+                    }
+
+                    if id.is_some() && name.is_some() {
+                        items.push(FavArtistDto {
+                            id,
+                            name,
+                            albums_count: v
+                                .get("albums_count")
+                                .and_then(|c| c.as_i64())
+                                .map(|c| c as i32),
+                            image: image_dto,
+                        });
                     }
                 }
                 Err(e) => eprintln!("[fav] failed to fetch artist {}: {}", artist_id, e),
@@ -569,7 +691,11 @@ impl QobuzClient {
     pub async fn create_playlist(&self, name: &str) -> Result<PlaylistDto> {
         let resp = self
             .post_request("playlist/create")
-            .form(&[("name", name), ("is_public", "false"), ("is_collaborative", "false")])
+            .form(&[
+                ("name", name),
+                ("is_public", "false"),
+                ("is_collaborative", "false"),
+            ])
             .send()
             .await?;
         let body = Self::check_response(resp).await?;
@@ -581,7 +707,7 @@ impl QobuzClient {
             .post_request("playlist/addTracks")
             .form(&[
                 ("playlist_id", playlist_id.to_string()),
-                ("track_ids",   track_id.to_string()),
+                ("track_ids", track_id.to_string()),
                 ("no_duplicate", "true".to_string()),
             ])
             .send()
@@ -600,11 +726,15 @@ impl QobuzClient {
         Ok(())
     }
 
-    pub async fn delete_track_from_playlist(&self, playlist_id: i64, playlist_track_id: i64) -> Result<()> {
+    pub async fn delete_track_from_playlist(
+        &self,
+        playlist_id: i64,
+        playlist_track_id: i64,
+    ) -> Result<()> {
         let resp = self
             .post_request("playlist/deleteTracks")
             .form(&[
-                ("playlist_id",        playlist_id.to_string()),
+                ("playlist_id", playlist_id.to_string()),
                 ("playlist_track_ids", playlist_track_id.to_string()),
             ])
             .send()

rust/src/lib.rs

@@ -1,26 +1,4 @@
 //! qobuz-backend: C-ABI library consumed by the Qt frontend.
-//!
-//! Event type constants – second argument of EventCallback:
-//!   0  EV_LOGIN_OK        { "token": "…", "user": { … } }
-//!   1  EV_LOGIN_ERR       { "error": "…" }
-//!   2  EV_SEARCH_OK       SearchCatalogDto
-//!   3  EV_SEARCH_ERR      { "error": "…" }
-//!   4  EV_ALBUM_OK        AlbumDto
-//!   5  EV_ALBUM_ERR       { "error": "…" }
-//!   6  EV_ARTIST_OK       ArtistDto
-//!   7  EV_ARTIST_ERR      { "error": "…" }
-//!   8  EV_PLAYLIST_OK     PlaylistDto
-//!   9  EV_PLAYLIST_ERR    { "error": "…" }
-//!  10  EV_FAV_TRACKS_OK   { "items": […], "total": N }
-//!  11  EV_FAV_ALBUMS_OK   { "items": […], "total": N }
-//!  12  EV_FAV_ARTISTS_OK  { "items": […], "total": N }
-//!  13  EV_PLAYLISTS_OK    { "items": […], "total": N }
-//!  14  EV_TRACK_CHANGED   TrackDto
-//!  15  EV_STATE_CHANGED   { "state": "playing"|"paused"|"idle"|"error" }
-//!  16  EV_POSITION        { "position": u64, "duration": u64 }
-//!  17  EV_TRACK_URL_OK    TrackFileUrlDto
-//!  18  EV_TRACK_URL_ERR   { "error": "…" }
-//!  19  EV_GENERIC_ERR     { "error": "…" }
 
 mod api;
 mod player;
@@ -38,9 +16,6 @@ use tokio::sync::Mutex;
 
 // ---------- Send-safe raw pointer wrapper ----------
 
-/// Wraps a `*mut c_void` so it can cross thread boundaries.
-/// SAFETY: The Qt QobuzBackend object is kept alive for the Backend's lifetime
-/// and callbacks only call QMetaObject::invokeMethod (thread-safe Qt API).
 #[derive(Clone, Copy)]
 struct SendPtr(*mut c_void);
 unsafe impl Send for SendPtr {}
@@ -70,7 +45,8 @@ pub const EV_TRACK_URL_ERR: c_int = 18;
 pub const EV_GENERIC_ERR: c_int = 19;
 pub const EV_ARTIST_RELEASES_OK: c_int = 24;
 pub const EV_DEEP_SHUFFLE_OK: c_int = 25;
-pub const EV_MOST_POPULAR_OK: c_int = 26;
+pub const EV_GENRES_OK: c_int = 27;
+pub const EV_FEATURED_ALBUMS_OK: c_int = 28;
 
 // ---------- Callback ----------
 
@@ -102,7 +78,6 @@ pub struct Backend(BackendInner);
 // ---------- Helpers ----------
 
 fn call_cb(cb: EventCallback, ud: SendPtr, ev: c_int, json: &str) {
-    // Strip null bytes that would cause CString::new to fail
     let safe = json.replace('\0', "");
     let cstr = CString::new(safe).unwrap_or_else(|_| CString::new("{}").unwrap());
     unsafe { cb(ud.0, ev, cstr.as_ptr()) };
@@ -112,7 +87,6 @@ fn err_json(msg: &str) -> String {
     serde_json::json!({ "error": msg }).to_string()
 }
 
-/// Spawn a Send + 'static future on the backend's Tokio runtime.
 fn spawn<F>(inner: &BackendInner, f: F)
 where
     F: std::future::Future<Output = ()> + Send + 'static,
@@ -163,26 +137,33 @@ pub unsafe extern "C" fn qobuz_backend_login(
     email: *const c_char,
     password: *const c_char,
 ) {
-    let inner    = &(*ptr).0;
+    let inner = &(*ptr).0;
-    let email    = CStr::from_ptr(email).to_string_lossy().into_owned();
+    let email = CStr::from_ptr(email).to_string_lossy().into_owned();
     let password = CStr::from_ptr(password).to_string_lossy().into_owned();
-    let client   = inner.client.clone();
+    let client = inner.client.clone();
-    let cb       = inner.cb;
+    let cb = inner.cb;
-    let ud       = inner.ud;
+    let ud = inner.ud;
 
     spawn(inner, async move {
         let result = client.lock().await.login(&email, &password).await;
         let (ev, json) = match result {
             Ok(resp) => {
                 let token = resp
-                    .oauth2.as_ref().and_then(|o| o.access_token.as_deref())
+                    .oauth2
+                    .as_ref()
+                    .and_then(|o| o.access_token.as_deref())
                     .or(resp.user_auth_token.as_deref())
                     .unwrap_or("")
                     .to_string();
-                let user_val = resp.user.as_ref()
+                let user_val = resp
+                    .user
+                    .as_ref()
                     .map(|u| serde_json::to_value(u).unwrap_or_default())
                     .unwrap_or_default();
-                (EV_LOGIN_OK, serde_json::json!({"token": token, "user": user_val}).to_string())
+                (
+                    EV_LOGIN_OK,
+                    serde_json::json!({"token": token, "user": user_val}).to_string(),
+                )
             }
             Err(e) => (EV_LOGIN_ERR, err_json(&e.to_string())),
         };
@@ -194,8 +175,6 @@ pub unsafe extern "C" fn qobuz_backend_login(
 pub unsafe extern "C" fn qobuz_backend_set_token(ptr: *mut Backend, token: *const c_char) {
     let inner = &(*ptr).0;
     let token = CStr::from_ptr(token).to_string_lossy().into_owned();
-    // Use blocking_lock (called from Qt main thread, not a tokio thread) so the
-    // token is set before any subsequent getUser/library requests are spawned.
     inner.client.blocking_lock().set_auth_token(token);
 }
 
@@ -207,27 +186,6 @@ pub unsafe extern "C" fn qobuz_backend_search(
     query: *const c_char,
     offset: u32,
     limit: u32,
-) {
-    let inner  = &(*ptr).0;
-    let query  = CStr::from_ptr(query).to_string_lossy().into_owned();
-    let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
-
-    spawn(inner, async move {
-        let result = client.lock().await.search(&query, offset, limit).await;
-        let (ev, json) = match result {
-            Ok(r)  => (EV_SEARCH_OK,  serde_json::to_string(&r).unwrap_or_default()),
-            Err(e) => (EV_SEARCH_ERR, err_json(&e.to_string())),
-        };
-        call_cb(cb, ud, ev, &json);
-    });
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn qobuz_backend_most_popular_search(
-    ptr: *mut Backend,
-    query: *const c_char,
-    limit: u32,
 ) {
     let inner = &(*ptr).0;
     let query = CStr::from_ptr(query).to_string_lossy().into_owned();
@@ -236,10 +194,10 @@ pub unsafe extern "C" fn qobuz_backend_most_popular_search(
     let ud = inner.ud;
 
     spawn(inner, async move {
-        let result = client.lock().await.most_popular_search(&query, limit).await;
+        let result = client.lock().await.search(&query, offset, limit).await;
         let (ev, json) = match result {
-            Ok(r) => (EV_MOST_POPULAR_OK, serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (EV_SEARCH_OK, serde_json::to_string(&r).unwrap_or_default()),
-            Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
+            Err(e) => (EV_SEARCH_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
     });
@@ -249,15 +207,16 @@ pub unsafe extern "C" fn qobuz_backend_most_popular_search(
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_get_album(ptr: *mut Backend, album_id: *const c_char) {
-    let inner    = &(*ptr).0;
+    let inner = &(*ptr).0;
     let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
 
     spawn(inner, async move {
         let result = client.lock().await.get_album(&album_id).await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_ALBUM_OK,  serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (EV_ALBUM_OK, serde_json::to_string(&r).unwrap_or_default()),
             Err(e) => (EV_ALBUM_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
@@ -268,14 +227,15 @@ pub unsafe extern "C" fn qobuz_backend_get_album(ptr: *mut Backend, album_id: *c
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_get_artist(ptr: *mut Backend, artist_id: i64) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
 
     spawn(inner, async move {
         let result = client.lock().await.get_artist_page(artist_id).await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_ARTIST_OK,  serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (EV_ARTIST_OK, serde_json::to_string(&r).unwrap_or_default()),
             Err(e) => (EV_ARTIST_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
@@ -292,17 +252,19 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
     limit: u32,
     _offset: u32,
 ) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     let rtype = CStr::from_ptr(release_type).to_string_lossy().into_owned();
 
     spawn(inner, async move {
-        // Auto-paginate: fetch all pages until has_more is false.
         let mut all_items: Vec<serde_json::Value> = Vec::new();
         let mut offset: u32 = 0;
         loop {
-            let result = client.lock().await
+            let result = client
+                .lock()
+                .await
                 .get_artist_releases_list(artist_id, &rtype, limit, offset)
                 .await;
             match result {
@@ -311,7 +273,10 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
                     if let Some(items) = obj.get("items").and_then(|v| v.as_array()) {
                         all_items.extend(items.iter().cloned());
                     }
-                    let has_more = obj.get("has_more").and_then(|v| v.as_bool()).unwrap_or(false);
+                    let has_more = obj
+                        .get("has_more")
+                        .and_then(|v| v.as_bool())
+                        .unwrap_or(false);
                     if !has_more {
                         break;
                     }
@@ -329,7 +294,12 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
             "has_more": false,
             "offset": 0
         });
-        call_cb(cb, ud, EV_ARTIST_RELEASES_OK, &serde_json::to_string(&result).unwrap_or_default());
+        call_cb(
+            cb,
+            ud,
+            EV_ARTIST_RELEASES_OK,
+            &serde_json::to_string(&result).unwrap_or_default(),
+        );
     });
 }
 
@@ -342,8 +312,11 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
 ) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
-    let ids_str = CStr::from_ptr(album_ids_json).to_string_lossy().into_owned();
+    let ud = inner.ud;
+    let ids_str = CStr::from_ptr(album_ids_json)
+        .to_string_lossy()
+        .into_owned();
 
     let album_ids: Vec<String> = match serde_json::from_str(&ids_str) {
         Ok(v) => v,
@@ -360,17 +333,18 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
             if let Ok(album) = result {
                 if let Some(tracks) = album.tracks.as_ref().and_then(|t| t.items.as_ref()) {
                     for t in tracks {
-                        // Serialize track and inject album info for playback context
                         if let Ok(mut tv) = serde_json::to_value(t) {
                             if let Some(obj) = tv.as_object_mut() {
-                                // Ensure album context is present on each track
                                 if obj.get("album").is_none() || obj["album"].is_null() {
-                                    obj.insert("album".to_string(), serde_json::json!({
+                                    obj.insert(
-                                        "id": album.id,
+                                        "album".to_string(),
-                                        "title": album.title,
+                                        serde_json::json!({
-                                        "artist": album.artist,
+                                            "id": album.id,
-                                        "image": album.image,
+                                            "title": album.title,
-                                    }));
+                                            "artist": album.artist,
+                                            "image": album.image,
+                                        }),
+                                    );
                                 }
                             }
                             all_tracks.push(tv);
@@ -378,10 +352,86 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
                     }
                 }
             }
-            // Skip albums that fail — don't abort the whole operation
         }
         let result = serde_json::json!({ "tracks": all_tracks });
-        call_cb(cb, ud, EV_DEEP_SHUFFLE_OK, &serde_json::to_string(&result).unwrap_or_default());
+        call_cb(
+            cb,
+            ud,
+            EV_DEEP_SHUFFLE_OK,
+            &serde_json::to_string(&result).unwrap_or_default(),
+        );
+    });
+}
+
+// ---------- Playlist ----------
+
+// ---------- Browse (genres / featured) ----------
+
+#[no_mangle]
+pub unsafe extern "C" fn qobuz_backend_get_genres(ptr: *mut Backend) {
+    let inner = &(*ptr).0;
+    let client = inner.client.clone();
+    let cb = inner.cb;
+    let ud = inner.ud;
+
+    spawn(inner, async move {
+        let result = client.lock().await.get_genres().await;
+        match result {
+            Ok(r) => {
+                let items = r["genres"]["items"].clone();
+                let total = r["genres"]["total"].as_i64().unwrap_or(0);
+                let out = serde_json::json!({"items": items, "total": total});
+                call_cb(
+                    cb,
+                    ud,
+                    EV_GENRES_OK,
+                    &serde_json::to_string(&out).unwrap_or_default(),
+                );
+            }
+            Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
+        }
+    });
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn qobuz_backend_get_featured_albums(
+    ptr: *mut Backend,
+    genre_id: i64,
+    kind: *const c_char,
+    limit: u32,
+    offset: u32,
+) {
+    let inner = &(*ptr).0;
+    let client = inner.client.clone();
+    let cb = inner.cb;
+    let ud = inner.ud;
+    let kind_str = CStr::from_ptr(kind).to_string_lossy().into_owned();
+
+    spawn(inner, async move {
+        let result = client
+            .lock()
+            .await
+            .get_featured_albums(genre_id, &kind_str, limit, offset)
+            .await;
+        match result {
+            Ok(r) => {
+                let items = r["albums"]["items"].clone();
+                let total = r["albums"]["total"].as_i64().unwrap_or(0);
+                let out = serde_json::json!({
+                    "items": items,
+                    "total": total,
+                    "type": kind_str,
+                    "genre_id": genre_id,
+                });
+                call_cb(
+                    cb,
+                    ud,
+                    EV_FEATURED_ALBUMS_OK,
+                    &serde_json::to_string(&out).unwrap_or_default(),
+                );
+            }
+            Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
+        }
     });
 }
 
@@ -394,14 +444,22 @@ pub unsafe extern "C" fn qobuz_backend_get_playlist(
     offset: u32,
     limit: u32,
 ) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
 
     spawn(inner, async move {
-        let result = client.lock().await.get_playlist(playlist_id, offset, limit).await;
+        let result = client
+            .lock()
+            .await
+            .get_playlist(playlist_id, offset, limit)
+            .await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_PLAYLIST_OK,  serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (
+                EV_PLAYLIST_OK,
+                serde_json::to_string(&r).unwrap_or_default(),
+            ),
             Err(e) => (EV_PLAYLIST_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
@@ -414,12 +472,16 @@ pub unsafe extern "C" fn qobuz_backend_get_playlist(
 pub unsafe extern "C" fn qobuz_backend_get_fav_tracks(ptr: *mut Backend, offset: u32, limit: u32) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         let result = client.lock().await.get_fav_tracks(offset, limit).await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_FAV_TRACKS_OK, serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (
-            Err(e) => (EV_GENERIC_ERR,   err_json(&e.to_string())),
+                EV_FAV_TRACKS_OK,
+                serde_json::to_string(&r).unwrap_or_default(),
+            ),
+            Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
     });
@@ -429,12 +491,16 @@ pub unsafe extern "C" fn qobuz_backend_get_fav_tracks(ptr: *mut Backend, offset:
 pub unsafe extern "C" fn qobuz_backend_get_fav_albums(ptr: *mut Backend, offset: u32, limit: u32) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         let result = client.lock().await.get_fav_albums(offset, limit).await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_FAV_ALBUMS_OK, serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (
-            Err(e) => (EV_GENERIC_ERR,   err_json(&e.to_string())),
+                EV_FAV_ALBUMS_OK,
+                serde_json::to_string(&r).unwrap_or_default(),
+            ),
+            Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
     });
@@ -444,29 +510,46 @@ pub unsafe extern "C" fn qobuz_backend_get_fav_albums(ptr: *mut Backend, offset:
 pub unsafe extern "C" fn qobuz_backend_get_fav_artists(ptr: *mut Backend, offset: u32, limit: u32) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         let result = client.lock().await.get_fav_artists(offset, limit).await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_FAV_ARTISTS_OK, serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (
-            Err(e) => (EV_GENERIC_ERR,    err_json(&e.to_string())),
+                EV_FAV_ARTISTS_OK,
+                serde_json::to_string(&r).unwrap_or_default(),
+            ),
+            Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
     });
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn qobuz_backend_get_user_playlists(ptr: *mut Backend, offset: u32, limit: u32) {
+pub unsafe extern "C" fn qobuz_backend_get_user_playlists(
+    ptr: *mut Backend,
+    offset: u32,
+    limit: u32,
+) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         let result = client.lock().await.get_user_playlists(offset, limit).await;
         let (ev, json) = match result {
             Ok(r) => {
-                let items = r.playlists.as_ref().and_then(|p| p.items.as_ref()).cloned().unwrap_or_default();
+                let items = r
+                    .playlists
+                    .as_ref()
+                    .and_then(|p| p.items.as_ref())
+                    .cloned()
+                    .unwrap_or_default();
                 let total = r.playlists.as_ref().and_then(|p| p.total).unwrap_or(0);
-                (EV_PLAYLISTS_OK, serde_json::json!({"items": items, "total": total}).to_string())
+                (
+                    EV_PLAYLISTS_OK,
+                    serde_json::json!({"items": items, "total": total}).to_string(),
+                )
             }
             Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
         };
@@ -482,9 +565,10 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
     track_id: i64,
     format_id: i32,
 ) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     let format = Format::from_id(format_id);
     let cmd_tx = inner.player.cmd_tx.clone();
     let status = inner.player.status.clone();
@@ -492,10 +576,13 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
     let rg_enabled = inner.replaygain_enabled.clone();
 
     spawn(inner, async move {
-        // 1. Check prefetch cache first for zero-gap start
         let cached = {
             let mut lock = prefetch.lock().await;
-            if lock.as_ref().map(|p| p.track_id == track_id).unwrap_or(false) {
+            if lock
+                .as_ref()
+                .map(|p| p.track_id == track_id)
+                .unwrap_or(false)
+            {
                 lock.take()
             } else {
                 None
@@ -504,58 +591,71 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
 
         // Extract prefetch_data to embed directly into TrackInfo
         let (track, url, n_segments, encryption_key, prefetch_data) = if let Some(pf) = cached {
-            (pf.track, pf.url, pf.n_segments, pf.encryption_key, pf.prefetch_data)
+            (
+                pf.track,
+                pf.url,
+                pf.n_segments,
+                pf.encryption_key,
+                pf.prefetch_data,
+            )
         } else {
-            // Fetch track metadata
             let track = match client.lock().await.get_track(track_id).await {
                 Ok(t) => t,
-                Err(e) => { call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string())); return; }
+                Err(e) => {
+                    call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string()));
+                    return;
+                }
             };
-            // Fetch stream URL
             let url_dto = match client.lock().await.get_track_url(track_id, format).await {
                 Ok(u) => u,
-                Err(e) => { call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string())); return; }
+                Err(e) => {
+                    call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string()));
+                    return;
+                }
             };
             let encryption_key = url_dto.key.clone();
-            // Prefer segmented url_template (reliable CDN path), fall back to plain url
+
-            eprintln!("[lib] url_dto: url={:?}, url_template={:?}, n_segments={:?}, mime={:?}, key_present={}",
+            let (url, n_segments) =
-                url_dto.url.as_deref().map(|u| &u[..u.len().min(60)]),
+                if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
-                url_dto.url_template.as_deref().map(|u| &u[..u.len().min(60)]),
+                    (tmpl, n)
-                url_dto.n_segments,
+                } else if let Some(u) = url_dto.url {
-                url_dto.mime_type,
+                    (u, 0u32)
-                encryption_key.is_some());
+                } else {
-            let (url, n_segments) = if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
+                    call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json("no stream URL"));
-                (tmpl, n)
+                    return;
-            } else if let Some(u) = url_dto.url {
+                };
-                (u, 0u32)
-            } else {
-                call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json("no stream URL"));
-                return;
-            };
-            eprintln!("[lib] resolved: n_segments={n_segments}, url_prefix={}", &url[..url.len().min(80)]);
             (track, url, n_segments, encryption_key, None)
         };
 
-        // 2. Notify track change
         if let Ok(j) = serde_json::to_string(&track) {
             call_cb(cb, ud, EV_TRACK_CHANGED, &j);
         }
 
-        // 3. Compute ReplayGain if enabled
         let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
-            track.audio_info.as_ref().and_then(|ai| ai.replaygain_track_gain)
+            track
+                .audio_info
+                .as_ref()
+                .and_then(|ai| ai.replaygain_track_gain)
         } else {
             None
         };
 
-        // 4. Update status + send play command
         *status.current_track.lock().unwrap() = Some(track.clone());
         if let Some(dur) = track.duration {
-            status.duration_secs.store(dur as u64, std::sync::atomic::Ordering::Relaxed);
+            status
+                .duration_secs
+                .store(dur as u64, std::sync::atomic::Ordering::Relaxed);
         }
-        let _ = cmd_tx.send(player::PlayerCommand::Play(player::TrackInfo { track, url, n_segments, encryption_key, replaygain_db, prefetch_data }));
 
-        // 5. State notification
+        let _ = cmd_tx.send(player::PlayerCommand::Play(player::TrackInfo {
+            track,
+            url,
+            n_segments,
+            encryption_key,
+            replaygain_db,
+            prefetch_data,
+        }));
+
         call_cb(cb, ud, EV_STATE_CHANGED, r#"{"state":"playing"}"#);
     });
 }
@@ -564,14 +664,24 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
 pub unsafe extern "C" fn qobuz_backend_pause(ptr: *mut Backend) {
     let inner = &(*ptr).0;
     inner.player.pause();
-    call_cb(inner.cb, inner.ud, EV_STATE_CHANGED, r#"{"state":"paused"}"#);
+    call_cb(
+        inner.cb,
+        inner.ud,
+        EV_STATE_CHANGED,
+        r#"{"state":"paused"}"#,
+    );
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_resume(ptr: *mut Backend) {
     let inner = &(*ptr).0;
     inner.player.resume();
-    call_cb(inner.cb, inner.ud, EV_STATE_CHANGED, r#"{"state":"playing"}"#);
+    call_cb(
+        inner.cb,
+        inner.ud,
+        EV_STATE_CHANGED,
+        r#"{"state":"playing"}"#,
+    );
 }
 
 #[no_mangle]
@@ -610,16 +720,24 @@ pub unsafe extern "C" fn qobuz_backend_get_volume(ptr: *const Backend) -> u8 {
 pub unsafe extern "C" fn qobuz_backend_get_state(ptr: *const Backend) -> c_int {
     match (*ptr).0.player.status.get_state() {
         PlayerState::Playing => 1,
-        PlayerState::Paused  => 2,
+        PlayerState::Paused => 2,
-        _                    => 0,
+        _ => 0,
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_take_track_finished(ptr: *mut Backend) -> c_int {
-    let finished = (*ptr).0.player.status.track_finished
+    let finished = (*ptr)
+        .0
+        .player
+        .status
+        .track_finished
         .swap(false, std::sync::atomic::Ordering::SeqCst);
-    if finished { 1 } else { 0 }
+    if finished {
+        1
+    } else {
+        0
+    }
 }
 
 #[no_mangle]
@@ -648,12 +766,20 @@ pub unsafe extern "C" fn qobuz_backend_take_track_transitioned(ptr: *mut Backend
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_set_replaygain(ptr: *mut Backend, enabled: bool) {
-    (*ptr).0.replaygain_enabled.store(enabled, std::sync::atomic::Ordering::Relaxed);
+    (*ptr)
+        .0
+        .replaygain_enabled
+        .store(enabled, std::sync::atomic::Ordering::Relaxed);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_set_gapless(ptr: *mut Backend, enabled: bool) {
-    (*ptr).0.player.status.gapless.store(enabled, std::sync::atomic::Ordering::Relaxed);
+    (*ptr)
+        .0
+        .player
+        .status
+        .gapless
+        .store(enabled, std::sync::atomic::Ordering::Relaxed);
 }
 
 #[no_mangle]
@@ -678,13 +804,14 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
             Err(_) => return,
         };
         let encryption_key = url_dto.key.clone();
-        let (url, n_segments) = if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
+        let (url, n_segments) =
-            (tmpl, n)
+            if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
-        } else if let Some(u) = url_dto.url {
+                (tmpl, n)
-            (u, 0u32)
+            } else if let Some(u) = url_dto.url {
-        } else {
+                (u, 0u32)
-            return;
+            } else {
-        };
+                return;
+            };
 
         // KICKSTART DOWNLOADING IMMEDIATELY
         let prefetch_data = if n_segments > 0 {
@@ -699,7 +826,10 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
         };
 
         let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
-            track.audio_info.as_ref().and_then(|ai| ai.replaygain_track_gain)
+            track
+                .audio_info
+                .as_ref()
+                .and_then(|ai| ai.replaygain_track_gain)
         } else {
             None
         };
@@ -721,7 +851,8 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
 pub unsafe extern "C" fn qobuz_backend_add_fav_track(ptr: *mut Backend, track_id: i64) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.add_fav_track(track_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -733,7 +864,8 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_track(ptr: *mut Backend, track_id
 pub unsafe extern "C" fn qobuz_backend_remove_fav_track(ptr: *mut Backend, track_id: i64) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.remove_fav_track(track_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -743,10 +875,11 @@ pub unsafe extern "C" fn qobuz_backend_remove_fav_track(ptr: *mut Backend, track
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_add_fav_album(ptr: *mut Backend, album_id: *const c_char) {
-    let inner    = &(*ptr).0;
+    let inner = &(*ptr).0;
     let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.add_fav_album(&album_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -755,11 +888,15 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_album(ptr: *mut Backend, album_id
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn qobuz_backend_remove_fav_album(ptr: *mut Backend, album_id: *const c_char) {
+pub unsafe extern "C" fn qobuz_backend_remove_fav_album(
-    let inner    = &(*ptr).0;
+    ptr: *mut Backend,
+    album_id: *const c_char,
+) {
+    let inner = &(*ptr).0;
     let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.remove_fav_album(&album_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -771,7 +908,8 @@ pub unsafe extern "C" fn qobuz_backend_remove_fav_album(ptr: *mut Backend, album
 pub unsafe extern "C" fn qobuz_backend_add_fav_artist(ptr: *mut Backend, artist_id: i64) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.add_fav_artist(artist_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -783,7 +921,8 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_artist(ptr: *mut Backend, artist_
 pub unsafe extern "C" fn qobuz_backend_remove_fav_artist(ptr: *mut Backend, artist_id: i64) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         if let Err(e) = client.lock().await.remove_fav_artist(artist_id).await {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -799,11 +938,12 @@ pub const EV_USER_OK: c_int = 23;
 pub unsafe extern "C" fn qobuz_backend_get_user(ptr: *mut Backend) {
     let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         let result = client.lock().await.get_user().await;
         let (ev, json) = match result {
-            Ok(r)  => (EV_USER_OK, serde_json::to_string(&r).unwrap_or_default()),
+            Ok(r) => (EV_USER_OK, serde_json::to_string(&r).unwrap_or_default()),
             Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
         };
         call_cb(cb, ud, ev, &json);
@@ -819,12 +959,18 @@ pub const EV_PLAYLIST_TRACK_ADDED: c_int = 22;
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_create_playlist(ptr: *mut Backend, name: *const c_char) {
     let inner = &(*ptr).0;
-    let name  = CStr::from_ptr(name).to_string_lossy().into_owned();
+    let name = CStr::from_ptr(name).to_string_lossy().into_owned();
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         match client.lock().await.create_playlist(&name).await {
-            Ok(p)  => call_cb(cb, ud, EV_PLAYLIST_CREATED, &serde_json::to_string(&p).unwrap_or_default()),
+            Ok(p) => call_cb(
+                cb,
+                ud,
+                EV_PLAYLIST_CREATED,
+                &serde_json::to_string(&p).unwrap_or_default(),
+            ),
             Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
         }
     });
@@ -832,13 +978,18 @@ pub unsafe extern "C" fn qobuz_backend_create_playlist(ptr: *mut Backend, name:
 
 #[no_mangle]
 pub unsafe extern "C" fn qobuz_backend_delete_playlist(ptr: *mut Backend, playlist_id: i64) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
         match client.lock().await.delete_playlist(playlist_id).await {
-            Ok(()) => call_cb(cb, ud, EV_PLAYLIST_DELETED,
+            Ok(()) => call_cb(
-                &serde_json::json!({"playlist_id": playlist_id}).to_string()),
+                cb,
+                ud,
+                EV_PLAYLIST_DELETED,
+                &serde_json::json!({"playlist_id": playlist_id}).to_string(),
+            ),
             Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
         }
     });
@@ -850,13 +1001,23 @@ pub unsafe extern "C" fn qobuz_backend_add_track_to_playlist(
     playlist_id: i64,
     track_id: i64,
 ) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
-        match client.lock().await.add_track_to_playlist(playlist_id, track_id).await {
+        match client
-            Ok(()) => call_cb(cb, ud, EV_PLAYLIST_TRACK_ADDED,
+            .lock()
-                &serde_json::json!({"playlist_id": playlist_id}).to_string()),
+            .await
+            .add_track_to_playlist(playlist_id, track_id)
+            .await
+        {
+            Ok(()) => call_cb(
+                cb,
+                ud,
+                EV_PLAYLIST_TRACK_ADDED,
+                &serde_json::json!({"playlist_id": playlist_id}).to_string(),
+            ),
             Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
         }
     });
@@ -868,11 +1029,17 @@ pub unsafe extern "C" fn qobuz_backend_delete_track_from_playlist(
     playlist_id: i64,
     playlist_track_id: i64,
 ) {
-    let inner  = &(*ptr).0;
+    let inner = &(*ptr).0;
     let client = inner.client.clone();
-    let cb = inner.cb; let ud = inner.ud;
+    let cb = inner.cb;
+    let ud = inner.ud;
     spawn(inner, async move {
-        if let Err(e) = client.lock().await.delete_track_from_playlist(playlist_id, playlist_track_id).await {
+        if let Err(e) = client
+            .lock()
+            .await
+            .delete_track_from_playlist(playlist_id, playlist_track_id)
+            .await
+        {
             call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
         }
     });

rust/src/player/mod.rs

@@ -141,7 +141,7 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
                 match rx.recv_timeout(Duration::from_millis(100)) {
                     Ok(PlayerCommand::Play(info)) => break info,
                     Ok(PlayerCommand::QueueNext(info)) => {
-                        // If completely idle and get QueueNext, treat as Play
+                        // If we are completely idle and get QueueNext, treat as Play
                         break info;
                     }
                     Ok(PlayerCommand::Stop) => {
@@ -155,7 +155,7 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
                     Ok(PlayerCommand::SetVolume(v)) => {
                         status.volume.store(v, Ordering::Relaxed);
                     }
-                    Ok(_) => {}
+                    Ok(_) => {} // Ignore Pause/Resume when idle
                     Err(RecvTimeoutError::Timeout) => {}
                     Err(RecvTimeoutError::Disconnected) => break 'outer,
                 }
@@ -176,9 +176,11 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
         status.position_secs.store(0, Ordering::Relaxed);
         paused.store(false, Ordering::SeqCst);
 
+        // TrackInfo now directly passes the prefetch_data (if it exists) to the decoder
         match decoder::play_track_inline(info, &status, &paused, &mut audio_output, &rx) {
             Ok(Some(NextAction::Play(next_track))) => {
                 pending_action = Some(NextAction::Play(next_track));
+                // Interrupted by a manual play, no need to tell C++ to advance the queue
             }
             Ok(Some(NextAction::Transition(next_track))) => {
                 pending_action = Some(NextAction::Play(next_track));

rust/src/player/output.rs

@@ -3,7 +3,7 @@ use cpal::{
     traits::{DeviceTrait, HostTrait, StreamTrait},
     StreamConfig,
 };
-use rb::{RbConsumer, RbProducer, SpscRb, RB};
+use rb::{RbConsumer, RbInspector, RbProducer, SpscRb, RB};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -13,6 +13,7 @@ use symphonia::core::audio::AudioBufferRef;
 const RING_BUFFER_SIZE: usize = 32 * 1024;
 
 pub struct AudioOutput {
+    _ring: SpscRb<f32>,
     ring_buf_producer: rb::Producer<f32>,
     _stream: cpal::Stream,
     pub sample_rate: u32,
@@ -50,6 +51,7 @@ impl AudioOutput {
         stream.play()?;
 
         Ok(Self {
+            _ring: ring,
             ring_buf_producer: producer,
             _stream: stream,
             sample_rate,
@@ -87,4 +89,13 @@ impl AudioOutput {
         }
         Ok(())
     }
+
+    pub fn flush(&self) {
+        // Wait until the ring buffer is fully emptied by cpal
+        while !self._ring.is_empty() {
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        // Give the physical DAC an extra 100ms to output the last samples
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
 }

src/CMakeLists.txt

@@ -26,6 +26,8 @@ target_sources(qobuz-qt PRIVATE
     view/artistlistview.hpp
     view/artistview.hpp
     view/artistview.cpp
+    view/genrebrowser.hpp
+    view/genrebrowser.cpp
     view/sidepanel/view.hpp
     view/sidepanel/view.cpp
 
@@ -56,3 +58,10 @@ target_sources(qobuz-qt PRIVATE
     util/icon.hpp
     util/settings.hpp
 )
+
+if (USE_DBUS)
+    target_sources(qobuz-qt PRIVATE
+        backend/mpris.hpp
+        backend/mpris.cpp
+    )
+endif ()

src/backend/mpris.cpp

@@ -0,0 +1,29 @@
+#include "mpris.hpp"
+
+#include <QDBusConnection>
+#include <QCoreApplication>
+#include <QProcess>
+
+MprisRootAdaptor::MprisRootAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+MprisPlayerAdaptor::MprisPlayerAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+Mpris::Mpris(QObject *parent)
+    : QObject(parent)
+{
+    m_root = new MprisRootAdaptor(this);
+    m_player = new MprisPlayerAdaptor(this);
+
+    QDBusConnection dbus = QDBusConnection::sessionBus();
+    QString serviceName = QString("org.mpris.MediaPlayer2.qobuz_qt.instance%1").arg(QCoreApplication::applicationPid());
+    
+    dbus.registerService(serviceName);
+    dbus.registerObject("/org/mpris/MediaPlayer2", this, 
+                        QDBusConnection::ExportAdaptors);
+}

src/backend/mpris.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QVariantMap>
+#include <QDBusAbstractAdaptor>
+#include <QDBusObjectPath>
+
+class MprisRootAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2")
+    
+    Q_PROPERTY(bool CanQuit READ canQuit)
+    Q_PROPERTY(bool Fullscreen READ fullscreen WRITE setFullscreen)
+    Q_PROPERTY(bool CanSetFullscreen READ canSetFullscreen)
+    Q_PROPERTY(bool CanRaise READ canRaise)
+    Q_PROPERTY(bool HasTrackList READ hasTrackList)
+    Q_PROPERTY(QString Identity READ identity)
+    Q_PROPERTY(QString DesktopEntry READ desktopEntry)
+    Q_PROPERTY(QStringList SupportedUriSchemes READ supportedUriSchemes)
+    Q_PROPERTY(QStringList SupportedMimeTypes READ supportedMimeTypes)
+
+public:
+    explicit MprisRootAdaptor(QObject *parent);
+
+    bool canQuit() const { return true; }
+    bool fullscreen() const { return false; }
+    void setFullscreen(bool) {}
+    bool canSetFullscreen() const { return false; }
+    bool canRaise() const { return true; }
+    bool hasTrackList() const { return false; } 
+    QString identity() const { return "Qobuz"; }
+    QString desktopEntry() const { return "qobuz-qt"; }
+    QStringList supportedUriSchemes() const { return {}; }
+    QStringList supportedMimeTypes() const { return {}; }
+
+public slots:
+    void Quit() { emit quitRequested(); }
+    void Raise() { emit raiseRequested(); }
+
+signals:
+    void quitRequested();
+    void raiseRequested();
+};
+
+class MprisPlayerAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2.Player")
+
+    Q_PROPERTY(QString PlaybackStatus READ playbackStatus NOTIFY playbackStatusChanged)
+    Q_PROPERTY(QString LoopStatus READ loopStatus WRITE setLoopStatus)
+    Q_PROPERTY(double Rate READ rate WRITE setRate)
+    Q_PROPERTY(bool Shuffle READ shuffle WRITE setShuffle)
+    Q_PROPERTY(QVariantMap Metadata READ metadata NOTIFY metadataChanged)
+    Q_PROPERTY(double Volume READ volume WRITE setVolume NOTIFY volumeChanged)
+    Q_PROPERTY(qlonglong Position READ position)
+    Q_PROPERTY(double MinimumRate READ minimumRate)
+    Q_PROPERTY(double MaximumRate READ maximumRate)
+    Q_PROPERTY(bool CanGoNext READ canGoNext)
+    Q_PROPERTY(bool CanGoPrevious READ canGoPrevious)
+    Q_PROPERTY(bool CanPlay READ canPlay)
+    Q_PROPERTY(bool CanPause READ canPause)
+    Q_PROPERTY(bool CanSeek READ canSeek)
+    Q_PROPERTY(bool CanControl READ canControl)
+
+public:
+    explicit MprisPlayerAdaptor(QObject *parent);
+
+    QString playbackStatus() const { return m_playbackStatus; }
+    void setPlaybackStatus(const QString &s) {
+        if (m_playbackStatus != s) {
+            m_playbackStatus = s;
+            emit playbackStatusChanged();
+        }
+    }
+
+    QString loopStatus() const { return "None"; }
+    void setLoopStatus(const QString &) {}
+
+    double rate() const { return 1.0; }
+    void setRate(double) {}
+
+    bool shuffle() const { return false; }
+    void setShuffle(bool) {}
+
+    QVariantMap metadata() const { return m_metadata; }
+    void setMetadata(const QVariantMap &m) { 
+        m_metadata = m; 
+        emit metadataChanged(); 
+    }
+
+    double volume() const { return m_volume; }
+    void setVolume(double v) { 
+        emit volumeChangeRequested(v); 
+    }
+    void updateVolume(double v) {
+        if (m_volume != v) {
+            m_volume = v;
+            emit volumeChanged();
+        }
+    }
+
+    qlonglong position() const { return m_positionMicro; }
+    void updatePosition(qlonglong posSecs) { m_positionMicro = posSecs * 1000000LL; }
+
+    double minimumRate() const { return 1.0; }
+    double maximumRate() const { return 1.0; }
+
+    bool canGoNext() const { return true; }
+    bool canGoPrevious() const { return true; }
+    bool canPlay() const { return true; }
+    bool canPause() const { return true; }
+    bool canSeek() const { return true; }
+    bool canControl() const { return true; }
+
+public slots:
+    void Next() { emit nextRequested(); }
+    void Previous() { emit previousRequested(); }
+    void Pause() { emit pauseRequested(); }
+    void PlayPause() { emit playPauseRequested(); }
+    void Stop() { emit stopRequested(); }
+    void Play() { emit playRequested(); }
+    void Seek(qlonglong offset) { emit seekRequested(offset); }
+    void SetPosition(const QDBusObjectPath &trackId, qlonglong position) { Q_UNUSED(trackId); emit seekToRequested(position); }
+    void OpenUri(const QString &uri) { Q_UNUSED(uri); }
+
+signals:
+    void playbackStatusChanged();
+    void metadataChanged();
+    void volumeChanged();
+
+    // Commands to MainWindow
+    void playRequested();
+    void pauseRequested();
+    void playPauseRequested();
+    void stopRequested();
+    void nextRequested();
+    void previousRequested();
+    void seekRequested(qlonglong offsetMicroseconds);
+    void seekToRequested(qlonglong positionMicroseconds);
+    void volumeChangeRequested(double volume);
+
+private:
+    QString m_playbackStatus = "Stopped";
+    QVariantMap m_metadata;
+    double m_volume = 1.0;
+    qlonglong m_positionMicro = 0;
+};
+
+class Mpris : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Mpris(QObject *parent = nullptr);
+
+    MprisRootAdaptor *root() const { return m_root; }
+    MprisPlayerAdaptor *player() const { return m_player; }
+
+private:
+    MprisRootAdaptor *m_root;
+    MprisPlayerAdaptor *m_player;
+};

src/backend/qobuzbackend.cpp

@@ -51,11 +51,6 @@ void QobuzBackend::search(const QString &query, quint32 offset, quint32 limit)
     qobuz_backend_search(m_backend, query.toUtf8().constData(), offset, limit);
 }
 
-void QobuzBackend::mostPopularSearch(const QString &query, quint32 limit)
-{
-    qobuz_backend_most_popular_search(m_backend, query.toUtf8().constData(), limit);
-}
-
 void QobuzBackend::getAlbum(const QString &albumId)
 {
     qobuz_backend_get_album(m_backend, albumId.toUtf8().constData());
@@ -84,6 +79,16 @@ void QobuzBackend::getPlaylist(qint64 playlistId, quint32 offset, quint32 limit)
     qobuz_backend_get_playlist(m_backend, playlistId, offset, limit);
 }
 
+void QobuzBackend::getGenres()
+{
+    qobuz_backend_get_genres(m_backend);
+}
+
+void QobuzBackend::getFeaturedAlbums(qint64 genreId, const QString &kind, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_featured_albums(m_backend, genreId, kind.toUtf8().constData(), limit, offset);
+}
+
 // ---- favorites ----
 
 void QobuzBackend::getFavTracks(quint32 offset, quint32 limit)
@@ -222,7 +227,7 @@ void QobuzBackend::onPositionTick()
 
     if (qobuz_backend_take_track_finished(m_backend))
         emit trackFinished();
-
+        
     if (qobuz_backend_take_track_transitioned(m_backend))
         emit trackTransitioned();
 }
@@ -246,9 +251,6 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
     case EV_SEARCH_OK:
         emit searchResult(obj);
         break;
-    case 26: // EV_MOST_POPULAR_OK
-        emit mostPopularResult(obj);
-        break;
     case EV_SEARCH_ERR:
         emit error(obj["error"].toString());
         break;
@@ -272,6 +274,12 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
     case 25: // EV_DEEP_SHUFFLE_OK
         emit deepShuffleTracksLoaded(obj["tracks"].toArray());
         break;
+    case 27: // EV_GENRES_OK
+        emit genresLoaded(obj);
+        break;
+    case 28: // EV_FEATURED_ALBUMS_OK
+        emit featuredAlbumsLoaded(obj);
+        break;
     case EV_ARTIST_ERR:
         emit error(obj["error"].toString());
         break;

src/backend/qobuzbackend.hpp

@@ -28,12 +28,13 @@ public:
 
     // --- catalog ---
     void search(const QString &query, quint32 offset = 0, quint32 limit = 20);
-    void mostPopularSearch(const QString &query, quint32 limit = 30);
     void getAlbum(const QString &albumId);
     void getArtist(qint64 artistId);
     void getArtistReleases(qint64 artistId, const QString &releaseType, quint32 limit = 50, quint32 offset = 0);
     void getAlbumsTracks(const QStringList &albumIds);
     void getPlaylist(qint64 playlistId, quint32 offset = 0, quint32 limit = 500);
+    void getGenres();
+    void getFeaturedAlbums(qint64 genreId, const QString &kind, quint32 limit = 50, quint32 offset = 0);
 
     // --- favorites ---
     void getFavTracks(quint32 offset = 0, quint32 limit = 500);
@@ -82,11 +83,12 @@ signals:
 
     // catalog
     void searchResult(const QJsonObject &result);
-    void mostPopularResult(const QJsonObject &result);
     void albumLoaded(const QJsonObject &album);
     void artistLoaded(const QJsonObject &artist);
     void artistReleasesLoaded(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
     void deepShuffleTracksLoaded(const QJsonArray &tracks);
+    void genresLoaded(const QJsonObject &result);
+    void featuredAlbumsLoaded(const QJsonObject &result);
     void playlistLoaded(const QJsonObject &playlist);
     void playlistCreated(const QJsonObject &playlist);
     void playlistDeleted(const QJsonObject &result);
@@ -112,6 +114,11 @@ private slots:
     Q_INVOKABLE void onEvent(int eventType, const QString &json);
     void onPositionTick();
 
+public:
+    void manuallyEmitTrackChanged(const QJsonObject &track) {
+        emit trackChanged(track);
+    }
+
 private:
     QobuzBackendOpaque *m_backend = nullptr;
     QTimer *m_positionTimer = nullptr;

src/list/library.cpp

@@ -20,6 +20,7 @@ enum NodeType {
     NodeFavAlbums,
     NodeFavArtists,
     NodePlaylist,
+    NodeBrowseGenres,
 };
 
 Library::Library(QobuzBackend *backend, QWidget *parent)
@@ -71,6 +72,13 @@ void Library::buildStaticNodes()
     // Playlists
     m_playlistsNode = new QTreeWidgetItem(this, QStringList{tr("Playlists")});
     m_playlistsNode->setExpanded(true);
+
+    // Browse
+    m_browseNode = new QTreeWidgetItem(this, QStringList{tr("Browse")});
+    m_browseNode->setExpanded(true);
+
+    auto *genresItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Genres")});
+    genresItem->setData(0, TypeRole, NodeBrowseGenres);
 }
 
 void Library::refresh()
@@ -167,6 +175,7 @@ void Library::onItemClicked(QTreeWidgetItem *item, int)
     case NodeFavTracks:  emit favTracksRequested();  break;
     case NodeFavAlbums:  emit favAlbumsRequested();  break;
     case NodeFavArtists: emit favArtistsRequested(); break;
+    case NodeBrowseGenres: emit browseGenresRequested(); break;
     case NodePlaylist: {
         const qint64  id   = item->data(0, IdRole).toLongLong();
         const QString name = item->data(0, NameRole).toString();

src/list/library.hpp

@@ -26,6 +26,7 @@ namespace List
         void favTracksRequested();
         void favAlbumsRequested();
         void favArtistsRequested();
+        void browseGenresRequested();
         void playlistRequested(qint64 playlistId, const QString &name);
         /// Emitted after playlists are loaded so others can cache the list.
         void userPlaylistsChanged(const QVector<QPair<qint64, QString>> &playlists);
@@ -43,6 +44,7 @@ namespace List
 
         QTreeWidgetItem *m_myLibNode     = nullptr;
         QTreeWidgetItem *m_playlistsNode = nullptr;
+        QTreeWidgetItem *m_browseNode    = nullptr;
         qint64           m_openPlaylistId = 0;
 
         void buildStaticNodes();

src/mainwindow.cpp

@@ -4,6 +4,10 @@
 #include "util/settings.hpp"
 #include "util/icon.hpp"
 
+#ifdef USE_DBUS
+#include "backend/mpris.hpp"
+#endif
+
 #include <QApplication>
 #include <QMenuBar>
 #include <QMenu>
@@ -61,17 +65,37 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
     statusBar()->showMessage(tr("Ready"));
 
     // ---- Scrobbler ----
-    m_scrobbler = new LastFmScrobbler(this);
+        m_scrobbler = new LastFmScrobbler(this);
-    connect(m_backend, &QobuzBackend::trackChanged,
+        connect(m_backend, &QobuzBackend::trackChanged,
-            m_scrobbler, &LastFmScrobbler::onTrackStarted);
+                m_scrobbler, &LastFmScrobbler::onTrackStarted);
-    connect(m_backend, &QobuzBackend::positionChanged,
+        connect(m_backend, &QobuzBackend::positionChanged,
-            m_scrobbler, &LastFmScrobbler::onPositionChanged);
+                m_scrobbler, &LastFmScrobbler::onPositionChanged);
-    connect(m_backend, &QobuzBackend::trackFinished,
+        connect(m_backend, &QobuzBackend::trackFinished,
-            m_scrobbler, &LastFmScrobbler::onTrackFinished);
+                m_scrobbler, &LastFmScrobbler::onTrackFinished);
 
-    // Scrobble the finished track during a gapless transition
+        // 1. Scrobble the finished track during a gapless transition
-    connect(m_backend, &QobuzBackend::trackTransitioned,
+        connect(m_backend, &QobuzBackend::trackTransitioned,
-            m_scrobbler, &LastFmScrobbler::onTrackFinished);
+                m_scrobbler, &LastFmScrobbler::onTrackFinished);
+
+    // ---- Gapless Signal ----
+        connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos, quint64 dur) {
+            if (!AppSettings::instance().gaplessEnabled() || dur == 0) return;
+
+            // Trigger prefetch if we pass the 50% mark OR are within 60 seconds of the end
+            if ((pos > dur / 2) || (dur > 60 && (dur - pos) <= 60)) {
+                if (!m_nextTrackPrefetched && m_queue->canGoNext()) {
+                    m_nextTrackPrefetched = true; // Lock it so it only fires once
+
+                    const auto upcoming = m_queue->upcomingTracks(1);
+                    if (!upcoming.isEmpty()) {
+                        const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
+                        if (nextId > 0) {
+                            m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+                        }
+                    }
+                }
+            }
+        });
 
     // ---- Backend signals ----
     connect(m_backend, &QobuzBackend::loginSuccess,   this, &MainWindow::onLoginSuccess);
@@ -122,6 +146,52 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
         m_backend->getFavTracks();
         statusBar()->showMessage(tr("Loading favorite tracks…"));
     });
+
+#ifdef USE_DBUS
+    m_mpris = new Mpris(this);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playRequested, m_backend, [this] {
+        if (m_backend->state() == 2) m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::pauseRequested, m_backend, &QobuzBackend::pause);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playPauseRequested, m_backend, [this] {
+        if (m_backend->state() == 1)
+            m_backend->pause();
+        else
+            m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::stopRequested, m_backend, &QobuzBackend::stop);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::nextRequested, this, [this] {
+        if (!m_queue->canGoNext()) return;
+        const qint64 id = static_cast<qint64>(m_queue->advance()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::previousRequested, this, [this] {
+        if (!m_queue->canGoPrev()) return;
+        const qint64 id = static_cast<qint64>(m_queue->stepBack()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekRequested, m_backend, [this](qlonglong offsetMicroseconds) {
+        qint64 newPos = m_backend->position() + (offsetMicroseconds / 1000000LL);
+        if (newPos < 0) newPos = 0;
+        m_backend->seek(newPos);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekToRequested, m_backend, [this](qlonglong positionMicroseconds) {
+        m_backend->seek(positionMicroseconds / 1000000LL);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::volumeChangeRequested, m_backend, [this](double vol) {
+        m_backend->setVolume(vol * 100);
+    });
+
+    connect(m_backend, &QobuzBackend::stateChanged, this, [this](const QString &state) {
+        if (state == "playing") m_mpris->player()->setPlaybackStatus("Playing");
+        else if (state == "paused") m_mpris->player()->setPlaybackStatus("Paused");
+        else m_mpris->player()->setPlaybackStatus("Stopped");
+    });
+    connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos) {
+        m_mpris->player()->updatePosition(pos);
+    });
+#endif
+
     connect(m_library, &List::Library::favAlbumsRequested, this, [this] {
         m_backend->getFavAlbums();
         statusBar()->showMessage(tr("Loading favorite albums…"));
@@ -136,6 +206,10 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
         m_backend->getPlaylist(id);
         statusBar()->showMessage(tr("Loading playlist: %1…").arg(name));
     });
+    connect(m_library, &List::Library::browseGenresRequested, this, [this] {
+        m_content->showGenreBrowser();
+        statusBar()->showMessage(tr("Browse Genres"));
+    });
 
     // ---- Track list → playback / playlist management ----
     connect(m_content->tracksList(), &List::Tracks::playTrackRequested,
@@ -289,6 +363,7 @@ void MainWindow::onLoginError(const QString &error)
 
 void MainWindow::onTrackChanged(const QJsonObject &track)
 {
+    m_nextTrackPrefetched = false;
     // Update playing row highlight in the track list
     const qint64 id = static_cast<qint64>(track["id"].toDouble());
     m_content->tracksList()->setPlayingTrackId(id);
@@ -301,15 +376,25 @@ void MainWindow::onTrackChanged(const QJsonObject &track)
     statusBar()->showMessage(
         artist.isEmpty() ? title : QStringLiteral("▶  %1 — %2").arg(artist, title));
 
-    // Prefetch next track URL when gapless is enabled
+#ifdef USE_DBUS
-    if (AppSettings::instance().gaplessEnabled() && m_queue->canGoNext()) {
+    QVariantMap metadata;
-        const auto upcoming = m_queue->upcomingTracks(1);
+    metadata["mpris:trackid"] = QVariant::fromValue(QDBusObjectPath(QString("/org/qobuz/track/%1").arg(id)));
-        if (!upcoming.isEmpty()) {
+    metadata["mpris:length"] = QVariant::fromValue(qlonglong(track["duration"].toDouble() * 1000000LL));
-            const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
+    metadata["xesam:title"]  = title;
-            if (nextId > 0)
+
-                m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+    QJsonObject album = track["album"].toObject();
-        }
+    metadata["xesam:album"]  = album["title"].toString();
+
+    if (!artist.isEmpty()) {
+        metadata["xesam:artist"] = QStringList{artist};
     }
+
+    if (album.contains("image") && album["image"].toObject().contains("large")) {
+        metadata["mpris:artUrl"] = album["image"].toObject()["large"].toString();
+    }
+
+    m_mpris->player()->setMetadata(metadata);
+#endif
 }
 
 void MainWindow::onFavTracksLoaded(const QJsonObject &result)
@@ -420,4 +505,3 @@ void MainWindow::onUserPlaylistsChanged(const QVector<QPair<qint64, QString>> &p
     m_content->tracksList()->setUserPlaylists(playlists);
     m_sidePanel->searchTab()->setUserPlaylists(playlists);
 }
-

src/mainwindow.hpp

@@ -19,6 +19,8 @@
 #include <QPair>
 #include <QString>
 
+class Mpris;
+
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -62,7 +64,9 @@ private:
     QueuePanel      *m_queuePanel  = nullptr;
     SidePanel::View *m_sidePanel   = nullptr;
     QDockWidget     *m_libraryDock = nullptr;
-    LastFmScrobbler  *m_scrobbler   = nullptr;
+    LastFmScrobbler *m_scrobbler   = nullptr;
+    Mpris           *m_mpris       = nullptr;
+    bool m_nextTrackPrefetched = false;
 
     void setupMenuBar();
     void tryRestoreSession();

src/view/albumlistview.hpp

@@ -80,6 +80,7 @@ public:
             const QString year = date.isEmpty()
                 ? a["dates"].toObject()["original"].toString().left(4)
                 : date.left(4);
+            const qint64 artistId = static_cast<qint64>(a["artist"].toObject()["id"].toDouble());
 
             const int tracks  = a["tracks_count"].toInt();
             const bool hiRes  = a["hires_streamable"].toBool()
@@ -97,6 +98,7 @@ public:
             item->setText(3, year);
             item->setText(4, tracks > 0 ? QString::number(tracks) : QString());
             item->setData(1, Qt::UserRole, id);
+            item->setData(2, Qt::UserRole, artistId);
         }
     }
 

src/view/genrebrowser.cpp

@@ -0,0 +1,122 @@
+#include "genrebrowser.hpp"
+
+#include <QAction>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QMenu>
+#include <QTreeWidgetItem>
+#include <QVBoxLayout>
+
+GenreBrowserView::GenreBrowserView(QobuzBackend *backend, QWidget *parent)
+    : QWidget(parent)
+    , m_backend(backend)
+{
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    auto *topBar = new QWidget(this);
+    auto *topLayout = new QHBoxLayout(topBar);
+    topLayout->setContentsMargins(8, 6, 8, 6);
+
+    topLayout->addWidget(new QLabel(tr("Genre:"), this));
+    m_genreCombo = new QComboBox(this);
+    m_genreCombo->setMinimumWidth(160);
+    topLayout->addWidget(m_genreCombo);
+
+    topLayout->addSpacing(16);
+
+    topLayout->addWidget(new QLabel(tr("Type:"), this));
+    m_typeCombo = new QComboBox(this);
+    m_typeCombo->addItem(tr("New Releases"), QStringLiteral("new-releases"));
+    m_typeCombo->addItem(tr("Best Sellers"), QStringLiteral("best-sellers"));
+    m_typeCombo->addItem(tr("Most Streamed"), QStringLiteral("most-streamed"));
+    m_typeCombo->addItem(tr("Editor Picks"), QStringLiteral("editor-picks"));
+    m_typeCombo->addItem(tr("Press Awards"), QStringLiteral("press-awards"));
+    topLayout->addWidget(m_typeCombo);
+
+    topLayout->addStretch();
+    layout->addWidget(topBar);
+
+    m_albumList = new AlbumListView(this);
+    m_albumList->setContextMenuPolicy(Qt::CustomContextMenu);
+    layout->addWidget(m_albumList, 1);
+
+    connect(m_backend, &QobuzBackend::genresLoaded,
+            this, &GenreBrowserView::onGenresLoaded);
+    connect(m_backend, &QobuzBackend::featuredAlbumsLoaded,
+            this, &GenreBrowserView::onFeaturedAlbumsLoaded);
+    connect(m_genreCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_typeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_albumList, &AlbumListView::albumSelected,
+            this, &GenreBrowserView::albumSelected);
+    connect(m_albumList, &QTreeWidget::customContextMenuRequested,
+            this, &GenreBrowserView::onAlbumContextMenu);
+}
+
+void GenreBrowserView::ensureGenresLoaded()
+{
+    if (!m_genresLoaded)
+        m_backend->getGenres();
+}
+
+void GenreBrowserView::onGenresLoaded(const QJsonObject &result)
+{
+    m_genresLoaded = true;
+    m_genreCombo->blockSignals(true);
+    m_genreCombo->clear();
+
+    const QJsonArray items = result["items"].toArray();
+    for (const auto &value : items) {
+        const QJsonObject genre = value.toObject();
+        m_genreCombo->addItem(
+            genre["name"].toString(),
+            static_cast<qint64>(genre["id"].toDouble()));
+    }
+
+    m_genreCombo->blockSignals(false);
+    onSelectionChanged();
+}
+
+void GenreBrowserView::onFeaturedAlbumsLoaded(const QJsonObject &result)
+{
+    m_albumList->setAlbums(result["items"].toArray());
+}
+
+void GenreBrowserView::onSelectionChanged()
+{
+    if (m_genreCombo->count() == 0)
+        return;
+
+    const qint64 genreId = m_genreCombo->currentData().toLongLong();
+    const QString type = m_typeCombo->currentData().toString();
+    m_backend->getFeaturedAlbums(genreId, type, 50, 0);
+}
+
+void GenreBrowserView::onAlbumContextMenu(const QPoint &pos)
+{
+    QTreeWidgetItem *item = m_albumList->itemAt(pos);
+    if (!item)
+        return;
+
+    const QString albumId = item->data(1, Qt::UserRole).toString();
+    const qint64 artistId = item->data(2, Qt::UserRole).toLongLong();
+
+    QMenu menu(this);
+
+    auto *openAlbum = menu.addAction(tr("Open Album"));
+    connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+        emit albumSelected(albumId);
+    });
+
+    if (artistId > 0) {
+        auto *openArtist = menu.addAction(tr("Open Artist"));
+        connect(openArtist, &QAction::triggered, this, [this, artistId] {
+            emit artistSelected(artistId);
+        });
+    }
+
+    menu.exec(m_albumList->viewport()->mapToGlobal(pos));
+}

src/view/genrebrowser.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "../backend/qobuzbackend.hpp"
+#include "albumlistview.hpp"
+
+#include <QComboBox>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QWidget>
+
+class GenreBrowserView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit GenreBrowserView(QobuzBackend *backend, QWidget *parent = nullptr);
+
+    void ensureGenresLoaded();
+
+signals:
+    void albumSelected(const QString &albumId);
+    void artistSelected(qint64 artistId);
+
+private slots:
+    void onGenresLoaded(const QJsonObject &result);
+    void onFeaturedAlbumsLoaded(const QJsonObject &result);
+    void onSelectionChanged();
+    void onAlbumContextMenu(const QPoint &pos);
+
+private:
+    QobuzBackend *m_backend = nullptr;
+    QComboBox *m_genreCombo = nullptr;
+    QComboBox *m_typeCombo = nullptr;
+    AlbumListView *m_albumList = nullptr;
+    bool m_genresLoaded = false;
+};

src/view/maincontent.cpp

@@ -45,12 +45,14 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     m_albumList  = new AlbumListView(this);
     m_artistList = new ArtistListView(this);
     m_artistView = new ArtistView(backend, queue, this);
+    m_genreBrowser = new GenreBrowserView(backend, this);
 
     m_stack->addWidget(m_welcome);    // 0
     m_stack->addWidget(tracksPage);   // 1
     m_stack->addWidget(m_albumList);  // 2
     m_stack->addWidget(m_artistList); // 3
     m_stack->addWidget(m_artistView); // 4
+    m_stack->addWidget(m_genreBrowser); // 5
 
     m_stack->setCurrentIndex(0);
 
@@ -58,6 +60,8 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     connect(m_artistList, &ArtistListView::artistSelected, this, &MainContent::artistRequested);
     connect(m_artistView, &ArtistView::albumSelected,      this, &MainContent::albumRequested);
     connect(m_artistView, &ArtistView::playTrackRequested, this, &MainContent::playTrackRequested);
+    connect(m_genreBrowser, &GenreBrowserView::albumSelected, this, &MainContent::albumRequested);
+    connect(m_genreBrowser, &GenreBrowserView::artistSelected, this, &MainContent::artistRequested);
 }
 
 void MainContent::showWelcome()       { m_stack->setCurrentIndex(0); }
@@ -122,3 +126,9 @@ void MainContent::onDeepShuffleTracks(const QJsonArray &tracks)
 {
     m_artistView->onDeepShuffleTracks(tracks);
 }
+
+void MainContent::showGenreBrowser()
+{
+    m_genreBrowser->ensureGenresLoaded();
+    m_stack->setCurrentIndex(5);
+}

src/view/maincontent.hpp

@@ -6,6 +6,7 @@
 #include "albumlistview.hpp"
 #include "artistlistview.hpp"
 #include "artistview.hpp"
+#include "genrebrowser.hpp"
 #include "trackcontextheader.hpp"
 
 #include <QWidget>
@@ -34,6 +35,7 @@ public:
     void updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
     void setFavArtistIds(const QSet<qint64> &ids);
     void onDeepShuffleTracks(const QJsonArray &tracks);
+    void showGenreBrowser();
 
     ArtistView *artistView() const { return m_artistView; }
 
@@ -51,4 +53,5 @@ private:
     AlbumListView       *m_albumList  = nullptr;
     ArtistListView      *m_artistList = nullptr;
     ArtistView          *m_artistView = nullptr;
+    GenreBrowserView    *m_genreBrowser = nullptr;
 };

src/view/maintoolbar.cpp

@@ -117,6 +117,7 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
     connect(m_backend, &QobuzBackend::trackChanged,    this, &MainToolBar::onTrackChanged);
     connect(m_backend, &QobuzBackend::positionChanged, this, &MainToolBar::onPositionChanged);
     connect(m_backend, &QobuzBackend::trackFinished,   this, &MainToolBar::onTrackFinished);
+    connect(m_backend, &QobuzBackend::trackTransitioned, this, &MainToolBar::onTrackTransitioned);
 
     // ---- Queue signals ----
     connect(m_queue, &PlayQueue::queueChanged, this, &MainToolBar::onQueueChanged);
@@ -249,6 +250,17 @@ void MainToolBar::onTrackFinished()
     }
 }
 
+void MainToolBar::onTrackTransitioned()
+{
+    if (m_queue->canGoNext()) {
+        const QJsonObject track = m_queue->advance();
+        setCurrentTrack(track);
+        m_backend->manuallyEmitTrackChanged(track);
+    } else {
+        onTrackFinished();
+    }
+}
+
 void MainToolBar::onQueueChanged()
 {
     m_previous->setEnabled(m_queue->canGoPrev());

src/view/maintoolbar.hpp

@@ -44,6 +44,7 @@ private slots:
     void onTrackChanged(const QJsonObject &track);
     void onPositionChanged(quint64 position, quint64 duration);
     void onTrackFinished();
+    void onTrackTransitioned();
     void onQueueChanged();
     void onShuffleToggled(bool checked);
 

src/view/sidepanel/view.cpp

@@ -39,16 +39,6 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     // Result tabs
     m_resultTabs = new QTabWidget(this);
 
-    // Top Results tab (default) — mixed artists/albums/tracks from most-popular endpoint
-    m_popularResults = new QTreeWidget(this);
-    m_popularResults->setHeaderLabels({tr(""), tr("Name"), tr("Detail")});
-    m_popularResults->setRootIsDecorated(false);
-    m_popularResults->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
-    m_popularResults->header()->setSectionResizeMode(1, QHeaderView::Stretch);
-    m_popularResults->header()->setSectionResizeMode(2, QHeaderView::Stretch);
-    m_popularResults->header()->setStretchLastSection(false);
-    m_popularResults->setContextMenuPolicy(Qt::CustomContextMenu);
-
     m_trackResults  = new QTreeWidget(this);
     m_trackResults->setHeaderLabels({tr("Title"), tr("Artist"), tr("Album")});
     m_trackResults->setRootIsDecorated(false);
@@ -67,26 +57,21 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
     m_artistResults->setHeaderLabels({tr("Artist")});
     m_artistResults->setRootIsDecorated(false);
 
-    m_resultTabs->addTab(m_popularResults, tr("Top Results"));
+    m_resultTabs->addTab(m_trackResults,  tr("Tracks"));
-    m_resultTabs->addTab(m_trackResults,   tr("Tracks"));
+    m_resultTabs->addTab(m_albumResults,  tr("Albums"));
-    m_resultTabs->addTab(m_albumResults,   tr("Albums"));
+    m_resultTabs->addTab(m_artistResults, tr("Artists"));
-    m_resultTabs->addTab(m_artistResults,  tr("Artists"));
     layout->addWidget(m_resultTabs);
 
     connect(searchBtn,   &QPushButton::clicked,  this, &SearchTab::onSearchSubmit);
     connect(m_searchBox, &QLineEdit::returnPressed, this, &SearchTab::onSearchSubmit);
 
-    connect(m_backend, &QobuzBackend::searchResult,      this, &SearchTab::onSearchResult);
+    connect(m_backend, &QobuzBackend::searchResult, this, &SearchTab::onSearchResult);
-    connect(m_backend, &QobuzBackend::mostPopularResult, this, &SearchTab::onMostPopularResult);
 
-    connect(m_popularResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
+    connect(m_trackResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
-    connect(m_trackResults,   &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
+    connect(m_albumResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
-    connect(m_albumResults,   &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
+    connect(m_artistResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
-    connect(m_artistResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
 
     // Context menus
-    connect(m_popularResults, &QTreeWidget::customContextMenuRequested,
-            this, &SearchTab::onPopularContextMenu);
     connect(m_trackResults, &QTreeWidget::customContextMenuRequested,
             this, &SearchTab::onTrackContextMenu);
     connect(m_albumResults, &QTreeWidget::customContextMenuRequested,
@@ -101,10 +86,8 @@ void SearchTab::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlist
 void SearchTab::onSearchSubmit()
 {
     const QString q = m_searchBox->text().trimmed();
-    if (q.isEmpty()) return;
+    if (!q.isEmpty())
-    m_backend->mostPopularSearch(q, 30);
+        m_backend->search(q, 0, 20);
-    m_backend->search(q, 0, 20);
-    m_resultTabs->setCurrentIndex(0); // show Top Results tab
 }
 
 void SearchTab::onSearchResult(const QJsonObject &result)
@@ -162,62 +145,6 @@ void SearchTab::onSearchResult(const QJsonObject &result)
     }
 }
 
-void SearchTab::onMostPopularResult(const QJsonObject &result)
-{
-    m_popularResults->clear();
-
-    QFont badgeFont;
-    badgeFont.setBold(true);
-    badgeFont.setPointSizeF(badgeFont.pointSizeF() * 0.8);
-
-    const QJsonArray items = result["most_popular"].toObject()["items"].toArray();
-    for (const auto &v : items) {
-        const QJsonObject entry = v.toObject();
-        const QString type    = entry["type"].toString();
-        const QJsonObject content = entry["content"].toObject();
-
-        QString badge, name, detail;
-        QColor badgeColor;
-
-        if (type == QStringLiteral("artists")) {
-            badge = QStringLiteral("A");
-            badgeColor = QColor(QStringLiteral("#6699CC"));
-            name   = content["name"].toString();
-            detail = tr("%1 albums").arg(static_cast<int>(content["albums_count"].toDouble()));
-        } else if (type == QStringLiteral("albums")) {
-            const bool hiRes = content["hires_streamable"].toBool();
-            badge      = hiRes ? QStringLiteral("H") : QStringLiteral("A");
-            badgeColor = hiRes ? QColor(QStringLiteral("#FFB232")) : QColor(QStringLiteral("#AAAAAA"));
-            name   = content["title"].toString();
-            detail = content["artist"].toObject()["name"].toString();
-        } else if (type == QStringLiteral("tracks")) {
-            badge = QStringLiteral("T");
-            badgeColor = QColor(QStringLiteral("#66BB66"));
-            name   = content["title"].toString();
-            detail = content["performer"].toObject()["name"].toString();
-        } else {
-            continue;
-        }
-
-        auto *item = new QTreeWidgetItem(m_popularResults, QStringList{badge, name, detail});
-        item->setForeground(0, badgeColor);
-        item->setFont(0, badgeFont);
-        item->setTextAlignment(0, Qt::AlignCenter);
-        item->setData(0, TypeRole, type == QStringLiteral("artists") ? QStringLiteral("artist")
-                                 : type == QStringLiteral("albums")  ? QStringLiteral("album")
-                                                                      : QStringLiteral("track"));
-        item->setData(0, JsonRole, content);
-
-        if (type == QStringLiteral("artists")) {
-            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
-        } else if (type == QStringLiteral("albums")) {
-            item->setData(1, IdRole, content["id"].toString());
-        } else {
-            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
-        }
-    }
-}
-
 void SearchTab::onItemDoubleClicked(QTreeWidgetItem *item, int)
 {
     if (!item) return;
@@ -226,10 +153,7 @@ void SearchTab::onItemDoubleClicked(QTreeWidgetItem *item, int)
     if (type == QStringLiteral("track")) {
         emit trackPlayRequested(item->data(0, IdRole).toLongLong());
     } else if (type == QStringLiteral("album")) {
-        // Album ID may be in col 0 or col 1 depending on which tree it came from
+        emit albumSelected(item->data(1, IdRole).toString());
-        QString albumId = item->data(1, IdRole).toString();
-        if (albumId.isEmpty()) albumId = item->data(0, IdRole).toString();
-        emit albumSelected(albumId);
     } else if (type == QStringLiteral("artist")) {
         emit artistSelected(item->data(0, IdRole).toLongLong());
     }
@@ -344,90 +268,6 @@ void SearchTab::onAlbumContextMenu(const QPoint &pos)
     menu.exec(m_albumResults->viewport()->mapToGlobal(pos));
 }
 
-void SearchTab::onPopularContextMenu(const QPoint &pos)
-{
-    auto *item = m_popularResults->itemAt(pos);
-    if (!item) return;
-
-    const QString type = item->data(0, TypeRole).toString();
-    const QJsonObject json = item->data(0, JsonRole).toJsonObject();
-    QMenu menu(this);
-
-    if (type == QStringLiteral("track")) {
-        const qint64 trackId = item->data(0, IdRole).toLongLong();
-        if (trackId <= 0) return;
-
-        auto *playNow  = menu.addAction(tr("Play now"));
-        auto *playNext = menu.addAction(tr("Play next"));
-        auto *addQueue = menu.addAction(tr("Add to queue"));
-        menu.addSeparator();
-        auto *addFav = menu.addAction(tr("Add to favorites"));
-
-        const QString albumId   = json["album"].toObject()["id"].toString();
-        const qint64  artistId  = static_cast<qint64>(json["performer"].toObject()["id"].toDouble());
-        const QString albumTitle  = json["album"].toObject()["title"].toString();
-        const QString artistName  = json["performer"].toObject()["name"].toString();
-
-        menu.addSeparator();
-        if (!albumId.isEmpty()) {
-            auto *openAlbum = menu.addAction(tr("Go to album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
-            connect(openAlbum, &QAction::triggered, this, [this, albumId] { emit albumSelected(albumId); });
-        }
-        if (artistId > 0) {
-            auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
-            connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
-        }
-
-        if (!m_userPlaylists.isEmpty()) {
-            menu.addSeparator();
-            auto *plMenu = menu.addMenu(tr("Add to playlist"));
-            for (const auto &pl : m_userPlaylists) {
-                auto *act = plMenu->addAction(pl.second);
-                connect(act, &QAction::triggered, this, [this, trackId, plId = pl.first] {
-                    emit addToPlaylistRequested(trackId, plId);
-                });
-            }
-        }
-
-        menu.addSeparator();
-        auto *info = menu.addAction(tr("Track info..."));
-
-        connect(playNow,  &QAction::triggered, this, [this, trackId] { emit trackPlayRequested(trackId); });
-        connect(playNext, &QAction::triggered, this, [this, json]    { m_queue->playNext(json); });
-        connect(addQueue, &QAction::triggered, this, [this, json]    { m_queue->addToQueue(json); });
-        connect(addFav,   &QAction::triggered, this, [this, trackId] { m_backend->addFavTrack(trackId); });
-        connect(info,     &QAction::triggered, this, [this, json]    { showTrackInfo(json); });
-
-    } else if (type == QStringLiteral("album")) {
-        const QString albumId = item->data(1, IdRole).toString();
-        if (albumId.isEmpty()) return;
-
-        auto *openAlbum = menu.addAction(tr("Open album"));
-        auto *addFav    = menu.addAction(tr("Add to favorites"));
-
-        const qint64 artistId   = static_cast<qint64>(json["artist"].toObject()["id"].toDouble());
-        const QString artistName = json["artist"].toObject()["name"].toString();
-        if (artistId > 0) {
-            menu.addSeparator();
-            auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
-            connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
-        }
-
-        connect(openAlbum, &QAction::triggered, this, [this, albumId] { emit albumSelected(albumId); });
-        connect(addFav,    &QAction::triggered, this, [this, albumId] { m_backend->addFavAlbum(albumId); });
-
-    } else if (type == QStringLiteral("artist")) {
-        const qint64 artistId = item->data(0, IdRole).toLongLong();
-        if (artistId <= 0) return;
-
-        auto *openArtist = menu.addAction(tr("Go to artist"));
-        connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
-    }
-
-    if (!menu.isEmpty())
-        menu.exec(m_popularResults->viewport()->mapToGlobal(pos));
-}
-
 void SearchTab::showTrackInfo(const QJsonObject &track)
 {
     TrackInfoDialog::show(track, this);

src/view/sidepanel/view.hpp

@@ -30,7 +30,6 @@ namespace SidePanel
 
     private slots:
         void onSearchResult(const QJsonObject &result);
-        void onMostPopularResult(const QJsonObject &result);
         void onSearchSubmit();
         void onItemDoubleClicked(QTreeWidgetItem *item, int column);
 
@@ -39,7 +38,6 @@ namespace SidePanel
         PlayQueue    *m_queue      = nullptr;
         QLineEdit    *m_searchBox  = nullptr;
         QTabWidget   *m_resultTabs = nullptr;
-        QTreeWidget  *m_popularResults = nullptr;
         QTreeWidget  *m_trackResults  = nullptr;
         QTreeWidget  *m_albumResults  = nullptr;
         QTreeWidget  *m_artistResults = nullptr;
@@ -47,7 +45,6 @@ namespace SidePanel
 
         void onTrackContextMenu(const QPoint &pos);
         void onAlbumContextMenu(const QPoint &pos);
-        void onPopularContextMenu(const QPoint &pos);
         void showTrackInfo(const QJsonObject &track);
     };