Spotify client

peppy.player · September 13, 2019 at 10:17 PM

Hat hier jemand Erfahrung mit der Implementierung von Spotify Client/UI? Ich frage mich nur, welche Bibliothek es besser ist, sie zu benutzen? Soweit ich verstehe, wurde libspotify veraltet. Es gibt auch spotifyd und Web API. Ich versuche, zwischen diesen beiden zu wählen.

-----------------------------------------------------------------------------------------------

Has anybody here had experience implementing Spotify client/UI? I'm just wondering which library it's better to use? As far as I understand libspotify was deprecated. There is also spotifyd and Web API. Trying to choose between these two.

Bot · Vor 5 Minuten

Spotify client? Schau mal ob du hier fündig wirst!

Linus · September 14, 2019 at 11:44 AM

Hi peppy.player,

Quote from peppy.player

Hat hier jemand Erfahrung mit der Implementierung von Spotify Client/UI?

Ja, ich. libspotify ist in der Tat veraltet (https://developer.spotify.com/technologies/libspotify/ existiert nicht mehr), und auch sonst sieht es, zumindest in der Python-Welt, ziemlich düster aus - das eigentlich sehr gute https://github.com/plamere/spotipy hat seit zwei Jahren kein Update mehr erhalten und es ist nur eine Frage der Zeit, bis diese Bibliothek aufgrund einer API-Änderung nicht mehr funktionieren wird.

Einige, sehr junge Forks gibt es, denen ich aber noch nicht vertraue.

Ich habe mich entschieden, das Web-API zu verwenden, und die API-Requests in Python direkt mit dem requests-Modul zu machen. spotifyd kannte ich noch nicht, sieht aber interessant aus!

Unglücklicherweise gibt es keinen WebSocket-Support im Web-API, man muss daher Polling verwenden, um die aktuellen Wiedergabe-Informationen möglichst nah an Echtzeit anzuzeigen... https://github.com/spotify/web-api/issues/492

Quote from peppy.player

Has anybody here had experience implementing Spotify client/UI?

Yes, I do. libspotify is indeed outdated (https://developer.spotify.com/technologies/libspotify/ doesn't even exist anymore), and it looks pretty gloomy, at least in the Python world - the actually very good https://github.com/plamere/spotipy hasn't received an update in two years and it's just a matter of time until this library won't work anymore due to an API change.

There are some very young forks, but I don't trust them yet.

I decided to use the Web API and do the API requests in Python directly using the requests module. I didn't know about spotifyd, but it looks interesting!

Unfortunately, there is no WebSocket support in the Web API, so you have to use polling to display the current playback information as close to realtime as possible... https://github.com/spotify/web-api/issues/492

peppy.player · September 14, 2019 at 6:13 PM

Vielen Dank Linus für die ausführlichen Informationen. Soweit ich weiß, wurde spotifyd in vielen Projekten als libspotify Ersatz verwendet. Obwohl ich mir nicht sicher bin, wie Sie diesen Prozess von Python aus steuern können. Wahrscheinlich über dbus (?), da ich keinen Python-Wrapper sehe.

Ich denke auch, dass die Web-API ein guter Weg ist. Es sieht so aus, als ob spotipy wirklich ein verlassenes Projekt mit vielen ungelösten Problemen ist. Es gibt noch eine weitere - pyfy https://github.com/omarryhan/pyfy. Aber um sicher zu gehen, ist es wahrscheinlich besser, das mit Python ohne zusätzliche Abhängigkeiten zu implementieren.

Ich hatte das gleiche Problem mit der Zeitverfolgung in der Weboberfläche für den Peppy Player. Ich beschloss, es einfach zu machen und eine eigene Browser-Uhr zu verwenden. Es besteht die Möglichkeit, dass die potenziellen Synchronisationsprobleme auftreten, aber der Unterschied ist so gering, dass er keine kniffligen Lösungen mit Resynchronisation oder unnötigem Traffic im Falle eines Web-Socket verdient. Das Problem mit Web-Socket ist, dass Sie die Verbindung immer offen halten müssen. Bei so vielen Spotify-Abonnenten bezweifle ich, dass sie diesen Weg gehen werden.

----------------------------------------------------------------------------------------------------

Thank you Linus for the detailed info. As far as I know spotifyd was used as a libspotify replacement in many projects. Though I'm not sure how you can control that process from Python. Probably through dbus (?) as I don't see any Python wrapper.

I also think that the Web API is a way to go. It looks like spotipy is really abandoned project with many unresolved issues. There is also another one - pyfy https://github.com/omarryhan/pyfy. But to be safe it's probably better to implement that using just Python without any additional dependencies.

I faced the same time tracking issue in Web UI for Peppy player. I decided to make it simple and use its own browser clock. There is a chance of the potential synchronization issues but the difference is so minimal that it doesn't deserve any tricky solutions with resynching or unnecessary traffic in case of web socket. The issue with web socket is that you need to keep connection always open. With so many Spotify subscribers I doubt they will go this route.

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Linus · September 14, 2019 at 7:10 PM

Quote from peppy.player

But to be safe it's probably better to implement that using just Python without any additional dependencies.

Yep, my implementation is 50 lines of Python using requests. It includes token refreshing and uses two API endpoints, https://api.spotify.com/v1/me and https://api.spotify.com/v1/me/player/currently-playing. Quite simple.

Quote from peppy.player

The issue with web socket is that you need to keep connection always open. With so many Spotify subscribers I doubt they will go this route.

No, that's not the reason - all official Spotify client applications are already using WebSockets. You can see this by visiting https://open.spotify.com (browser player) and looking at the HTTP requests made - multiple WebSocket connections openened.

They even gave WebSocket API access to Discord, and probably Discord is paying good money for it. The WebSockets API for Spotify already exists and is scalable and being used by their millions of users every day - they just won't made it public, which is a shame.

I'm polling with 1Hz (that's a near-real-time experience), someone even made a comment in the GitHub thread linked above saying people polling will use even more resources than a WebSocket connection - which I think is true.

------------------------------------------

Ja, meine Implementierung ist 50 Zeilen Python mit requests. Sie beinhaltet die Aktualisierung des Tokens und verwendet zwei API-Endpunkte, https://api.spotify.com/v1/me und https://api.spotify.com/v1/me/player/currently-playing. Ganz einfach.

Nein, das ist nicht der Grund - alle offiziellen Spotify Client-Anwendungen verwenden bereits WebSockets. Das kann man sehen, indem man https://open.spotify.com (Browser-Player) aufruft und sich die HTTP-Anfragen ansieht - mehrere WebSocket-Verbindungen werden geöffnet.

Spotify hat Discord Zugang zum WebSocket API gegeben, und wahrscheinlich zahlt Discord gutes Geld dafür. Das WebSockets API for Spotify existiert bereits und ist skalierbar und wird täglich von Millionen von Benutzern genutzt - haben es nur nicht veröffentlicht, was eine Schande ist.

Ich führe Abfragen mit 1Hz durch (das ist eine nahezu Echtzeit-Erfahrung), jemand hat sogar einen Kommentar im oben verlinkten GitHub-Thread abgegeben, dass die permanenten abfragen noch mehr Ressourcen verbrauchen würden als eine WebSocket-Verbindung - was ich für wahr halte.

peppy.player · September 14, 2019 at 7:32 PM

Web Socket macht die Kommunikation im Gegensatz zu normalem HTTP stateful. Das benötigt zusätzliche Ressourcen auf der Serverseite, um diesen Zustand aufrechtzuerhalten. Ich denke, das ist einer der Gründe, warum es noch nicht öffentlich zugänglich ist. So gibt Web Socket die Kommunikation in Bezug auf den Traffic frei, benötigt aber mehr Ressourcen/Speicher auf der Serverseite. Wo das Polling den Traffic erhöht, aber keine zusätzlichen Ressourcen auf der Serverseite benötigt. Ich bin mir nicht sicher, welchen Weg sie gehen werden.

--------------------------------------------------------------------------------------

Web Socket makes communication stateful in contrast with regular HTTP. That needs additional resources on the server side to keep that state. I think that's one of the reasons why it's not publicly available yet. So Web Socket frees communication in terms of traffic but needs more resources/memory on server side. Where polling makes traffic heavier but doesn't need additional resources on the server side. I'm not sure which way they will go.

Linus · September 14, 2019 at 7:33 PM

This is the relevant Code:

Python

import base64
from typing import Any, Callable, Dict, Optional

import requests


class SpotifyApi:
    def __init__(
        self,
        client_id: str,
        client_secret: str,
        access_token: str,
        refresh_token: str,
        access_token_changed: Optional[Callable[[str], None]] = None,
    ) -> None:
        self.client_id = client_id
        self.client_secret = client_secret
        self.access_token = access_token
        self.refresh_token = refresh_token
        self.access_token_changed = access_token_changed or (lambda _: None)

    def _refresh_access_token(self) -> None:
        # https://developer.spotify.com/documentation/general/guides/authorization-guide/#4-requesting-a-refreshed-access-token-spotify-returns-a-new-access-token-to-your-app
        b64_token = base64.b64encode(
            f"{self.client_id}:{self.client_secret}".encode()
        ).decode()
        r = requests.post(
            "https://accounts.spotify.com/api/token",
            headers={"Authorization": f"Basic {b64_token}"},
            data={"grant_type": "refresh_token", "refresh_token": self.refresh_token},
        )
        access_token = r.json()["access_token"]
        self.access_token = access_token
        self.access_token_changed(access_token)

    def _api_request(
        self, url: str, http_method: Callable = requests.get, **kwargs
    ) -> Any:
        headers = {"Authorization": f"Bearer {self.access_token}"}
        r = http_method(url, headers=headers, **kwargs)
        if r.status_code != 200:
            if r.status_code == 401:
                self._refresh_access_token()
                return self._api_request(url, http_method, **kwargs)
            else:
                r.raise_for_status()
        else:
            return r.json()

    @property
    def me(self) -> Dict[str, Any]:
        return self._api_request("https://api.spotify.com/v1/me")

    @property
    def currently_playing(self) -> Dict[str, Any]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/currently-playing"
        )

Display More

And proof that it works

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

peppy.player · September 14, 2019 at 7:58 PM

Also gehört der Top-Spieler dir, oder? Benutzen Sie es nur, um eine Wiedergabe zu steuern? Wer spielt eigentlich einen Stream? Können Sie diesen Stream über die Web-API abrufen? Ich danke dir!

--------------------------------------------------------------------------------

So the top player is yours, right? Do you use it just to control a playback? Who is actually playing a stream? Can you get that stream using Web API? Thank you!

peppy.player · September 14, 2019 at 8:14 PM

Ich benutze Spotify nicht selbst. Soweit ich verstehe, gibt es zwei Arten von Konten - kostenlos und primär. Deckt die Web API beide Kontoarten ab?

-----------------------------------------------------------------------------------------

I don't use Spotify myself. As far as I understand there are two types of account - free and primary. Does the Web API cover both account types?

Linus · September 14, 2019 at 9:30 PM

Quote from peppy.player

So the top player is yours, right?

Yes

Quote from peppy.player

Do you use it just to control a playback?

It works in both directions - control playback and display playback controlled from another device/Spotify client.

Quote from peppy.player

Who is actually playing a stream? Can you get that stream using Web API?

The stream is played by any running Spotify client - streaming is not possible with the Web API but using the Web Playback SDK (only in the browser): https://developer.spotify.com/documentation/web-playback-sdk/

I'm not doing that.

Quote from peppy.player

I don't use Spotify myself. As far as I understand there are two types of account - free and primary. Does the Web API cover both account types?

There are free accounts (playing forced ads every now and then) and paid "premium" accounts. You should be able to use the Web API when authenticated with a free account, the Web Playback SDK requires a premium account.

---------------------------------------------------------------------------------

Quote from peppy.player

Also gehört der Top-Spieler dir, oder?

Ja

Quote from peppy.player

Benutzen Sie es nur, um eine Wiedergabe zu steuern?

Es funktioniert in beide Richtungen - Wiedergabe steuern und die durch ein anderes Gerät/Spotify-Client gesteuerte Wiedergabe anzeigen.

Quote from peppy.player

Wer spielt eigentlich einen Stream? Können Sie diesen Stream über die Web-API abrufen?

Der Stream wird von einem beliebigen, laufenden Spotify-Client abgespielt - streaming ist nicht mit dem Web API möglich, aber mit dem Web Playback SDK (nur im Browser): https://developer.spotify.com/documentation/web-playback-sdk/

Ich verwende es nicht.

Quote from peppy.player

Ich benutze Spotify nicht selbst. Soweit ich verstehe, gibt es zwei Arten von Konten - kostenlos und primär. Deckt die Web API beide Kontoarten ab?

Es gibt kostenlose Accounts (die ab und zu erzwungene Werbung abspielen) und kostenpflichtige "Premium" Accounts. Es sollte möglich sein, das Web API mit einem kostenlosen Account zu verwenen, das Web Playback SDK benötigt einen Premium-Account.

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

peppy.player · September 14, 2019 at 9:47 PM

Das ist wahrscheinlich der Grund, warum man spotifyd auf Raspberry Pi verwendet. Da ich die Fähigkeit brauche, ohne Browser zu spielen. Also muss ich nach den Informationen über die Integration mit spotifyd suchen. Ich danke dir!

-----------------------------------------------------------------------------

That's probably the reason to use spotifyd running on Raspberry Pi. As I need ability to play without browser. So I need to search for the info about integration with spotifyd. Thank you!

**hyle** · September 14, 2019 at 9:50 PM Official Post

Linus Bitte antworte auch zweisprachig! Du weißt ja das nicht alle hier englisch verstehen, aber vielleicht gerne der Konversation folgen möchten.

Linus · September 14, 2019 at 10:17 PM

Quote from hyle

Linus Bitte antworte auch zweisprachig! Du weißt ja das nicht alle hier englisch verstehen, aber vielleicht gerne der Konversation folgen möchten.

Völlig richtig. Danke für den Hinweis, predige ich ja selbst andauernd. Da war ich einfach zu faul

Der Vollständigkeit halber noch ein paar Methoden, die ich zu obiger Klasse hinzugefügt habe:

For the sake of completeness a few more methods that I added to the above class:

Python

class SpotifyApi:
    ...
    def previous(self, **kwargs) -> Dict[str, Any]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/previous", requests.post, params=kwargs
        )

    def next(self, **kwargs) -> Optional[Dict[str, Any]]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/next", requests.post, params=kwargs
        )

    def play(self, **kwargs) -> Optional[Dict[str, Any]]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/play", requests.put, params=kwargs
        )

    def pause(self, **kwargs) -> Optional[Dict[str, Any]]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/pause", requests.put, params=kwargs
        )

    def seek(self, **kwargs) -> Optional[Dict[str, Any]]:
        return self._api_request(
            "https://api.spotify.com/v1/me/player/seek", requests.put, params=kwargs
        )

Display More

Dank kwargs lassen sich in der API-Dokumentation beschriebene "Query Parameters" direkt als Parameter an die Funktion übergeben, z.B. für https://developer.spotify.com/documentation/…uery-parameters

Thanks to kwargs, "Query Parameters" described in the API documentation can be passed directly as parameters to the function, e.g. for https://developer.spotify.com/documentation/…uery-parameters

Query Parameter	Value
position_ms	Required. The position in milliseconds to seek to. Must be a positive number. Passing in a position that is greater than the length of the track will cause the player to start playing the next song.
device_id	Optional. The id of the device this command is targeting. If not supplied, the user’s currently active device is the target.

Python

api = SpotifyApi(...)
api.seek(position_ms=123456)

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

peppy.player · September 14, 2019 at 10:29 PM

Ich glaube also, dass device_id eine spotifyd ID sein kann. Gemäß der Beschreibung kann es in einem Netzwerk wie jedes andere Spotify-Gerät betrieben werden:

https://github.com/Spotifyd/spotifyd

-------------------------------------------------------------------------------------------

So I believe device_id can be spotifyd ID. According to the description it can run in a network as any other Spotify device:

https://github.com/Spotifyd/spotifyd

peppy.player · October 11, 2019 at 5:23 PM

Es sieht so aus, als ob 'spotifyd' und die Web-Benutzeroberfläche nur für Premium-Benutzer funktionieren. Die alternative Variante, den Spotify-Player aus Ihrem RPi zu machen, ist die Verwendung des Daemons 'shairport-sync':

https://github.com/mikebrady/shairport-sync

Es kann Streams wiedergeben, die über das AirPlay-Protokoll kommen. Das funktioniert meist von Apple-Geräten/Playern aus und mit einiger zusätzlicher Software könnte es auch von anderen Plattformen aus funktionieren. Ich glaube, dass Sie mit "shaiport-sync" sowohl von Spotify-Konten - Premium als auch Non-Premium - streamen können.

-------------------------------------------------------------------------------

It looks like 'spotifyd' and Web UI work only for premium users. The alternative variant of making Spotify player from your RPi is to use 'shairport-sync' daemon:

https://github.com/mikebrady/shairport-sync

It can play streams coming over AirPlay protocol. That mostly works from Apple devices/players and with some additional software could work from other platforms as well. I believe using 'shaiport-sync' you can stream from both Spotify accounts - premium and non-premium.

plani · October 20, 2019 at 6:49 PM

have anybody a installation description to install Spotify for free on the raspi

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

peppy.player · October 20, 2019 at 7:56 PM

Die einzige Möglichkeit, ein kostenloses Spotify-Konto zu nutzen, von dem ich weiß, ist, den Player/App irgendwo zu installieren (z.B. iPhone) und mit der Shirport-sync-Software nach Raspberry Pi zu streamen:

https://github.com/mikebrady/shairport-sync

Hier sind alle Befehle, um es auf RPi zu installieren:

Code

sudo iwconfig wlan0 power off
sudo apt-get install build-essential git xmltoman autoconf automake libtool libpopt-dev libconfig-dev libasound2-dev avahi-daemon libavahi-client-dev libssl-dev libsoxr-dev libglib2.0-dev
git clone https://github.com/mikebrady/shairport-sync.git
cd shairport-sync
autoreconf -fi
./configure --sysconfdir=/etc --with-alsa --with-soxr --with-avahi --with-ssl=openssl --with-systemd --with-metadata --with-dbus-interface
make
sudo make install

Danach musst du die Konfigurationsdatei /etc/shairport-sync.conf ändern:

Code

name = "Peppy Player"; // name of your client
cover_art_cache_directory="" // to disable image caching

Die letzte Eigenschaft wurde heute nach meiner Anfrage eingeführt. Es ermöglicht, das Zwischenspeichern von Bildern (Album Art) in einem Dateisystem zu vermeiden.

Alle diese Schritte ermöglichen es, RPi als Ihr Audioausgabesystem zu verwenden. Allerdings müssen Sie den Player selbst noch woanders installieren. Es ist eine andere Geschichte für das primäre/nicht kostenlose Konto.

---------------------------------------------------------------------------------------------

The only way to use free Spotify account which I know about is to install the player/app somewhere (e.g. iPhone) and stream to Raspberry Pi using shairport-sync software:

https://github.com/mikebrady/shairport-sync

Here are all commands to install it on RPi:

Code

sudo iwconfig wlan0 power off
sudo apt-get install build-essential git xmltoman autoconf automake libtool libpopt-dev libconfig-dev libasound2-dev avahi-daemon libavahi-client-dev libssl-dev libsoxr-dev libglib2.0-dev
git clone https://github.com/mikebrady/shairport-sync.git
cd shairport-sync
autoreconf -fi
./configure --sysconfdir=/etc --with-alsa --with-soxr --with-avahi --with-ssl=openssl --with-systemd --with-metadata --with-dbus-interface
make
sudo make install

After that you need to change the config file /etc/shairport-sync.conf:

Code

name = "Peppy Player"; // name of your client
cover_art_cache_directory="" // to disable image caching

The last property was introduced today after my request. It allows to avoid caching images (album art) in a file system.

All these steps will allow to use RPi as your audio output system. Though you still need to install the player itself somewhere else. It's a different story for the primary/non-free account.

peppy.player · November 4, 2019 at 3:21 AM

Hier ist das Beispiel für die Verwendung des kostenlosen Spotify-Kontos mit Raspberry Pi. Ich habe gerade die Implementierung dieses Ansatzes für den Peppy Player abgeschlossen. Es wird in der nächsten Version verfügbar sein.

Du musst die Spotify App auf deinem Apple Gerät installieren. In meinem Fall ist es das iPhone. Dann wählen Sie einfach Peppy Player als Ausgabegerät. Der Stream wird über AirPlay an den auf Raspberry Pi laufenden Shirport-sync-Prozess übertragen. Die Wiedergabe (Play/Pause/Next/Previous) und die Lautstärke können entweder vom Apple-Gerät oder vom Peppy-Player aus gesteuert werden.

----------------------------------------------------------------------------------------------

Here is the example of using free Spotify account with Raspberry Pi. I've just finished the implementation of this approach for Peppy player. It will be available in the next release.

You need to install the Spotify app on your Apple device. It's iPhone in my case. Then just select Peppy Player as output device. The stream will be transferred over AirPlay to the shairport-sync process running on Raspberry Pi. The playback (Play/Pause/Next/Previous) and volume can be controlled either from Apple device or from Peppy player.

peppy.player · November 11, 2019 at 9:48 PM

Quote from Deaktiviert

This is the relevant Code:

Python

...
class SpotifyApi:
    def __init__(
        self,
        client_id: str,
        client_secret: str,
        access_token: str,
        refresh_token: str,
        access_token_changed: Optional[Callable[[str], None]] = None,
    )
...

Display More

Soweit ich die Kunden-ID und das Kundengeheimnis verstehe, sind dies die Werte des Entwicklers, die Sie erhalten, wenn Sie hier auf'Kunden-ID erstellen' klicken:

https://developer.spotify.com/dashboard/applications

Bedeutet das, dass ich, wenn ich meine App verbreite, jeden Benutzer bitten muss, die Kunden-ID und das Geheimnis dieses Entwicklers zu erstellen?

Danke

----------------------------------------------------------------------------------

As far as I understand a Client ID and Client Secret here are developer's values which you can get by clicking on 'Create a Client ID' here:

https://developer.spotify.com/dashboard/applications

Does it mean that if I distribute my app I need to ask each user to create that developer's client ID and secret?

Thanks

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Koepisch · November 24, 2019 at 3:46 PM

Hallo Peppy.Player,

wie ich es verstehe, implementierst du nicht die Lösung via spotifyd sondern wirst das iPhone Protokoll verwenden. Ich bin die spotifyd api kurz überpflogen und denke, dass das mit einem spotify premium account gehen sollte. Mir fehlte bis lang auch immer die Möglichkeit über die GUI einen Bluetooth Speaker anzukoppeln und ihn auch wieder zu releasen, um den line out zu verwenden. Ist das inzwischen möglich? Ich plane einen 2. Player, wobei auch spotify premium genutzt werden könnte. Ich weiß aber nicht ob, es technisch über spotify connect möglich ist Playlisten auszuwahlen und abzuspielen.

Gruße

Koepisch

peppy.player · November 24, 2019 at 6:41 PM

Hallo Koepisch,

Ich hoffe, dass ich das neue Peppy-Software-Release in ein paar Wochen veröffentlichen kann. Dazu gehört auch die Unterstützung von AirPlay und Spotify Connect. Dies ermöglicht die Nutzung des kostenlosen Spotify-Kontos mit AirPlay und des Premium-Spotify-Kontos mit Spotify Connect.

Die Unterstützung für AirPlay basiert auf der Shairport-sync Software - https://github.com/mikebrady/shairport-sync. Es wird möglich sein, Player (z.B. iTunes oder Spotify) auf Apple-Geräten (z.B. iPhone, iPad etc.) zu betreiben und sich über das AirPlay-Protokoll mit dem Peppy Player zu verbinden. Du kannst im Bild oben sehen, wie das funktionieren wird. Es sollte auch von jeder anderen Plattform (z.B. Windows) funktionieren, wenn Sie das entsprechende Plugin (z.B. TuneBlade http://www.tuneblade.com/) installieren. Die Wiedergabe (Lautstärke/nächste/vorherige) kann in diesem Fall entweder vom "Master"-Gerät, auf dem Sie starten, oder vom Peppy-Player aus gesteuert werden. Die Wiedergabelisten können nur im Master-Player ausgewählt werden. Dies ist die einzige Möglichkeit, ein kostenloses Spotify-Konto zu nutzen. Ein Premium-Account sollte auch über AirPlay funktionieren.

Das einzige Problem mit dem AirPlay-Ansatz ist, dass Sie entweder ein Apple-Gerät benötigen oder ein Plugin installieren. Um Spotify auf jeder Plattform zu unterstützen, werde ich eine andere Software verwenden - raspotify https://github.com/dtcooper/raspotify. Dieser Ansatz ist dem AirPlay-Ansatz sehr ähnlich, aber anstatt das Apple AirPlay-Protokoll zu verwenden, wird das Protokoll Spotify Connect verwendet. Es funktioniert nur für Spotify Premium-Konten und ermöglicht die Ausgabe von Audio-Stream über Ihren Raspberry Pi. Es ist nicht möglich, die Wiedergabe über die Benutzeroberfläche des Peppy-Players zu steuern. Bei der Verwendung von Raspotify ist es nicht erforderlich, Spotify Benutzername/Passwort auf der Seite des Peppy Players anzugeben.

Der spotifyd ist dem Raspotify sehr ähnlich und bietet einige zusätzliche Funktionen - die Möglichkeit, die Wiedergabe über dbus zu steuern. Leider gibt es einige Probleme mit spotifyd (z.B. https://github.com/Spotifyd/spotifyd/issues/337), also habe ich mich entschieden, stattdessen Raspotify zu verwenden. Wahrscheinlich werde ich in einer der zukünftigen Peppy-Versionen Unterstützung für spotifyd hinzufügen. Dadurch kann die Wiedergabe von Spotify Connect über den Peppy Player gesteuert werden.

Alle beschriebenen Ansätze erlauben es nicht, mit Playlists aus dem Peppy Player zu arbeiten. Um zu unterstützen, dass Peppy Player die Spotify Web API implementieren sollte. Ich beschloss, diese Aufgabe vorerst zu verschieben.

Ich bin mir nicht sicher, welche Art von Problem Sie mit dem Bluetooth-Lautsprecher haben. Du kannst die Frage im Peppy Player Thread posten.

Mit freundlichen Grüßen

-------------------------------------------------------------------------------------------------------

Hi Koepisch,

I hope to make the new Peppy software release in a couple weeks. It will include support for AirPlay and Spotify Connect. That will allow to use free Spotify account using AirPlay and premium Spotify account using Spotify Connect.

The support for AirPlay will be based on the shairport-sync software - https://github.com/mikebrady/shairport-sync. It will be possible to run players (e.g. iTunes or Spotify) on Apple devices (e.g. iPhone, iPad etc) and connect to the Peppy player over AirPlay protocol. You can see in the image above how that will work. It should also work from any other platform (e.g. Windows) if you install the corresponding plugin (e.g. TuneBlade http://www.tuneblade.com/). The playback (volume/next/previous) in this case can be controlled either from 'master' device where you start or from Peppy player. The playlists can be selected only from the 'master' player. This is the only way to use free Spotify account. A premium account should also work over AirPlay.

The only problem with AirPlay approach is that you need either Apple device or install some plugin. To support Spotify on any platform I'll use another software - raspotify https://github.com/dtcooper/raspotify. This approach is very similar to the AirPlay approach but instead of using Apple AirPlay protocol it will use protocol called Spotify Connect. It works only for Spotify premium accounts and allows to output audio stream through your Raspberry Pi. It will not allow to control playback from Peppy player UI. Using raspotify there is no need to provide Spotify username/password on Peppy player side.

The spotifyd is very similar to raspotify and provides some additional functionality - ability to control playback using dbus. Unfortunately there are some issues with spotifyd (e.g. https://github.com/Spotifyd/spotifyd/issues/337) so I decided to use raspotify instead. Probably I'll add support for spotifyd in one of the future Peppy releases. That will allow to control Spotify Connect playback from Peppy player.

All described approaches don't allow to work with playlists from Peppy player. To support that Peppy player should implement Spotify Web API. I decided to postpone this task for now.

I'm not sure what kind of issue do you have with Bluetooth speaker. You can post the question in the Peppy player thread.

Best Regards

Spotify client

Participate now!

Similar Threads

Deezer, etc. vom Pi 3 via minidlna zur Verfügung stellen?

Wie kann ich mithilfe von Python ein im Web angezeigtes Audio Level Meter programmieren?

Users Viewing This Thread