" >&1
exit 1
}
[ -n "$1" ] || usage
echo "Sleeping for $1 seconds"
sleep $1
dest=org.mpris.MediaPlayer2.spotifyd.instance$(pidof spotifyd)
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.ListNames | grep -q "$dest"
if [ "$?" = "0" ]
then
dbus-send --print-reply --dest=$dest /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.Stop
# alternatively just pause:
# dbus-send --print-reply --dest=$dest /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.Pause
else
echo "No active spotifyd playback."
fi
```
================================================
FILE: docs/src/advanced/hooks.md
================================================
# User supplied Scripts
If you want to create custom behaviour around `spotifyd`, one option is to look into the [D-Bus functionality](./dbus.md). But on headless systems or smaller projects, we also offer a hook API. On certain events, a hook can be executed with event details given as environment variables.
To point `spotifyd` to such a script, use the `--onevent /path/to/script` cli arg / `on_song_change_hook = "/path/to/script"` configuration value.
In order to learn about the available events and the available details, you can either create simple scripts which log the given environment variables or look at the output of `spotifyd`, which logs whenever the script is executed.
The following scripts are intended to serve as inspiration for your own scripts. If you have written own scripts which you think might be useful to others, please create a PR adding them here!
## Dunst Notifications (Using Spotify API)
This script will show a dunst notification when you play/change/stop Spotify (and when the music change). It is using spotify APIs to get music details.
### Dependencies
* curl (Request to APIs)
* xargs (Argument passing)
* cut
* jq (https://stedolan.github.io/jq) (for JSON parsing)
### How to use
* Create a file containing the script below:
```bash
user_id=YOUR_USER_ID # generated on https://developer.spotify.com/dashboard/applications
secret_id=YOUR_SECRET_ID
myToken=$(curl -s -X 'POST' -u $user_id:$secret_id -d grant_type=client_credentials https://accounts.spotify.com/api/token | jq '.access_token' | cut -d\" -f2)
RESULT=$?
if [ "$PLAYER_EVENT" = "start" ];
then
if [ $RESULT -eq 0 ]; then
curl -s -X 'GET' https://api.spotify.com/v1/tracks/$TRACK_ID -H 'Accept: application/json' -H 'Content-Type: application/json' -H "Authorization:\"Bearer $myToken\"" | jq '.name, .artists[].name, .album.name, .album.release_date, .track_number, .album.total_tracks' | xargs printf "\"Playing '%s' from '%s' (album: '%s' in %s (%s/%s))\"" | xargs notify-send --urgency=low --expire-time=3000 --icon=/usr/share/icons/gnome/32x32/actions/player_play.png --app-name=spotifyd spotifyd
else
echo "Cannot get token."
fi
elif [ "$PLAYER_EVENT" = "change" ];
then
if [ $RESULT -eq 0 ]; then
curl -s -X 'GET' https://api.spotify.com/v1/tracks/$TRACK_ID -H 'Accept: application/json' -H 'Content-Type: application/json' -H "Authorization:\"Bearer $myToken\"" | jq '.name, .artists[].name, .album.name, .album.release_date, .track_number, .album.total_tracks' | xargs printf "\"Music changed to '%s' from '%s' (album: '%s' in %s (%s/%s))\"" | xargs notify-send --urgency=low --expire-time=3000 --icon=/usr/share/icons/gnome/32x32/actions/player_fwd.png --app-name=spotifyd spotifyd
else
echo "Cannot get token."
fi
elif [ "$PLAYER_EVENT" = "stop" ];
then
if [ $RESULT -eq 0 ]; then
curl -s -X 'GET' https://api.spotify.com/v1/tracks/$TRACK_ID -H 'Accept: application/json' -H 'Content-Type: application/json' -H "Authorization:\"Bearer $myToken\"" | jq '.name, .artists[].name, .album.name, .album.release_date, .track_number, .album.total_tracks' | xargs printf "Stoping music (Last song: '%s' from '%s' (album: '%s' in %s (%s/%s)))\"" | xargs notify-send --urgency=low --expire-time=3000 --icon=/usr/share/icons/gnome/32x32/actions/player_stop.png --app-name=spotifyd spotifyd
else
echo "Cannot get token."
fi
else
echo "Unknown event."
fi
```
* Make this script executable (`chmod +x notification_script.sh`)
* Add the line `onevent = "bash /home/YOU_USER/bin/spotifyNotifications.sh"` to your `spotifyd.conf`
================================================
FILE: docs/src/advanced/launchd.md
================================================
# Running as launchd service
On macOS, the system wide and per-user daemon/agent manager is known as `launchd`. Interfacing with `launchd` is performed through `launchctl`.
In order to use `spotifyd` as a service on macOS one must specify a `.plist` that represents the service, and place it in `/Library/LaunchDaemons`.
Here is a .plist which works with macOS Catalina 10.15.3:
```xml
Label
rustlang.spotifyd
ProgramArguments
/usr/local/bin/spotifyd
--config-path=/users/YourUserName/.config/spotifyd/spotifyd.conf
--no-daemon
UserName
YourUserName
KeepAlive
ThrottleInterval
30
```
Once present in the `/Library/LaunchDaemons` directory, the .plist must be loaded and started with the following commands.
`sudo launchctl load -w /Library/LaunchDaemons/rustlang.spotifyd.plist`
`sudo launchctl start /Library/LaunchDaemons/rustlang.spotifyd.plist`
One may also unload/stop the service in a similar fashion replacing load/start with unload/stop.
Note:
* You should update "YourUserName" with your actual username for macOS (or remove "UserName" to run as root.
* The string, `--no-daemon` is needed as launchd won't receive a PID for the process and will lose its remit over spotifyd. So it's best to include it, there will be no difference in use, nor will you see any log output.
* macOS tries to start the daemon immediately on boot, and spotifyd fails if Wifi isn't connected. So one must have a keep alive (which retries if it fails to launch on boot), that retries after 30 seconds, which is enough for wifi etc to come up.
================================================
FILE: docs/src/advanced/mpris.md
================================================
# MPRIS on headless systems
D-Bus offers two types of communication buses, the system and the session bus. By default and in most setups, MPRIS is expected to run on the session bus (for example, `playerctl` requires that). However, in headless contexts, the session bus is usually not available.
In this case, you basically have two options:
## Option 1: Launch with `dbus-launch`
By creating a wrapper script and using `dbus-launch`, `spotifyd` can be run with its own bus. This could look like the following
`./spotify_wrapper.sh`:
```bash
#!/bin/bash
echo "$DBUS_SESSION_BUS_ADDRESS" > /tmp/spotifyd_bus
echo "To use spotifyd's session bus, run 'export DBUS_SESSION_BUS_ADDRESS=$(cat /tmp/spotifyd_bus)'"
spotifyd --no-daemon --use-mpris
```
Then, execute this script using `dbus-launch ./spotify_wrapper.sh` and follow the instructions in the output.
## Option 2: Using the system bus
Instead of creating a new session bus, we can instead make use of the always existing system bus.
To instruct `spotifyd` to use the system instead of the session bus, set the `--dbus-type system` cli flag / `dbus_type = "system"` config value.
By default, requesting names on the system bus requires special priveleges, which `spotifyd` doesn't have. So, unless being run as root, this will fail. To allow a non-root user to request the `spotifyd` name, we need to create the following file (replacing `your user` by something sensible):
`/usr/share/dbus-1/system.d/spotifyd.conf`:
```xml
```
Make sure to reload the D-Bus configuration with `systemctl reload dbus`.
================================================
FILE: docs/src/advanced/systemd.md
================================================
# Running as systemd service
## As as a user service
A `systemd.service` unit file is provided in the project sources to help run spotifyd as a service on systemd-based systems. The file `contrib/spotifyd.service` should be copied to either:
```bash
/etc/systemd/user/
~/.config/systemd/user/
```
Packagers of systemd-based distributions are encouraged to include the file in the former location. End-user should prefer the latter. It should be noted that some targets are not available when running under the user directory, such as `network-online.target`.
Control of the daemon is handed over to systemd. The following command will start the service whenever the user logs in to the system. Logging out will stop the service.
```bash
systemctl --user enable spotifyd.service --now
```
## As a system wide service
When running spotifyd as a system wide service, it is not possible to access a user's keyring to obtain login credentials. Do not set `use_keyring = true` and do not specify `--use-keyring`, when running as a system wide service. To be able to access login credentials stored in the user's keyring, run spotifyd as a user service, as decribed above.
Additionally, `use_mpris = true` or `--use-mpris` should not be used, since their intended usage is within user sessions (and not system-wide daemons). If you have very specific requirements and still want to control a system-wide `spotifyd` instance, head over to [MPRIS on headless systems](./mpris.md).
A `systemd.service` unit file is provided to help run spotifyd as a service on systemd-based systems. The file `contrib/spotifyd.service` should be copied to:
```bash
/etc/systemd/system/
```
Control of the daemon is handed over to systemd. The following example commands will start the service and keep it running across reboots.
```bash
systemctl daemon-reload
systemctl enable spotifyd.service --now
```
================================================
FILE: docs/src/configuration/README.md
================================================
# Configuration
`Spotifyd` is able to run without configuration at all and will assume default values for most of the fields. However, running without configuration will only allow you to connect to it via Spotify Connect if you're on the same network as the daemon.
All configuration options can be specified directly as command line arguments or alternatively (in particular for permanent changes) be written into a configuration file. Throughout this section, we will always give both possibilities, e.g. `--cli-arg` for the cli variant / `config_value` for the config file variable.
## Config File
`spotifyd` will look for its configuration at `/etc/spotifyd.conf`, `$XDG_CONFIG_PATH/spotifyd/spotifyd.conf` or if that is not set `~/.config/spotifyd/spotifyd.conf`. For other needs, you can point `spotifyd` to it's config file with the command line argument `--config-path `.
You can start with the following documented config as an example and read through the subpages of this section:
```toml
{{#include ../../../contrib/spotifyd.conf}}
```
================================================
FILE: docs/src/configuration/audio.md
================================================
# Audio Configuration
On most setups, audio should be Just Working™. If you have specific needs or something's not working, you might need to touch some of the config values.
## Backend
> `-b/--backend` or `backend` in the config file.
There are different audio backends available to choose from. See `spotifyd --help` to get the available names.
## Device selection
> `--device` or `device` in the config file.
Instead of using the default device, which can sometimes be different to what you'd prefer, you can ask `spotifyd` to use a specific audio device. The interpretation and available values depends on the backend you're using.
- For ALSA, you can use `aplay -L` to get a list of possible devices.
- For PulseAudio, run `pactl list short sinks` to get a list of possible names.
## Bitrate
> `-B/--bitrate` or `bitrate` in the config file.
To reduce bandwidth usage or increase quality, you can play with the bitrate.
## Volume Controller
> `--volume-controller` or `volume_controller` in the config file.
In most cases, leaving this at the default (`softvol`) should be fine.
If you want your `spotifyd` volume to be synchronized with an output device's hardware volume, you can set this to `alsa` or `alsa_linear`. In both cases, you might also want to set the `mixer` device to set which device's volume should be changed.
If you want to prevent the user to be able to adjust the volume, set this instead to `none`.
## Other
For more interesting but less relevant audio options, have a look at `spotifyd --help` or [the example config](./).
================================================
FILE: docs/src/configuration/auth.md
================================================
# Authentication
There are two different ways of authentication supported.
## Discovery on LAN
By default, `spotifyd` advertises itself on the local network as a Spotify Connect device and will thus appear in **official** clients. After selecting it over there, you should be able to hear the sound coming out of your `spotifyd` device.
For this to work, you need to make sure that your firewall isn't blocking the discovery. In particular, `spotifyd` uses two ports:
- `5353 UDP`: MDNS service advertisement
- A zeroconf port which uses TCP. By default, it is randomly chosen, but if you want to, you can configure it with the `--zeroconf-port` cli option / `zeroconf_port` config value.
If you don't want discovery, because you're using one of the methods below, you can disable it via the `--disable-discovery` cli option / `disable_discovery = true` config value.
> __Note:__ By default, the last active session will be remembered and reconnected once the service is restarted.
## Manual Login (via OAuth)
If for some reason, discovery is not a viable option for your use case or you prefer a single-user instance, you can manually log in to your account and `spotifyd` will connect to this account by default.
> __Note:__ Since the login method requires a web browser, trying this on headless systems is not recommended. As a workaround, you can log in on a machine with a working web browser and then copy the credential file onto the headless system. The location of the credential file will be `/oauth/credentials.json`.
Before you begin the login flow, make sure that you won't need to change `cache_path` later on, because that location will be used to store the login data.
Now, you're ready to run `spotifyd authenticate` (for available options, see `spotifyd auth --help`).
This will ask you to browse to a link with your preferred web browser. On the page, you need to log into your Spotify account and confirm the connection.
If the process was successful, you should see the message "Go back to your terminal :)" in your browser window. You can now close the tab and return to the terminal.
Now, when running `spotifyd --no-daemon`, you should see that `spotifyd` automatically connects to your account.
```
Loading config from "..."
[...]
Login via OAuth as user .
[...]
Authenticated as '' !
```
> __Note:__ Even if you logged into `spotifyd` using this method, discovery will still be enabled by default and any incoming connection will interrupt the current session. If you don't want or need this, you can disable it via the `--disable-discovery` cli option / `disable_discovery = true` config value.
================================================
FILE: docs/src/configuration/other.md
================================================
# Other settings
## Appearance
You can customize, how your device is displayed in clients with `--device-name` / `device_name` and `--device-type` / `device_type` options.
## Caching
You can enable audio data caching by setting a `--cache-path` / `cache_path` and limit its size with `--max-cache-size` / `max_cache_size`.
## MPRIS
On linux desktop systems, you can enable `--use-mpris` / `use_mpris` (if your version has enabled that feature). This will give your desktop environment or tools like `playerctl` the option to display information about and control `spotifyd`.
================================================
FILE: docs/src/installation/README.md
================================================
# Installation
Getting `spotifyd` on your system should be as easy as downloading a binary in most cases.
If you'd like to learn how to compile `spotifyd` yourself, head over to [building from source](./source.md).
## Linux
Some linux distributions include `spotifyd` in their official repositories. Have a look at [Repology](https://repology.org/project/spotifyd/versions)
for a list of the distributions that currently ship an up-to-date version of `spotifyd`.
If your distribution is not supported or the provided version is too old, skip to [this section](#installing-from-releases) in order to install one of our pre-built binaries.
## macOS
If you're a homebrew user, installing `spotifyd` is as easy as running
```console
brew install spotifyd
```
## FreeBSD
On FreeBSD, a package is available and can be installed with `pkg install spotifyd`.
## OpenBSD
On OpenBSD, a package is available and can be installed with `pkg_add spotifyd`.
## Installing from releases
If none of the above methods work for you, you can also use our provided binaries.
First, you need to find a suitable binary for your platform. The provided binaries differ in the available features
and the platform architecture that they were built for. You can find the latest binaries [here](https://github.com/Spotifyd/spotifyd/releases).
**Feature Sets:**
- `full`: **all audio backends** and **MPRIS** support
- `default`: **some audio backends** (depending on your platform: PulseAudio, PortAudio, ALSA) and **MPRIS** support
- `slim`: **one audio backend** (depending on your platform) and **no MPRIS** support (good for headless systems)
If you're unsure which version to choose, just go for `default` on desktop systems and `slim` on headless systems.
**Architecture:**
If you're on Linux, check your platform architecture with `uname -m`:
- `x86_64`: Download one of the `spotifyd-linux-x86_64-{full,default,slim}.tar.gz` packages.
- `armhf`, `armv7`: Download one of the `spotifyd-linux-armv7-{full,default,slim}.tar.gz` packages.
- `aarch64`: Download one of the `spotifyd-linux-aarch64-{full,default,slim}.tar.gz`
- `armv6`: Unfortunately, we no longer support this architecture. If you still need this to work, please open an issue or join the [community matrix channel](https://matrix.to/#/#spotifyd:matrix.org) and we'll try to find a solution.
If you're on macOS, download one of the `spotifyd-macos-{full,default,slim}.tar.gz` packages.
You should now extract the downloaded archive, make the `spotifyd` file executable and copy it to a sensible location. This can be done using the following commands:
```console
$ tar xzf spotifyd-*.tar.gz # extract
$ cd spotifyd-*/
$ chmod +x spotifyd # make binary executable
$ # move to correct location, e.g. on Linux:
$ # for a user-wide installation (make sure that your $PATH includes ~/.local/bin)
$ mv spotifyd ~/.local/bin/spotifyd
$ # for a system-wide installation
$ sudo chown root:root spotifyd
$ sudo mv spotifyd /usr/local/bin/spotifyd
```
## Running
Now that you have installed `spotifyd`, you can check if everything was successful by running `spotifyd --version`.
You should be ready to go now and after running `spotifyd --no-daemon`, it should appear in an **official** Spotify client which is on the same network.
If this does not work, you can head over to the [troubleshooting section](../troubleshooting.md) or look at [different methods of authentication](../configuration/auth.md).
================================================
FILE: docs/src/installation/cross-compilation.md
================================================
# Cross-Compilation
If you want to run `spotifyd` on lower-power hardware such as a RaspberryPi, but none of our prebuilt binaries suit your needs, you might want to cross-compile `spotifyd` on a more powerful machine and deploy the binary on the target system.
## Using `cross`
The easiest way to cross-compile is using the amazing [`cross` project](https://github.com/cross-rs/cross). This way, the build environment comes already pre-configured.
Follow the instructions in their README to install `cross`.
In the current latest release of cross (v0.2.5), some targets are too outdated and compilation will fail. Thus, it is currently recommended to install the latest version of `cross` from their git repo instead of a prebuilt binary.
Then, you should be able to run `cross build --target `, where target is one of the targets in `rustc --print target-list`. Please also refer to [the general from source guide](./source.md) for additional flags that you might want to append to that command.
If this was successful, copy the resulting binary from `target//{release,debug}/spotifyd` to the `spotifyd` machine and try running it there.
If `cross` doesn't support your target, you can try the alternative approach using Docker and QEMU below.
If compilation of your target isn't working even though `cross` supports it, feel free to open an issue on our GitHub or join the [community matrix channel](https://matrix.to/#/#spotifyd:matrix.org) and ask there.
## Using Docker and QEMU
We can also use `docker` to cross compile on every platform and OS that runs `docker` and `qemu`:
1. Setup a docker [custom builder](https://docs.docker.com/build/building/multi-platform/#create-a-custom-builder)
```shell
docker buildx create \
--name container-builder \
--driver docker-container \
--use --bootstrap
```
If you are **not** using Docker-Desktop you might have to install [QEMU](https://docs.docker.com/build/building/multi-platform/#install-qemu-manually)
2. Create a docker `docker-compose.yml`
Here we are building a `arm64` binary, so we set `platform: linux/arm64`
```yaml
services:
build-container:
image: rust:1-bookworm
platform: linux/arm64
command: bash -c "
apt-get update &&
apt-get install -y \
libasound2-dev \
libssl-dev \
jq \
pkg-config &&
wget -O - https://api.github.com/repos/Spotifyd/spotifyd/tarball/$(\
curl -SsL https://api.github.com/repos/Spotifyd/spotifyd/releases/latest \
| jq '.tag_name' -r) \
| tar xzv -C /spotifyd --strip-components=1 &&
cargo build --release &&
cp /spotifyd/target/release/spotifyd /build/"
working_dir: /spotifyd
volumes:
- ./:/build
```
3. Run `docker compose up`
This will copy the build `spotifyd` binary in the current directory.
================================================
FILE: docs/src/installation/service.md
================================================
# Running as a service
Most people want to have `spotifyd` always running in the background. The preferred method to do this depends on the OS you're using.
## Linux
If you installed `spotifyd` directly from your distribution, chances are that the installation includes a service definition such that you can run
```console
$ systemctl --user start spotifyd # start spotifyd using systemd
$ systemctl --user enable --now spotifyd # start spotifyd and enable starting on login
```
If you installed `spotifyd` some other way, head over to [the advanced section](../advanced/systemd.md) for further instructions.
## macOS
If you installed `spotifyd` using brew, the following commands should do the trick
```console
$ brew services run spotifyd # start the service once
$ brew services start spotifyd # start spotifyd and enable starting on boot
```
If you installed `spotifyd` without brew, [the advanced section](../advanced/launchd.md) has got you covered.
## FreeBSD
When installed via the package manager, the following commands are available:
```console
$ sudo service spotifyd onestart # start spotifyd once
$ sudo sysrc spotifyd_enable=YES # enable starting spotifyd on boot
```
================================================
FILE: docs/src/installation/source.md
================================================
# Building from source
The guide below assumes that you're building `spotifyd` on the system that you want to run it on. If you'd instead prefer to cross-compile, head over to [this section](./cross-compilation.md).
You can also compile `spotifyd` yourself, allowing you to tailor it perfectly to your needs or get the latest fixes. `spotifyd` is written in Rust. You can download the toolchain (compiler and package manager) over at [rustup.rs](https://rustup.rs). Follow their instructions to get started.
> __Note:__ Please make sure that you compile the package using the most recent `stable` version of Rust available through `rustup`. Some distro versions are quite outdated and might result in compilation errors.
## Required packages
`spotifyd` might require additional libraries during build and runtime, depending on your platform and the way to compile it (static or dynamic). The following table shows the libraries needed for each OS respectively.
| Target Platform | Libraries |
|-----------------|------------------------------------------------------|
| Fedora | alsa-lib-devel make gcc |
| openSUSE | alsa-devel make gcc |
| Debian | libasound2-dev libssl-dev libpulse-dev libdbus-1-dev |
| Arch | base-devel alsa-lib libogg libpulse dbus |
| macOS | dbus pkg-config portaudio |
If you're building on a non-standard target, for example the RaspberryPi, you might need an additional `libclang-dev` and `cmake` package for one of our dependencies. Details can be found on [this page](https://aws.github.io/aws-lc-rs/requirements/linux.html).
## Installing with cargo
To build and install the latest version of `spotifyd`, you can use the package manager for rust. The base command is the following
```console
cargo install spotifyd --locked
```
If you would rather install from the latest commit on GitHub, download or clone the project, enter the directory and run
```console
cargo install --path . --locked
```
> __Note:__ Both methods will install the binary in `$XDG_DATA_HOME/cargo/bin` or `$HOME/.cargo/bin`. To execute it, you must make sure that this location is part of your shell's `$PATH` variable. Also, you might have to change the paths when following other parts of this documentation.
## Compiling with cargo
To just build the binary without installing, run
```console
cargo build --release --locked
```
This will build the binary and leave the result at `./target/release/spotifyd`.
## Building a Debian package
You can use the `cargo-deb` crate in order to build a Debian package from source.
Install it by:
```console
cargo install cargo-deb
```
Then you can build and install the Debian package with:
```console
cargo deb --install
```
Note, that when building a Debian package, the `--release` is passed to the
build command already and you do not need to specify it yourself. See for the
flags that are set by default in `Cargo.toml`.
## Building an RPM package
You can use the `cargo-generate-rpm` crate in order to build an RPM package from source.
Install it by:
```console
cargo install cargo-generate-rpm
```
Then you can build and install the RPM package with:
```console
cargo build --release
strip -s target/release/spotifyd
cargo generate-rpm
sudo rpm -Uvh target/generate-rpm/spotifyd-[VERSION].[ARCH].rpm
```
## Feature Flags
`spotifyd` is split into a base package plus additional features that can be toggled on or off during compilation. Those can be split into two groups: The audio backend features that are responsible for playing back the music and additional functionality features, which enhance your experience using `spotifyd`.
| Feature Flag | Description |
|--------------|-------------------------------------------------------------------------------------|
| `alsa_backend` | Provides support for the ALSA backend. Should work in most setups and is enabled by default. |
| `pulseaudio_backend` | Support for PulseAudio. |
| `rodio_backend` | Rust-native implementation of audio backends on all platforms. Does not need any external packages to be installed. |
| `portaudio_backend` | Audio backend that can be used on non-Linux systems. |
| `rodiojack_backend` | Support for the Jack backend. |
| `dbus_mpris` | Provides multimedia key support (Linux and BSD only) |
To customize your build, pass a subset of the features listed above to any of the `cargo` commands above via `--features ,,...`. Disable the default feature `alsa_backend` with `--no-default-features`. So an example command could look like the following:
```
cargo install spotifyd --locked --no-default-features --features rodio_backend,dbus_mpris
```
================================================
FILE: docs/src/troubleshooting.md
================================================
# Troubleshooting
## no sound on FreeBSD
If you have correctly configured `spotifyd` to use `portaudio` and everything seems to be working except that there's no sound, you might have to switch to a different audio device.
If you have `portaudio` as your backend and set your device to `?`, spotifyd will output all of the available PortAudio devices it can find on your system. This could look like the following
```bash
- /dev/dsp0 (default)
- /dev/dsp1
- /dev/dsp2
- /dev/dsp
```
Assume that the 4th device (index 3, starting from 0, `/dev/dsp`) is the output device that is needed. That coincides with the `pcm3` (also index 3, starting from 0) device that FreeBSD lists in `dmesg` as well as the `hw.snd.default_unit=3` sysctl that is used to set the device as OSS's default. It seems like the index number correlates across each of those enumerations.
After setting `device = "/dev/dsp"` in the config, the sound should start working. If not, you can try the other possible values that are available.
================================================
FILE: hooks/pre-commit
================================================
#!/bin/sh
# Author: Sven Lechner (SirWindfield)
# License: GPLv3
require_clean_work_tree() {
# Update index
git update-index -q --ignore-submodules --refresh
err=0
# Disallow unstaged changes in the working tree
if ! git diff-files --quiet --ignore-submodules --; then
echo >&2 "Cannot commit: you have unstaged changes."
git diff-files --name-status -r --ignore-submodules -- >&2
err=1
fi
if [ $err = 1 ]; then
echo >&2 "Please stage or stash them."
exit 1
fi
}
echo "→ Checking for local changes..."
require_clean_work_tree
echo "→ Formatting Rust code..."
cargo fmt
if [ $? -ne 0 ]; then
exit 1
fi
for path in $(git diff --name-only --cached); do
git update-index --add $path
done
echo "→ Building pre-commit build artifacts..."
cargo check --quiet --no-default-features --features "rodio_backend"
if [ $? -ne 0 ]; then
exit 1
fi
cargo build --quiet --no-default-features --features "rodio_backend"
# Linting is only done with the rodio backend and the keyring feature as those should be
# compilable for every supported platform without external library needs.
echo "→ Linting Rust code..."
cargo clippy --no-default-features --features "rodio_backend" -- -D warnings
echo "→ Testing Rust code..."
cargo test --no-default-features --features "rodio_backend"
================================================
FILE: setup-dev-workspace.sh
================================================
#!/bin/sh
# Author: Sven Lechner (SirWindfield)
# License: GPLv3
# Copies all hooks into the .git/hooks directory
cp hooks/* .git/hooks
================================================
FILE: src/alsa_mixer.rs
================================================
use alsa::device_name::HintIter;
use color_eyre::{
Section,
eyre::{self, Context, eyre},
};
use librespot_playback::mixer::{Mixer, MixerConfig};
use log::error;
use std::sync::{Arc, Mutex, MutexGuard};
pub fn get_available_controls() -> alsa::Result {
alsa::device_name::HintIter::new_str(None, "ctl")
}
pub struct AlsaMixer {
pub mixer: Arc>,
pub config: MixerConfig,
}
impl AlsaMixer {
fn get_selem<'a>(
&'a self,
lock: &'a MutexGuard<'a, alsa::Mixer>,
) -> eyre::Result> {
let selem_id = alsa::mixer::SelemId::new(&self.config.control, self.config.index);
let selem = lock.find_selem(&selem_id).ok_or_else(|| {
eyre!(
"No control with name '{}' in alsa device '{}'",
self.config.control,
self.config.device,
)
.with_suggestion(|| {
format!(
"maybe try one of the following for 'control':{}",
lock.iter()
.filter_map(|elem| {
let selem = alsa::mixer::Selem::new(elem)?;
if selem.has_playback_volume() {
selem
.get_id()
.get_name()
.ok()
.map(|name| format!("\n- {name}"))
} else {
None
}
})
.collect::()
)
})
})?;
Ok(selem)
}
fn set_volume_with_err(&self, volume: u16) -> eyre::Result<()> {
let lock = self.mixer.lock().expect("lock shouldn't be poisoned");
let elem = self.get_selem(&lock)?;
let (min, max) = elem.get_playback_volume_range();
let volume_steps = (max - min) as f64;
let normalised_volume = if matches!(
self.config.volume_ctrl,
librespot_playback::config::VolumeCtrl::Linear
) {
(((volume as f64) / (u16::MAX as f64)) * volume_steps) as i64 + min
} else {
((volume as f64 + 1.0).log((u16::MAX as f64) + 1.0) * volume_steps).floor() as i64 + min
};
elem.set_playback_volume_all(normalised_volume)?;
Ok(())
}
fn get_volume_with_err(&self) -> eyre::Result {
let lock = self.mixer.lock().expect("lock shouldn't be poisoned");
let elem = self.get_selem(&lock)?;
let (min, max) = elem.get_playback_volume_range();
let volume_steps = (max - min) as f64;
let vol = elem.get_playback_volume(alsa::mixer::SelemChannelId::mono())?;
let normalized_volume = if matches!(
self.config.volume_ctrl,
librespot_playback::config::VolumeCtrl::Linear
) {
((vol - min) as f64 * u16::MAX as f64 / volume_steps).floor() as u16
} else {
((u16::MAX as f64 + 1.0).powf(((vol - min) as f64) / volume_steps) - 1.0).floor() as u16
};
Ok(normalized_volume)
}
}
impl Mixer for AlsaMixer {
fn open(config: MixerConfig) -> Result {
let mixer = alsa::Mixer::new(&config.device, false)
.wrap_err("failed to open mixer")
.map_err(librespot_core::Error::invalid_argument)?;
Ok(AlsaMixer {
mixer: Arc::new(Mutex::new(mixer)),
config,
})
}
fn volume(&self) -> u16 {
match self.get_volume_with_err() {
Ok(vol) => vol,
Err(err) => {
error!("failed to get volume from alsa device: {err:?}");
0
}
}
}
fn set_volume(&self, volume: u16) {
match self.set_volume_with_err(volume) {
Ok(_) => (),
Err(err) => error!("Couldn't set volume of alsa device: {err:?}"),
}
}
}
================================================
FILE: src/config.rs
================================================
use crate::utils;
use clap::{
Args, Parser, Subcommand, ValueEnum,
builder::{IntoResettable, PossibleValuesParser, TypedValueParser, ValueParser},
};
use color_eyre::{
Report,
eyre::{Context, bail},
};
use directories::ProjectDirs;
use gethostname::gethostname;
use librespot_core::{cache::Cache, config::DeviceType as LSDeviceType, config::SessionConfig};
use librespot_playback::{
audio_backend,
config::{AudioFormat as LSAudioFormat, Bitrate as LSBitrate, PlayerConfig},
dither::{DithererBuilder, TriangularDitherer, mk_ditherer},
};
use log::{debug, error, info, warn};
use serde::{
Deserialize, Deserializer,
de::{self, Error, Unexpected},
};
use sha1::{Digest, Sha1};
use std::{
borrow::Cow,
convert::TryInto,
fs,
path::{Path, PathBuf},
str::FromStr,
};
use url::Url;
const CONFIG_FILE_NAME: &str = "spotifyd.conf";
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, ValueEnum)]
#[serde(rename_all = "snake_case")]
pub enum VolumeController {
#[cfg(feature = "alsa_backend")]
Alsa,
#[cfg(feature = "alsa_backend")]
AlsaLinear,
#[serde(rename = "softvol")]
SoftVolume,
None,
}
// Spotify's device type (copied from it's config.rs)
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, ValueEnum)]
#[serde(rename_all = "snake_case")]
pub enum DeviceType {
Unknown,
Computer,
Tablet,
Smartphone,
Speaker,
#[serde(rename = "t_v")]
Tv,
#[serde(rename = "a_v_r")]
Avr,
#[serde(rename = "s_t_b")]
Stb,
AudioDongle,
GameConsole,
CastAudio,
CastVideo,
Automobile,
Smartwatch,
Chromebook,
UnknownSpotify,
CarThing,
Observer,
}
impl From for LSDeviceType {
fn from(item: DeviceType) -> Self {
match item {
DeviceType::Unknown => LSDeviceType::Unknown,
DeviceType::Computer => LSDeviceType::Computer,
DeviceType::Tablet => LSDeviceType::Tablet,
DeviceType::Smartphone => LSDeviceType::Smartphone,
DeviceType::Speaker => LSDeviceType::Speaker,
DeviceType::Tv => LSDeviceType::Tv,
DeviceType::Avr => LSDeviceType::Avr,
DeviceType::Stb => LSDeviceType::Stb,
DeviceType::AudioDongle => LSDeviceType::AudioDongle,
DeviceType::GameConsole => LSDeviceType::GameConsole,
DeviceType::CastAudio => LSDeviceType::CastAudio,
DeviceType::CastVideo => LSDeviceType::CastVideo,
DeviceType::Automobile => LSDeviceType::Automobile,
DeviceType::Smartwatch => LSDeviceType::Smartwatch,
DeviceType::Chromebook => LSDeviceType::Chromebook,
DeviceType::UnknownSpotify => LSDeviceType::UnknownSpotify,
DeviceType::CarThing => LSDeviceType::CarThing,
DeviceType::Observer => LSDeviceType::Observer,
}
}
}
fn bitrate_parser() -> impl IntoResettable {
let possible_values: PossibleValuesParser = ["96", "160", "320"].into();
possible_values.map(|val| match val.as_str() {
"96" => Bitrate::Bitrate96,
"160" => Bitrate::Bitrate160,
"320" => Bitrate::Bitrate320,
_ => unreachable!(),
})
}
/// Spotify's audio bitrate
#[derive(Clone, Copy, Debug, PartialEq, Eq, ValueEnum)]
pub enum Bitrate {
Bitrate96,
Bitrate160,
Bitrate320,
}
impl<'de> Deserialize<'de> for Bitrate {
fn deserialize>(deserializer: D) -> Result {
match u16::deserialize(deserializer) {
Ok(96) => Ok(Self::Bitrate96),
Ok(160) => Ok(Self::Bitrate160),
Ok(320) => Ok(Self::Bitrate320),
Ok(x) => Err(D::Error::invalid_value(
Unexpected::Unsigned(x.into()),
&"a bitrate: 96, 160, 320",
)),
Err(e) => Err(e),
}
}
}
impl From for LSBitrate {
fn from(bitrate: Bitrate) -> Self {
match bitrate {
Bitrate::Bitrate96 => LSBitrate::Bitrate96,
Bitrate::Bitrate160 => LSBitrate::Bitrate160,
Bitrate::Bitrate320 => LSBitrate::Bitrate320,
}
}
}
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, ValueEnum)]
#[serde(rename_all = "snake_case")]
pub enum DBusType {
Session,
System,
}
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, ValueEnum)]
pub enum AudioFormat {
F32,
S32,
S24,
S24_3,
S16,
}
impl From for LSAudioFormat {
fn from(audio_format: AudioFormat) -> Self {
match audio_format {
AudioFormat::F32 => LSAudioFormat::F32,
AudioFormat::S32 => LSAudioFormat::S32,
AudioFormat::S24 => LSAudioFormat::S24,
AudioFormat::S24_3 => LSAudioFormat::S24_3,
AudioFormat::S16 => LSAudioFormat::S16,
}
}
}
fn possible_backends() -> Vec<&'static str> {
audio_backend::BACKENDS.iter().map(|b| b.0).collect()
}
fn deserialize_backend<'de, D>(de: D) -> Result, D::Error>
where
D: Deserializer<'de>,
{
let backend = String::deserialize(de)?;
let possible_backends = possible_backends();
if possible_backends.contains(&backend.as_str()) {
Ok(Some(backend))
} else {
Err(de::Error::invalid_value(
Unexpected::Str(&backend),
&format!(
"a valid backend (available: {})",
possible_backends.join(", ")
)
.as_str(),
))
}
}
fn number_or_string<'de, D>(de: D) -> Result, D::Error>
where
D: Deserializer<'de>,
{
let val = toml::Value::deserialize(de)?;
let unexpected = match val {
toml::Value::Integer(num) => {
let num: u8 = num.try_into().map_err(de::Error::custom)?;
return Ok(Some(num));
}
toml::Value::String(num) => {
return u8::from_str(&num)
.map(Some)
.inspect(|_| warn!("`initial_volume` should be a number rather than a string, this will become a hard error in the future"))
.map_err(de::Error::custom)
}
toml::Value::Float(f) => Unexpected::Float(f),
toml::Value::Boolean(b) => Unexpected::Bool(b),
toml::Value::Datetime(_) => Unexpected::Other("datetime"),
toml::Value::Array(_) => Unexpected::Seq,
toml::Value::Table(_) => Unexpected::Map,
};
Err(de::Error::invalid_type(unexpected, &"number"))
}
#[derive(Debug, Default, Parser)]
#[command(version, about, long_about = None, args_conflicts_with_subcommands = true)]
pub struct CliConfig {
/// The path to the config file to use
#[arg(long, value_name = "PATH", global = true)]
pub config_path: Option,
/// Prints more verbose output
#[arg(short, long, action = clap::ArgAction::Count, global = true)]
pub verbose: u8,
/// If set, starts spotifyd without detaching
#[arg(long)]
pub no_daemon: bool,
/// Path to PID file.
#[cfg(unix)]
#[arg(long, value_name = "PATH")]
pub pid: Option,
#[command(subcommand)]
pub mode: Option,
#[command(flatten)]
pub shared_config: SharedConfigValues,
}
#[derive(Debug, Subcommand)]
pub enum ExecutionMode {
#[command(visible_alias = "auth")]
Authenticate {
/// The port to use for the OAuth redirect
#[arg(long, default_value_t = 8000)]
oauth_port: u16,
},
}
// A struct that holds all allowed config fields.
// The actual config file is made up of two sections, spotifyd and global.
#[derive(Clone, Default, Debug, Deserialize, PartialEq, Args)]
pub struct SharedConfigValues {
/// A script that gets evaluated in the user's shell when the song changes
#[arg(visible_alias = "onevent", long, value_name = "CMD")]
#[serde(alias = "onevent")]
on_song_change_hook: Option,
/// The cache path used to store credentials and music file artifacts
#[arg(long, short, value_name = "PATH", global = true)]
cache_path: Option,
/// The maximal cache size in bytes
#[arg(long, value_name = "BYTES")]
max_cache_size: Option,
/// Disable the use of audio cache
#[arg(
long,
default_missing_value("true"),
require_equals = true,
num_args(0..=1),
value_name = "BOOL"
)]
no_audio_cache: Option,
/// The audio backend to use
#[arg(long, short, value_parser = possible_backends())]
#[serde(deserialize_with = "deserialize_backend", default)]
backend: Option,
/// The volume controller to use
#[arg(value_enum, long, visible_alias = "volume-control")]
#[serde(alias = "volume-control")]
volume_controller: Option,
/// The audio device (or pipe file)
#[arg(long)]
device: Option,
/// The device name displayed in Spotify
#[arg(long, short)]
device_name: Option,
/// The bitrate of the streamed audio data
#[arg(long, short = 'B', value_parser = bitrate_parser())]
bitrate: Option,
/// The audio format of the streamed audio data
#[arg(value_enum, long)]
audio_format: Option,
/// Initial volume between 0 and 100
#[arg(long)]
#[serde(deserialize_with = "number_or_string", default)]
initial_volume: Option,
/// Enable to normalize the volume during playback
#[arg(
long,
default_missing_value("true"),
require_equals = true,
num_args(0..=1),
value_name = "BOOL"
)]
volume_normalisation: Option,
/// A custom pregain applied before sending the audio to the output device
#[arg(long)]
normalisation_pregain: Option,
#[arg(
long,
default_missing_value("true"),
require_equals = true,
num_args(0..=1),
value_name = "BOOL"
)]
disable_discovery: Option,
/// The port used for the Spotify Connect discovery
#[arg(long)]
zeroconf_port: Option,
/// The proxy used to connect to spotify's servers
#[arg(long, value_name = "URL")]
proxy: Option,
/// The device type shown to clients
#[arg(value_enum, long)]
device_type: Option,
/// Start playing similar songs after your music has ended
#[arg(
long,
default_missing_value("true"),
require_equals = true,
num_args(0..=1),
value_name = "BOOL"
)]
#[serde(default)]
autoplay: Option,
#[cfg(feature = "alsa_backend")]
#[command(flatten)]
#[serde(flatten)]
alsa_config: AlsaConfig,
#[cfg(feature = "dbus_mpris")]
#[command(flatten)]
#[serde(flatten)]
mpris_config: MprisConfig,
}
#[cfg(feature = "dbus_mpris")]
#[derive(Debug, Default, Clone, Deserialize, Args, PartialEq, Eq)]
pub struct MprisConfig {
/// Enables the MPRIS interface
#[arg(
long,
default_missing_value("true"),
require_equals = true,
num_args(0..=1),
value_name = "BOOL"
)]
#[serde(alias = "use-mpris")]
pub(crate) use_mpris: Option,
/// The Bus-type to use for the MPRIS interface
#[arg(value_enum, long)]
pub(crate) dbus_type: Option,
}
#[cfg(feature = "alsa_backend")]
#[derive(Debug, Default, Clone, Deserialize, Args, PartialEq, Eq)]
pub struct AlsaConfig {
/// The control device
#[arg(long)]
pub(crate) control: Option,
/// The mixer to use
#[arg(long)]
pub(crate) mixer: Option,
}
#[derive(Debug, Default, Deserialize)]
pub struct FileConfig {
global: Option,
spotifyd: Option,
}
impl FileConfig {
pub fn get_merged_sections(self) -> Option {
match (self.global, self.spotifyd) {
(Some(global), Some(mut spotifyd)) => {
spotifyd.merge_with(global);
Some(spotifyd)
}
(global, spotifyd) => global.or(spotifyd),
}
}
}
#[derive(Copy, Clone)]
enum KnownConfigProblem {
#[cfg_attr(
all(feature = "alsa_backend", feature = "dbus_mpris"),
expect(dead_code)
)]
MissingFeature(&'static str),
UsernamePassword,
}
fn get_known_config_problem(path: &serde_ignored::Path<'_>) -> Option {
const DISABLED_CONFIGS: &[(KnownConfigProblem, &[&str])] = &[
#[cfg(not(feature = "alsa_backend"))]
(
KnownConfigProblem::MissingFeature("alsa_backend"),
&["control", "mixer"],
),
#[cfg(not(feature = "dbus_mpris"))]
(
KnownConfigProblem::MissingFeature("dbus_mpris"),
&["use_mpris", "dbus_type"],
),
(
KnownConfigProblem::UsernamePassword,
&[
"username",
"password",
"username_cmd",
"password_cmd",
"use_keyring",
],
),
];
if let serde_ignored::Path::Map { key, .. } = path {
for (problem, params) in DISABLED_CONFIGS {
if params.contains(&key.as_str()) {
return Some(*problem);
}
}
}
None
}
impl CliConfig {
pub fn load_config_file_values(&mut self) -> Result<(), Report> {
let config_file_path = match self.config_path.clone().or_else(get_config_file) {
Some(p) => p,
None => {
info!("No config file specified. Running with default values");
return Ok(());
}
};
info!("Loading config from {:?}", &config_file_path);
let content = match fs::read_to_string(config_file_path) {
Ok(s) => s,
Err(e) => {
info!("Failed reading config file: {}", e);
return Ok(());
}
};
let toml_de = toml::Deserializer::parse(&content)?;
let config_content: FileConfig = serde_ignored::deserialize(toml_de, |path| {
if let Some(problem) = get_known_config_problem(&path) {
match problem {
KnownConfigProblem::MissingFeature(feature) => {
warn!(
"The config key '{path}' is ignored, because the feature '{feature}' is missing in this build"
);
}
KnownConfigProblem::UsernamePassword => {
warn!(
"The config key '{path}' is ignored, because authentication with username and password is no longer supported by Spotify. Please use `spotifyd authenticate` instead"
);
}
}
} else {
warn!("Unknown key '{path}' in config will be ignored");
}
})?;
// The call to get_merged_sections consumes the FileConfig!
if let Some(merged_sections) = config_content.get_merged_sections() {
self.shared_config.merge_with(merged_sections);
}
Ok(())
}
}
impl SharedConfigValues {
pub fn get_cache(&self, for_oauth: bool) -> color_eyre::Result {
let Some(cache_path) = self.cache_path.as_deref().map(Cow::Borrowed).or_else(|| {
ProjectDirs::from("", "", "spotifyd")
.map(|dirs| Cow::Owned(dirs.cache_dir().to_path_buf()))
}) else {
bail!("Failed to determine cache directory, please specify one manually");
};
if for_oauth {
let mut creds_path = cache_path.into_owned();
creds_path.push("oauth");
Cache::new(Some(creds_path), None, None, None)
} else {
let audio_cache = !self.no_audio_cache.unwrap_or(false);
let mut creds_path = cache_path.to_path_buf();
creds_path.push("zeroconf");
Cache::new(
Some(creds_path.as_path()),
Some(cache_path.as_ref()),
audio_cache.then_some(cache_path.as_ref()),
self.max_cache_size,
)
}
.wrap_err("Failed to initialize cache")
}
pub fn proxy_url(&self) -> Option {
match &self.proxy {
Some(s) => match Url::parse(s) {
Ok(url) => {
if url.scheme() != "http" {
error!("Only HTTP proxies are supported!");
None
} else {
Some(url)
}
}
Err(err) => {
error!("Invalid proxy URL: {}", err);
None
}
},
None => {
debug!("No proxy specified");
None
}
}
}
pub fn merge_with(&mut self, mut other: SharedConfigValues) {
macro_rules! merge {
($a:expr; and $b:expr => {$($x:ident),+}) => {
$($a.$x = $a.$x.take().or_else(|| $b.$x.take());)+
}
}
// Handles Option merging.
merge!(self; and other => {
backend,
volume_normalisation,
normalisation_pregain,
bitrate,
initial_volume,
device_name,
device,
volume_controller,
cache_path,
no_audio_cache,
on_song_change_hook,
disable_discovery,
zeroconf_port,
proxy,
device_type,
max_cache_size,
audio_format,
autoplay
});
#[cfg(feature = "dbus_mpris")]
merge!(self.mpris_config; and other.mpris_config => {use_mpris, dbus_type});
#[cfg(feature = "alsa_backend")]
merge!(self.alsa_config; and other.alsa_config => {mixer, control});
}
}
pub(crate) fn get_config_file() -> Option {
let etc_conf = format!("/etc/{CONFIG_FILE_NAME}");
let dirs = directories::ProjectDirs::from("", "", "spotifyd")?;
let mut path = dirs.config_dir().to_path_buf();
path.push(CONFIG_FILE_NAME);
if path.exists() {
Some(path)
} else if Path::new(&etc_conf).exists() {
let path: PathBuf = etc_conf.into();
Some(path)
} else {
None
}
}
fn device_id(name: &str) -> String {
hex::encode(Sha1::digest(name.as_bytes()))
}
pub(crate) struct SpotifydConfig {
pub(crate) cache: Option,
pub(crate) oauth_cache: Option,
pub(crate) backend: Option,
pub(crate) audio_device: Option,
pub(crate) audio_format: LSAudioFormat,
pub(crate) volume_controller: VolumeController,
pub(crate) initial_volume: u16,
pub(crate) device_name: String,
pub(crate) player_config: PlayerConfig,
pub(crate) session_config: SessionConfig,
pub(crate) onevent: Option,
#[cfg(unix)]
pub(crate) pid: Option,
pub(crate) shell: String,
pub(crate) discovery: bool,
pub(crate) zeroconf_port: Option,
pub(crate) device_type: LSDeviceType,
#[cfg(feature = "dbus_mpris")]
pub(crate) mpris: MprisConfig,
#[cfg(feature = "alsa_backend")]
pub(crate) alsa_config: AlsaConfig,
}
pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
let (cache, oauth_cache) = match (
config.shared_config.get_cache(false),
config.shared_config.get_cache(true),
) {
(Ok(cache), Ok(oauth_cache)) => (Some(cache), Some(oauth_cache)),
(a, b) => {
// at least one of the results are err
let err = a.or(b).map(|_| ()).unwrap_err();
warn!("{err}");
(None, None)
}
};
let proxy_url = config.shared_config.proxy_url();
let bitrate: LSBitrate = config
.shared_config
.bitrate
.unwrap_or(Bitrate::Bitrate160)
.into();
let audio_format: LSAudioFormat = config
.shared_config
.audio_format
.unwrap_or(AudioFormat::S16)
.into();
let volume_controller = config
.shared_config
.volume_controller
.unwrap_or(VolumeController::SoftVolume);
let default_initial_volume = 90;
let initial_volume: u16 = config
.shared_config
.initial_volume
.filter(|val| {
if (0..=100).contains(val) {
true
} else {
warn!("initial_volume must be in range 0..100");
false
}
})
.map(|volume| (volume as i32 * (u16::MAX as i32) / 100) as u16)
.unwrap_or((default_initial_volume * (u16::MAX as i32) / 100) as u16);
let device_name = config
.shared_config
.device_name
.filter(|s| !s.trim().is_empty())
.unwrap_or_else(|| format!("{}@{}", "Spotifyd", gethostname().to_string_lossy()));
let device_id = device_id(&device_name);
let normalisation_pregain = config.shared_config.normalisation_pregain.unwrap_or(0.0);
let device_type = config
.shared_config
.device_type
.unwrap_or(DeviceType::Speaker)
.into();
#[cfg(unix)]
let pid = config.pid.map(|f| {
f.into_os_string()
.into_string()
.expect("Failed to convert PID file path to valid Unicode")
});
let shell = utils::get_shell().unwrap_or_else(|| {
info!("Unable to identify shell. Defaulting to \"sh\".");
"sh".to_string()
});
// choose default ditherer the same way librespot does
let ditherer: Option = match audio_format {
LSAudioFormat::S16 | LSAudioFormat::S24 | LSAudioFormat::S24_3 => {
Some(mk_ditherer::)
}
_ => None,
};
// TODO: when we were on librespot 0.1.5, all PlayerConfig values were available in the
// Spotifyd config. The upgrade to librespot 0.2.0 introduces new config variables, and we
// should consider adding them to Spotifyd's config system.
let pc = PlayerConfig {
bitrate,
normalisation: config.shared_config.volume_normalisation.unwrap_or(false),
normalisation_pregain_db: normalisation_pregain,
gapless: true,
ditherer,
..Default::default()
};
SpotifydConfig {
cache,
oauth_cache,
backend: config.shared_config.backend,
audio_device: config.shared_config.device,
audio_format,
volume_controller,
initial_volume,
device_name,
player_config: pc,
session_config: SessionConfig {
autoplay: config.shared_config.autoplay,
device_id,
proxy: proxy_url,
ap_port: Some(443),
..Default::default()
},
onevent: config.shared_config.on_song_change_hook,
shell,
discovery: !config.shared_config.disable_discovery.unwrap_or(false),
zeroconf_port: config.shared_config.zeroconf_port,
device_type,
#[cfg(unix)]
pid,
#[cfg(feature = "dbus_mpris")]
mpris: config.shared_config.mpris_config,
#[cfg(feature = "alsa_backend")]
alsa_config: config.shared_config.alsa_config,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_section_merging() {
let mut spotifyd_section = SharedConfigValues {
device_type: Some(DeviceType::Computer),
..Default::default()
};
let global_section = SharedConfigValues {
device_name: Some("spotifyd-test".to_string()),
..Default::default()
};
// The test only makes sense if both sections differ.
assert_ne!(spotifyd_section, global_section);
let file_config = FileConfig {
global: Some(global_section),
spotifyd: Some(spotifyd_section.clone()),
};
let merged_config = file_config.get_merged_sections().unwrap();
// Add the new field to spotifyd section.
spotifyd_section.device_name = Some("spotifyd-test".to_string());
assert_eq!(merged_config, spotifyd_section);
}
#[test]
fn test_example_config() {
let example_config = include_str!("../contrib/spotifyd.conf");
let config: FileConfig = toml::Deserializer::parse(example_config)
.and_then(|toml_de| {
serde_ignored::deserialize(toml_de, |path| {
panic!("Unknown key in (commented) example config: '{}'", path)
})
})
.expect("Commented example config should be valid");
assert_eq!(
(config.global, config.spotifyd),
(Some(SharedConfigValues::default()), None),
"example config should not do anything by default, but contain the global section"
);
let uncommented_example_config = example_config
.lines()
.map(|line| {
// uncomment any line starting with #[a-zA-Z]
line.strip_prefix("#")
.filter(|rest| {
// uncomment if the rest is a valid config line
// if alsa_backend is not enabled, ignore the 'backend = "alsa"' line
rest.starts_with(char::is_alphabetic)
&& (cfg!(feature = "alsa_backend") || !rest.starts_with("backend"))
})
.unwrap_or(line)
})
.collect::>()
.join("\n");
let config: FileConfig = toml::Deserializer::parse(&uncommented_example_config)
.and_then(|toml_de| {
serde_ignored::deserialize(toml_de, |path| {
if !matches!(
get_known_config_problem(&path),
Some(KnownConfigProblem::MissingFeature(_))
) {
panic!("Unknown configuration key in example config: {}", path);
}
})
})
.expect("Uncommented example config should be valid");
assert!(
config.spotifyd.is_none(),
"example config should not have a spotifyd section"
);
assert!(
config
.global
.is_some_and(|global| global != SharedConfigValues::default()),
"uncommented example config should contain some values"
);
}
}
================================================
FILE: src/dbus_mpris.rs
================================================
use crate::config::DBusType;
use chrono::{Duration, prelude::*};
use dbus::{
MethodErr,
arg::{RefArg, Variant},
channel::{MatchingReceiver, Sender},
message::{MatchRule, SignalArgs},
nonblock::stdintf::org_freedesktop_dbus::PropertiesPropertiesChanged,
};
use dbus_crossroads::{Crossroads, IfaceToken};
use dbus_tokio::connection::{self, IOResourceError};
use futures::{
Future,
task::{Context, Poll},
};
use librespot_connect::{LoadContextOptions, LoadRequest, LoadRequestOptions, Spirc};
use librespot_core::{Session, SpotifyUri};
use librespot_metadata::audio::AudioItem;
use librespot_playback::player::PlayerEvent;
use log::{debug, warn};
use std::convert::TryFrom;
use std::{
collections::HashMap,
pin::Pin,
sync::{Arc, RwLock},
};
use thiserror::Error;
use time::format_description::well_known::Iso8601;
use tokio::{
runtime::Handle,
sync::{
Mutex,
mpsc::{UnboundedReceiver, UnboundedSender},
},
};
type DbusMap = HashMap>>;
const MPRIS_PATH: &str = "/org/mpris/MediaPlayer2";
const CONTROLS_PATH: &str = "/rs/spotifyd/Controls";
pub enum ControlMessage {
SetSession(Arc, Session),
DropSession,
Shutdown,
}
pub(crate) struct DbusServer {
dbus_future: Pin>>>,
control_tx: UnboundedSender,
}
impl DbusServer {
pub fn new(event_rx: UnboundedReceiver, dbus_type: DBusType) -> DbusServer {
let (control_tx, control_rx) = tokio::sync::mpsc::unbounded_channel();
let dbus_future = Box::pin(create_dbus_server(event_rx, control_rx, dbus_type));
DbusServer {
dbus_future,
control_tx,
}
}
pub fn set_session(&self, spirc: Arc, session: Session) -> Result<(), DbusError> {
self.control_tx
.send(ControlMessage::SetSession(spirc, session))
.map_err(|_| DbusError::ControlChannelBroken)
}
pub fn drop_session(&self) -> Result<(), DbusError> {
self.control_tx
.send(ControlMessage::DropSession)
.map_err(|_| DbusError::ControlChannelBroken)
}
/// Sends a shutdown signal and returns false, if the server was already shut down.
pub fn shutdown(&self) -> bool {
self.control_tx.send(ControlMessage::Shutdown).is_ok()
}
}
#[derive(Debug, Error)]
pub(crate) enum DbusError {
#[error("Failed to initialize D-Bus: {}", .0)]
InitFailure(#[from] dbus::Error),
#[error("The connection was terminated unexpectedly: {}", .0)]
ConnectionFailure(#[from] IOResourceError),
#[error("Unexpectedly lost control of dbus server")]
ControlChannelBroken,
}
impl Future for DbusServer {
type Output = Result<(), DbusError>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll {
self.dbus_future.as_mut().poll(cx)
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum PlaybackStatus {
Playing,
Paused,
Stopped,
}
impl PlaybackStatus {
fn to_mpris(self) -> &'static str {
match self {
PlaybackStatus::Playing => "Playing",
PlaybackStatus::Paused => "Paused",
PlaybackStatus::Stopped => "Stopped",
}
}
}
#[derive(Debug)]
struct Position {
last_position: Duration,
last_update: DateTime,
}
impl Position {
fn new() -> Self {
Self {
last_position: Duration::zero(),
last_update: Local::now(),
}
}
fn update_position(&mut self, new_position: Duration) {
self.last_update = Local::now();
self.last_position = new_position;
}
fn get_position(&self) -> Duration {
(Local::now() - self.last_update) + self.last_position
}
}
#[derive(Clone, Copy, Debug)]
enum RepeatState {
None,
Track,
All,
}
impl RepeatState {
fn to_mpris(self) -> &'static str {
match self {
RepeatState::None => "None",
RepeatState::Track => "Track",
RepeatState::All => "Playlist",
}
}
fn repeat_track(self) -> bool {
matches!(self, RepeatState::Track)
}
fn repeat_context(self) -> bool {
!matches!(self, RepeatState::None)
}
}
impl From<(bool, bool)> for RepeatState {
fn from((context, track): (bool, bool)) -> Self {
if context {
if track {
RepeatState::Track
} else {
RepeatState::All
}
} else {
RepeatState::None
}
}
}
#[derive(Debug)]
struct CurrentStateInner {
status: PlaybackStatus,
position: Option,
audio_item: Option>,
volume: u16,
shuffle: bool,
repeat: RepeatState,
play_request_id: Option,
}
fn insert_attr(map: &mut DbusMap, attr: impl ToString, value: impl RefArg + 'static) {
map.insert(attr.to_string(), Variant(Box::new(value)));
}
impl CurrentStateInner {
fn mpris_volume(&self) -> f64 {
self.volume as f64 / u16::MAX as f64
}
fn get_position(&self) -> Option {
let position = self.position.as_ref()?;
match self.status {
PlaybackStatus::Playing => Some(position.get_position()),
PlaybackStatus::Paused => Some(position.last_position),
PlaybackStatus::Stopped => None,
}
}
fn update_position(&mut self, position: Duration) {
self.position
.get_or_insert_with(Position::new)
.update_position(position);
}
fn handle_event(&mut self, event: PlayerEvent) -> (DbusMap, bool) {
let mut changed = DbusMap::new();
let mut seeked = false;
// note that get_play_request_id is None on PlayRequestIdChanged
if Option::zip(self.play_request_id, event.get_play_request_id())
.is_some_and(|(cur_id, event_id)| cur_id != event_id)
{
debug!("discarding event due to play_request_id mismatch");
return (changed, seeked);
}
debug!("handling event {event:?}");
match event {
PlayerEvent::VolumeChanged { volume } => {
self.volume = volume;
insert_attr(&mut changed, "Volume", self.mpris_volume());
}
PlayerEvent::Stopped { .. } => {
self.status = PlaybackStatus::Stopped;
self.audio_item = None;
insert_attr(
&mut changed,
"PlaybackStatus",
self.status.to_mpris().to_string(),
);
insert_attr(&mut changed, "Metadata", self.to_metadata());
}
PlayerEvent::Playing { position_ms, .. } => {
if self.status != PlaybackStatus::Playing {
self.status = PlaybackStatus::Playing;
insert_attr(
&mut changed,
"PlaybackStatus",
self.status.to_mpris().to_string(),
);
}
self.update_position(Duration::milliseconds(position_ms as i64));
seeked = true;
}
PlayerEvent::Paused { position_ms, .. } => {
if self.status != PlaybackStatus::Paused {
self.status = PlaybackStatus::Paused;
insert_attr(
&mut changed,
"PlaybackStatus",
self.status.to_mpris().to_string(),
)
}
self.update_position(Duration::milliseconds(position_ms as i64));
seeked = true;
}
PlayerEvent::TrackChanged { audio_item } => {
self.audio_item = Some(audio_item);
insert_attr(&mut changed, "Metadata", self.to_metadata());
}
PlayerEvent::PositionCorrection { position_ms, .. }
| PlayerEvent::PositionChanged { position_ms, .. }
| PlayerEvent::Seeked { position_ms, .. } => {
self.update_position(Duration::milliseconds(position_ms as i64));
seeked = true;
}
PlayerEvent::ShuffleChanged { shuffle } => {
self.shuffle = shuffle;
insert_attr(&mut changed, "Shuffle", self.shuffle);
}
PlayerEvent::RepeatChanged { context, track } => {
self.repeat = (context, track).into();
insert_attr(
&mut changed,
"LoopStatus",
self.repeat.to_mpris().to_string(),
)
}
PlayerEvent::PlayRequestIdChanged { play_request_id } => {
self.play_request_id = Some(play_request_id);
}
PlayerEvent::Preloading { .. }
| PlayerEvent::Loading { .. }
| PlayerEvent::TimeToPreloadNextTrack { .. }
| PlayerEvent::EndOfTrack { .. }
| PlayerEvent::Unavailable { .. }
| PlayerEvent::AutoPlayChanged { .. }
| PlayerEvent::FilterExplicitContentChanged { .. }
| PlayerEvent::SessionConnected { .. }
| PlayerEvent::SessionDisconnected { .. }
| PlayerEvent::SessionClientChanged { .. } => (),
}
(changed, seeked)
}
fn to_metadata(&self) -> DbusMap {
let mut m = HashMap::new();
insert_attr(
&mut m,
"mpris:trackid",
uri_to_object_path(
self.audio_item
.as_deref()
.and_then(|item| item.track_id.to_uri().ok())
.as_deref(),
),
);
if let Some(audio_item) = self.audio_item.as_deref() {
if let Some(length) =
Duration::milliseconds(audio_item.duration_ms as i64).num_microseconds()
{
insert_attr(&mut m, "mpris:length", length);
}
if let Some(cover) = audio_item.covers.iter().max_by_key(|im| im.width) {
insert_attr(&mut m, "mpris:artUrl", cover.url.clone());
}
insert_attr(&mut m, "xesam:title", audio_item.name.clone());
use librespot_metadata::audio::UniqueFields::*;
match &audio_item.unique_fields {
Local {
artists,
album,
album_artists,
number,
disc_number,
path,
} => {
if let Some(artists) = artists {
insert_attr(&mut m, "xesam:artist", artists.clone());
}
if let Some(album) = album {
insert_attr(&mut m, "xesam:album", album.clone());
}
if let Some(album_artists) = album_artists {
insert_attr(&mut m, "xesam:albumArtist", album_artists.clone());
}
if let Some(number) = number {
insert_attr(&mut m, "xesam:trackNumber", *number);
}
if let Some(disc_number) = disc_number {
insert_attr(&mut m, "xesam:discNumber", *disc_number);
}
insert_attr(&mut m, "xesam:url", format!("file://{:?}", path));
}
Track {
artists,
album,
album_artists,
popularity,
number,
disc_number,
} => {
insert_attr(
&mut m,
"xesam:artist",
artists
.iter()
.map(|artist| artist.name.clone())
.collect::>(),
);
insert_attr(&mut m, "xesam:album", album.clone());
insert_attr(&mut m, "xesam:albumArtist", album_artists.clone());
insert_attr(&mut m, "xesam:autoRating", (*popularity as f64) / 100.0);
insert_attr(&mut m, "xesam:trackNumber", *number);
insert_attr(&mut m, "xesam:discNumber", *disc_number);
}
Episode {
description,
publish_time,
show_name,
} => {
insert_attr(&mut m, "xesam:artist", vec![show_name.clone()]);
insert_attr(&mut m, "xesam:comment", vec![description.clone()]);
if let Ok(formatted_publish) = publish_time.format(&Iso8601::DEFAULT) {
insert_attr(&mut m, "xesam:contentCreated", formatted_publish);
}
}
}
}
m
}
}
#[derive(Debug)]
struct CurrentState(RwLock);
#[derive(Clone, Copy, Debug, Error)]
#[error("internal state no longer available due to application error")]
struct StatePoisonError;
impl From for MethodErr {
fn from(value: StatePoisonError) -> Self {
MethodErr::failed(&value)
}
}
impl CurrentState {
fn new(inner: CurrentStateInner) -> Self {
Self(RwLock::new(inner))
}
fn read(&self) -> Result, StatePoisonError> {
self.0.read().map_err(|_| StatePoisonError)
}
fn write(
&self,
) -> Result, StatePoisonError> {
self.0.write().map_err(|_| StatePoisonError)
}
}
async fn create_dbus_server(
mut event_rx: UnboundedReceiver,
mut control_rx: UnboundedReceiver,
dbus_type: DBusType,
) -> Result<(), DbusError> {
let (resource, conn) = match dbus_type {
DBusType::Session => connection::new_session_sync(),
DBusType::System => connection::new_system_sync(),
}?;
let mut connection_task = tokio::spawn(async { Err::<(), _>(resource.await) });
// this name will be used, once we can provide the mpris interface
let mpris_name = format!(
"org.mpris.MediaPlayer2.spotifyd.instance{}",
std::process::id()
);
// this name will always be available to allow easy discovery of the controls interface
let spotifyd_name = format!("rs.spotifyd.instance{}", std::process::id());
conn.request_name(&spotifyd_name, false, true, true).await?;
let mut cr = Crossroads::new();
cr.set_async_support(Some((
conn.clone(),
Box::new(|x| {
tokio::spawn(x);
}),
)));
let current_state = Arc::new(CurrentState::new(CurrentStateInner {
status: PlaybackStatus::Stopped,
position: None,
audio_item: None,
volume: u16::MAX,
shuffle: false,
repeat: RepeatState::None,
play_request_id: None,
}));
let (quit_tx, mut quit_rx) = tokio::sync::mpsc::unbounded_channel();
let cr = Arc::new(Mutex::new(cr));
let crossroads = cr.clone();
conn.start_receive(
MatchRule::new_method_call(),
Box::new(move |msg, conn| {
tokio::task::block_in_place(|| {
let mut cr = cr.blocking_lock();
cr.handle_message(msg, conn).unwrap();
});
true
}),
);
let mut spirc: Option> = None;
let mut session: Option = None;
struct ConnectionData {
conn_id: String,
seeked_fn: SeekedSignal,
}
let mut cur_conn: Option = None;
loop {
tokio::select! {
_ = quit_rx.recv() => {
break;
}
result = &mut connection_task => {
result.expect("the dbus connection panicked")?;
break;
}
event = event_rx.recv() => {
let event = event.expect("event channel was unexpectedly closed");
if let PlayerEvent::SessionConnected { connection_id, .. } = event {
let mut cr = crossroads.lock().await;
let seeked_fn = register_player_interface(
&mut cr,
spirc.clone().unwrap(),
session.clone().unwrap(),
current_state.clone(),
quit_tx.clone(),
);
if cur_conn.is_none() {
conn.request_name(&mpris_name, true, true, true).await?;
}
cur_conn = Some(ConnectionData { conn_id: connection_id, seeked_fn });
} else if let PlayerEvent::SessionDisconnected { connection_id, .. } = event {
// if this message isn't outdated yet, we vanish from the bus
if cur_conn.as_ref().is_some_and(|d| d.conn_id == connection_id) {
let mut cr = crossroads.lock().await;
conn.release_name(&mpris_name).await?;
cr.remove::<()>(&MPRIS_PATH.into());
cur_conn = None;
}
} else {
let (changed, seeked) = current_state
.write()
.expect("state has been poisoned")
.handle_event(event);
if seeked {
let position = current_state
.read()
.expect("state has been poisoned")
.get_position();
if let Some((ConnectionData { seeked_fn, .. }, position)) =
Option::zip(cur_conn.as_ref(), position)
{
let msg = seeked_fn(
&MPRIS_PATH.into(),
&(position.num_microseconds().unwrap_or_default(),),
);
conn.send(msg).unwrap();
}
}
if !changed.is_empty() {
let msg = PropertiesPropertiesChanged {
interface_name: "org.mpris.MediaPlayer2.Player".to_owned(),
changed_properties: changed,
invalidated_properties: Vec::new(),
};
conn.send(
msg.to_emit_message(&dbus::Path::new(MPRIS_PATH).unwrap()),
)
.unwrap();
}
}
}
control = control_rx.recv() => {
let control = control.expect("control channel was unexpectedly closed");
match control {
ControlMessage::Shutdown => {
break;
},
ControlMessage::SetSession(new_spirc, new_session) => {
let mut cr = crossroads.lock().await;
register_controls_interface(&mut cr, new_spirc.clone());
spirc = Some(new_spirc);
session = Some(new_session);
}
ControlMessage::DropSession => {
let mut cr = crossroads.lock().await;
conn.release_name(&mpris_name).await?;
cr.remove::<()>(&MPRIS_PATH.into());
cr.remove::<()>(&CONTROLS_PATH.into());
spirc = None;
session = None;
cur_conn = None;
}
}
}
}
}
conn.release_name(&mpris_name).await?;
conn.release_name(&spotifyd_name).await?;
Ok(())
}
type SeekedSignal = Box dbus::Message + Send + Sync + 'static>;
fn register_player_interface(
cr: &mut Crossroads,
spirc: Arc,
session: Session,
current_state: Arc,
quit_tx: tokio::sync::mpsc::UnboundedSender<()>,
) -> SeekedSignal {
// The following methods and properties are part of the MediaPlayer2 interface.
// https://specifications.freedesktop.org/mpris-spec/latest/Media_Player.html
let media_player2_interface = cr.register("org.mpris.MediaPlayer2", move |b| {
let mut quit_tx = Some(quit_tx);
b.method("Raise", (), (), move |_, _, (): ()| {
// noop
Ok(())
});
b.method("Quit", (), (), move |_, _, (): ()| {
quit_tx.take().unwrap().send(()).ok();
Ok(())
});
b.property("CanQuit")
.emits_changed_const()
.get(|_, _| Ok(true));
b.property("CanRaise")
.emits_changed_const()
.get(|_, _| Ok(false));
b.property("CanSetFullscreen")
.emits_changed_const()
.get(|_, _| Ok(false));
b.property("HasTrackList")
.emits_changed_const()
.get(|_, _| Ok(false));
b.property("Identity")
.emits_changed_const()
.get(|_, _| Ok("Spotifyd".to_string()));
b.property("SupportedUriSchemes")
.emits_changed_const()
.get(|_, _| Ok(vec!["spotify".to_string()]));
b.property("SupportedMimeTypes")
.emits_changed_const()
.get(|_, _| Ok(Vec::::new()));
});
// The following methods and properties are part of the MediaPlayer2.Player interface.
// https://specifications.freedesktop.org/mpris-spec/latest/Player_Interface.html
let mut seeked_signal = None;
let player_interface: IfaceToken<()> = cr.register("org.mpris.MediaPlayer2.Player", |b| {
seeked_signal = Some(b.signal::<(i64,), _>("Seeked", ("Position",)).msg_fn());
let local_spirc = spirc.clone();
b.method("VolumeUp", (), (), move |_, _, (): ()| {
local_spirc.volume_up().map_err(|e| MethodErr::failed(&e))
})
.deprecated();
let local_spirc = spirc.clone();
b.method("VolumeDown", (), (), move |_, _, (): ()| {
local_spirc.volume_down().map_err(|e| MethodErr::failed(&e))
})
.deprecated();
let local_spirc = spirc.clone();
b.method("Next", (), (), move |_, _, (): ()| {
local_spirc.next().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("Previous", (), (), move |_, _, (): ()| {
local_spirc.prev().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("Pause", (), (), move |_, _, (): ()| {
local_spirc.pause().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("PlayPause", (), (), move |_, _, (): ()| {
warn!("PlayPause method called via mpris");
local_spirc.play_pause().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("Play", (), (), move |_, _, (): ()| {
warn!("Play method called via mpris");
local_spirc.play().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("Stop", (), (), move |_, _, (): ()| {
let pause_playback = false;
local_spirc
.disconnect(pause_playback)
.map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.method("Seek", ("offset",), (), move |_, _, (offset,): (i64,)| {
let Some(position) = local_state.read()?.get_position() else {
return Err(dbus::MethodErr::failed(
"cannot seek while playback is stopped",
));
};
let new_pos = position + Duration::microseconds(offset);
let new_pos_ms = u32::try_from(new_pos.num_milliseconds()).map_err(|err| {
dbus::MethodErr::invalid_arg(&format!("new position out of bounds: {err}"))
})?;
if let Err(err) = local_spirc.set_position_ms(new_pos_ms) {
warn!("failed to seek by {offset}ms: {err}");
return Err(dbus::MethodErr::failed(&err));
}
Ok(())
});
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.method(
"SetPosition",
("track_id", "position"),
(),
move |_, _, (track_id, pos): (dbus::Path, i64)| {
let Some((current_track_id, duration)) = local_state
.read()?
.audio_item
.as_ref()
.map(|item| (item.track_id.clone(), item.duration_ms))
else {
return Err(dbus::MethodErr::failed(
"can set position while nothing is playing",
));
};
let duration = Duration::milliseconds(duration.into());
if !track_id.ends_with(¤t_track_id.to_id().unwrap()) {
// as per mpris spec: ignore as stale
return Ok(());
}
let new_position = Duration::microseconds(pos);
if new_position < Duration::zero() || new_position > duration {
// ignore as per spec
return Ok(());
}
if let Err(err) =
local_spirc.set_position_ms(new_position.num_milliseconds() as u32)
{
return Err(dbus::MethodErr::failed(&err));
}
Ok(())
},
);
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.method("OpenUri", ("uri",), (), move |_, _, (uri,): (String,)| {
let uri = SpotifyUri::from_uri(uri.as_str()).map_err(|e| MethodErr::invalid_arg(&e))?;
let CurrentStateInner {
shuffle, repeat, ..
} = *local_state.read()?;
let session = session.clone();
let (playing_track_index, context_uri) = Handle::current()
.block_on(async move {
use librespot_metadata::*;
Ok::<_, librespot_core::Error>(match uri {
SpotifyUri::Track { .. } => {
let track = Track::get(&session, &uri).await?;
if track.number == 0 {
warn!("track.number is not expected to be 0- but 1-indexed");
}
((track.number - 1).max(0) as u32, track.album.id.to_uri()?)
}
SpotifyUri::Album { .. }
| SpotifyUri::Artist { .. }
| SpotifyUri::Playlist { .. }
| SpotifyUri::Episode { .. }
| SpotifyUri::Show { .. } => (0, uri.to_uri()?),
SpotifyUri::Local { .. } | SpotifyUri::Unknown { .. } => {
return Err(librespot_core::Error::unimplemented(
"this type of uri is not supported",
));
}
})
})
.map_err(|e| MethodErr::failed(&e))?;
warn!(
"loading context_uri {context_uri} with playing_track_index {playing_track_index}"
);
local_spirc
.load(LoadRequest::from_context_uri(
context_uri,
LoadRequestOptions {
start_playing: true,
seek_to: 0,
context_options: Some(LoadContextOptions::Options(
librespot_connect::Options {
shuffle,
repeat: repeat.repeat_context(),
repeat_track: repeat.repeat_track(),
},
)),
playing_track: Some(librespot_connect::PlayingTrack::Index(
playing_track_index,
)),
},
))
.map_err(|e| MethodErr::failed(&e))
});
let local_state = current_state.clone();
b.property("PlaybackStatus")
.emits_changed_false()
.get(move |_, _| {
let playback_state = local_state.read()?.status;
Ok(playback_state.to_mpris().to_string())
});
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.property("Shuffle")
.emits_changed_false()
.get(move |_, _| Ok(local_state.read()?.shuffle))
.set(move |_, _, value| {
local_spirc
.shuffle(value)
.map(|_| None)
.map_err(|err| dbus::MethodErr::failed(&err))
});
b.property("Rate").emits_changed_const().get(|_, _| Ok(1.0));
b.property("MaximumRate")
.emits_changed_const()
.get(|_, _| Ok(1.0));
b.property("MinimumRate")
.emits_changed_const()
.get(|_, _| Ok(1.0));
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.property("Volume")
.emits_changed_false()
.get(move |_, _| Ok(local_state.read()?.mpris_volume()))
.set(move |_, _, value| {
if let Err(err) = local_spirc.set_volume((value * u16::MAX as f64) as u16) {
return Err(dbus::MethodErr::failed(&err));
}
Ok(None)
});
let local_spirc = spirc.clone();
let local_state = current_state.clone();
b.property("LoopStatus")
.emits_changed_true()
.get(move |_, _| {
let repeat = local_state.read()?.repeat;
Ok(repeat.to_mpris().to_string())
})
.set(move |_, _, value| {
let repeat = match value.as_str() {
"None" => RepeatState::None,
"Playlist" => RepeatState::All,
"Track" => RepeatState::Track,
mode => {
return Err(dbus::MethodErr::failed(&format!(
"unsupported repeat mode: {mode}"
)));
}
};
local_spirc
.repeat(repeat.repeat_context())
.map_err(|e| MethodErr::failed(&e))?;
local_spirc
.repeat_track(repeat.repeat_track())
.map_err(|e| MethodErr::failed(&e))?;
Ok(None)
});
let local_state = current_state.clone();
b.property("Position")
.emits_changed_false()
.get(move |_, _| {
let Some(position) = local_state.read()?.get_position() else {
return Err(dbus::MethodErr::failed("no position available currently"));
};
Ok(position.num_microseconds().unwrap_or_default())
});
let local_state = current_state.clone();
b.property("Metadata")
.emits_changed_false()
.get(move |_, _| Ok(local_state.read()?.to_metadata()));
for prop in [
"CanPlay",
"CanPause",
"CanSeek",
"CanControl",
"CanGoPrevious",
"CanGoNext",
] {
b.property(prop).emits_changed_const().get(|_, _| Ok(true));
}
});
cr.insert(MPRIS_PATH, &[media_player2_interface, player_interface], ());
seeked_signal.expect("player interface has not been registered")
}
fn register_controls_interface(cr: &mut Crossroads, spirc: Arc) {
let spotifyd_ctrls_interface: IfaceToken<()> = cr.register("rs.spotifyd.Controls", |b| {
let local_spirc = spirc.clone();
b.method("VolumeUp", (), (), move |_, _, (): ()| {
local_spirc.volume_up().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("VolumeDown", (), (), move |_, _, (): ()| {
local_spirc.volume_down().map_err(|e| MethodErr::failed(&e))
});
let local_spirc = spirc.clone();
b.method("TransferPlayback", (), (), move |_, _, (): ()| {
local_spirc.activate().map_err(|e| MethodErr::failed(&e))
});
});
cr.insert(CONTROLS_PATH, &[spotifyd_ctrls_interface], ());
}
fn uri_to_object_path(uri: Option<&str>) -> dbus::Path<'static> {
let Some(uri) = uri else {
return dbus::Path::new("/org/mpris/MediaPlayer2/TrackList/NoTrack").unwrap();
};
let mut path = String::with_capacity(uri.len() + 1);
for element in uri.split(':') {
path.push('/');
path.push_str(element);
}
dbus::Path::new(path).unwrap()
}
================================================
FILE: src/error.rs
================================================
use std::fmt::{self, Display};
/// This crate's error type.
#[derive(Debug)]
pub(crate) struct Error {
kind: ErrorKind,
}
impl Error {
pub(crate) fn subprocess(shell: &str, cmd: &str) -> Self {
Self {
kind: ErrorKind::Subprocess {
cmd: cmd.into(),
msg: Message::None,
shell: shell.into(),
},
}
}
pub(crate) fn subprocess_with_err(shell: &str, cmd: &str, e: E) -> Self
where
E: std::error::Error + 'static,
{
Self {
kind: ErrorKind::Subprocess {
cmd: cmd.into(),
msg: Message::Error(Box::new(e)),
shell: shell.into(),
},
}
}
pub(crate) fn subprocess_with_str(shell: &str, cmd: &str, s: &str) -> Self {
Self {
kind: ErrorKind::Subprocess {
cmd: cmd.into(),
msg: Message::String(s.into()),
shell: shell.into(),
},
}
}
}
impl From for Error {
fn from(kind: ErrorKind) -> Self {
Self { kind }
}
}
impl Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.kind)
}
}
impl std::error::Error for Error {}
/// This crate's error kind type.
#[derive(Debug)]
pub(crate) enum ErrorKind {
Subprocess {
cmd: String,
msg: Message,
shell: String,
},
#[allow(unused)]
NormalisationPregainInvalid,
}
impl Display for ErrorKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ErrorKind::Subprocess { cmd, msg, shell } => match msg {
Message::None => write!(f, "Failed to execute {cmd} using {shell}."),
Message::Error(e) => {
write!(f, "Failed to execute {cmd} using {shell}. Error: {e}",)
}
Message::String(s) => {
write!(f, "Failed to execute {cmd} using {shell}. Error: {s}",)
}
},
ErrorKind::NormalisationPregainInvalid => write!(
f,
"normalisation-pregain must be a valid 32-bit floating point number."
),
}
}
}
#[derive(Debug)]
pub(crate) enum Message {
None,
String(String),
Error(Box),
}
================================================
FILE: src/main.rs
================================================
use crate::config::CliConfig;
use clap::Parser;
#[cfg(unix)]
use color_eyre::eyre::eyre;
use color_eyre::eyre::{self, Context};
use config::ExecutionMode;
#[cfg(unix)]
use daemonize::Daemonize;
use fern::colors::ColoredLevelConfig;
use log::{LevelFilter, info, trace};
use oauth::run_oauth;
#[cfg(target_os = "openbsd")]
use pledge::pledge;
#[cfg(windows)]
use std::fs;
use tokio::runtime::Runtime;
#[cfg(feature = "alsa_backend")]
mod alsa_mixer;
mod config;
#[cfg(feature = "dbus_mpris")]
mod dbus_mpris;
mod error;
mod main_loop;
mod no_mixer;
mod oauth;
mod process;
mod setup;
mod utils;
enum LogTarget {
Terminal,
Syslog,
}
fn setup_logger(log_target: LogTarget, verbose: u8) -> eyre::Result<()> {
let log_level = match verbose {
0 => LevelFilter::Info,
1 => LevelFilter::Debug,
2.. => LevelFilter::Trace,
};
let mut logger = fern::Dispatch::new().level(log_level);
if verbose == 0 {
logger = logger.level_for("symphonia_format_ogg::demuxer", LevelFilter::Warn);
}
let logger = match log_target {
LogTarget::Terminal => {
let colors = ColoredLevelConfig::new();
logger
.format(move |out, message, record| {
let target = if verbose > 0 {
&format!(" {}", record.target())
} else {
""
};
out.finish(format_args!(
"[{}{}] {}",
colors.color(record.level()),
target,
message
))
})
.chain(std::io::stdout())
}
#[cfg(unix)]
LogTarget::Syslog => {
let log_format = syslog::Formatter3164 {
facility: syslog::Facility::LOG_DAEMON,
hostname: None,
process: "spotifyd".to_owned(),
pid: std::process::id(),
};
logger.chain(
syslog::unix(log_format)
.map_err(|e| eyre!("Couldn't connect to syslog instance: {}", e))?,
)
}
#[cfg(target_os = "windows")]
LogTarget::Syslog => {
let dirs = directories::BaseDirs::new().unwrap();
let mut log_file = dirs.data_local_dir().to_path_buf();
log_file.push("spotifyd");
log_file.push(".spotifyd.log");
if let Some(p) = log_file.parent() {
fs::create_dir_all(p)?
};
logger.chain(
fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.open(log_file)
.expect("Couldn't initialize logger"),
)
}
};
logger.apply().wrap_err("Couldn't initialize logger")
}
fn main() -> eyre::Result<()> {
// Start with superset of all potentially required promises.
// Drop later after CLI arguments and configuration files were parsed.
#[cfg(target_os = "openbsd")]
pledge(
"stdio rpath wpath cpath inet mcast flock chown unix dns proc exec audio",
None,
)
.unwrap();
color_eyre::install().wrap_err("Couldn't initialize error reporting")?;
let cli_config = CliConfig::parse();
match cli_config.mode {
None => run_daemon(cli_config),
Some(ExecutionMode::Authenticate { oauth_port }) => run_oauth(cli_config, oauth_port),
}
}
fn run_daemon(mut cli_config: CliConfig) -> eyre::Result<()> {
let is_daemon = !cli_config.no_daemon;
let log_target = if is_daemon {
#[cfg(unix)]
{
LogTarget::Syslog
}
#[cfg(target_os = "windows")]
{
LogTarget::Terminal
}
} else {
#[cfg(unix)]
{
LogTarget::Terminal
}
#[cfg(target_os = "windows")]
{
if std::env::var("SPOTIFYD_CHILD").is_ok() {
LogTarget::Syslog
} else {
LogTarget::Terminal
}
}
};
setup_logger(log_target, cli_config.verbose)?;
cli_config
.load_config_file_values()
.wrap_err("could not load the config file")?;
trace!("{:?}", &cli_config);
// Returns the old SpotifydConfig struct used within the rest of the daemon.
let internal_config = config::get_internal_config(cli_config);
if is_daemon {
info!("Daemonizing running instance");
#[cfg(unix)]
{
let mut daemonize = Daemonize::new();
if let Some(pid) = internal_config.pid.as_ref() {
daemonize = daemonize.pid_file(pid);
}
match daemonize.start() {
Ok(_) => info!("Detached from shell, now running in background."),
Err(e) => return Err(e).wrap_err("something went wrong while daemonizing"),
};
}
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
use std::process::{Command, exit};
let mut args = std::env::args().collect::>();
args.remove(0);
args.push("--no-daemon".to_string());
Command::new(std::env::current_exe().unwrap())
.args(args)
.env("SPOTIFYD_CHILD", "1")
.creation_flags(8 /* DETACHED_PROCESS */)
.spawn()
.expect("Couldn't spawn daemon");
exit(0);
}
}
#[cfg(target_os = "openbsd")]
{
// At this point:
// * --username-cmd, --password-cmd were handled
// > no "proc exec"
// * --pid, daemon(3) were handled
// > no "cpath flock chown" for PID file
// > no "proc" for double-fork(2)
//
// Required runtime promises:
// stdout/err, syslog(3) "stdio"
// ${TMPDIR}/.tmp*, cache "[rwc]path"
// Spotify API/Connect "inet dns"
// D-Bus, MPRIS "unix"
// Zeroconf Discovery "mcast"
// PortAudio, sio_open(3) ("[rwc]path unix inet audio")
// > after sndio(7) cookie "audio"
// --on-song-change-hook aka. "onevent", run via --shell aka. "shell"
if internal_config.onevent.is_some() {
pledge(
"stdio rpath wpath cpath inet mcast unix dns proc exec audio",
None,
)
.unwrap();
} else {
pledge("stdio rpath wpath cpath inet mcast unix dns audio", None).unwrap();
}
}
let runtime = Runtime::new().unwrap();
runtime.block_on(async {
let initial_state = setup::initial_state(internal_config)?;
initial_state.run().await
})
}
================================================
FILE: src/main_loop.rs
================================================
#[cfg(feature = "dbus_mpris")]
use crate::config::{DBusType, MprisConfig};
#[cfg(feature = "dbus_mpris")]
use crate::dbus_mpris::DbusServer;
use crate::process::spawn_program_on_event;
use crate::utils::Backoff;
use color_eyre::eyre::{self, Context};
use futures::future::Either;
#[cfg(not(feature = "dbus_mpris"))]
use futures::future::Pending;
use futures::{
self, Future, FutureExt, StreamExt,
future::{self, Fuse, FusedFuture},
stream::Peekable,
};
use librespot_connect::{ConnectConfig, Spirc};
use librespot_core::{
Error, SessionConfig, authentication::Credentials, cache::Cache, config::DeviceType,
session::Session,
};
use librespot_discovery::Discovery;
use librespot_playback::{
audio_backend::Sink,
config::{AudioFormat, PlayerConfig},
mixer::Mixer,
player::Player,
};
use log::{error, info};
use std::pin::Pin;
use std::sync::Arc;
#[cfg(not(feature = "dbus_mpris"))]
type DbusServer = Pending<()>;
pub(crate) enum CredentialsProvider {
Discovery {
stream: Peekable,
last_credentials: Option,
},
CredentialsOnly(Credentials),
}
impl CredentialsProvider {
async fn get_credentials(&mut self) -> Credentials {
match self {
CredentialsProvider::Discovery {
stream,
last_credentials,
} => {
let new_creds = match last_credentials.take() {
Some(creds) => stream.next().now_or_never().flatten().unwrap_or(creds),
None => stream.next().await.unwrap(),
};
*last_credentials = Some(new_creds.clone());
new_creds
}
CredentialsProvider::CredentialsOnly(creds) => creds.clone(),
}
}
// wait for an incoming connection if the underlying provider is a discovery stream
async fn incoming_connection(&mut self) {
match self {
CredentialsProvider::Discovery { stream, .. } => {
let peeked = Pin::new(stream).peek().await;
if peeked.is_none() {
future::pending().await
}
}
_ => future::pending().await,
}
}
}
pub(crate) struct MainLoop {
pub(crate) session_config: SessionConfig,
pub(crate) player_config: PlayerConfig,
pub(crate) cache: Option,
pub(crate) mixer: Arc,
pub(crate) backend: fn(Option, AudioFormat) -> Box,
pub(crate) audio_device: Option,
pub(crate) audio_format: AudioFormat,
pub(crate) disable_volume: bool,
pub(crate) initial_volume: u16,
pub(crate) shell: String,
pub(crate) device_type: DeviceType,
pub(crate) device_name: String,
pub(crate) player_event_program: Option,
pub(crate) credentials_provider: CredentialsProvider,
#[cfg(feature = "dbus_mpris")]
pub(crate) mpris_config: MprisConfig,
}
struct ConnectionInfo> {
spirc: Spirc,
#[cfg_attr(not(feature = "dbus_mpris"), expect(unused))]
session: Session,
player: Arc,
spirc_task: SpircTask,
}
impl MainLoop {
async fn get_connection(
&mut self,
) -> Result + use<>>, Error> {
let creds = self.credentials_provider.get_credentials().await;
let mut connection_backoff = Backoff::default();
loop {
let session = Session::new(self.session_config.clone(), self.cache.clone());
let player = {
let audio_device = self.audio_device.clone();
let audio_format = self.audio_format;
let backend = self.backend;
Player::new(
self.player_config.clone(),
session.clone(),
self.mixer.get_soft_volume(),
move || backend(audio_device, audio_format),
)
};
// TODO: expose is_group
match Spirc::new(
ConnectConfig {
name: self.device_name.clone(),
device_type: self.device_type,
initial_volume: self.initial_volume,
disable_volume: self.disable_volume,
..ConnectConfig::default()
},
session.clone(),
creds.clone(),
player.clone(),
self.mixer.clone(),
)
.await
{
Ok((spirc, spirc_task)) => {
break Ok(ConnectionInfo {
spirc,
session,
player,
spirc_task,
});
}
Err(err) => {
let Ok(backoff) = connection_backoff.next_backoff() else {
break Err(err);
};
error!("connection to spotify failed: {err}");
info!(
"retrying connection in {} seconds (retry {}/{})",
backoff.as_secs(),
connection_backoff.retries(),
connection_backoff.max_retries()
);
tokio::time::sleep(backoff).await;
}
}
}
}
pub(crate) async fn run(mut self) -> eyre::Result<()> {
tokio::pin! {
let ctrl_c = tokio::signal::ctrl_c();
// we don't necessarily have a dbus server
let dbus_server = Either::::Right(future::pending());
}
#[cfg(feature = "dbus_mpris")]
let mpris_event_tx = if self.mpris_config.use_mpris.unwrap_or(true) {
let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
*dbus_server.as_mut() = Either::Left(DbusServer::new(
rx,
self.mpris_config.dbus_type.unwrap_or(DBusType::Session),
));
Some(tx)
} else {
None
};
let mainloop_result: eyre::Result<()> = 'mainloop: loop {
let connection = tokio::select!(
_ = &mut ctrl_c => {
break 'mainloop Ok(());
}
connection = self.get_connection() => {
match connection {
Ok(connection) => connection,
Err(err) => break 'mainloop Err(err).wrap_err("failed to connect to spotify"),
}
}
);
let spirc_task = connection.spirc_task;
tokio::pin!(spirc_task);
let shared_spirc = Arc::new(connection.spirc);
#[cfg(feature = "dbus_mpris")]
if let Either::Left(mut dbus_server) = Either::as_pin_mut(dbus_server.as_mut())
&& let Err(err) = dbus_server
.as_mut()
.set_session(shared_spirc.clone(), connection.session)
{
let _ = shared_spirc.shutdown();
let _ = (&mut spirc_task).await;
break 'mainloop Err(err).wrap_err("failed to configure dbus server");
}
let mut running_event_program = Box::pin(Fuse::terminated());
let mut event_channel = connection.player.get_player_event_channel();
loop {
tokio::select!(
// a new session has been started via the discovery stream
_ = self.credentials_provider.incoming_connection() => {
let _ = shared_spirc.shutdown();
let _ = (&mut spirc_task).await;
break;
}
// the program should shut down
_ = &mut ctrl_c => {
let _ = shared_spirc.shutdown();
let _ = (&mut spirc_task).await;
break 'mainloop Ok(());
}
// spirc was shut down by some external factor
_ = &mut spirc_task => {
break;
}
// dbus stopped unexpectedly
result = &mut dbus_server => {
#[cfg(feature = "dbus_mpris")]
{
let _ = shared_spirc.shutdown();
let _ = (&mut spirc_task).await;
*dbus_server.as_mut() = Either::Right(future::pending());
break 'mainloop result.wrap_err("DBus terminated unexpectedly");
}
#[cfg(not(feature = "dbus_mpris"))]
result // unused variable
}
// a new player event is available and no program is running
event = event_channel.recv(), if running_event_program.is_terminated() => {
let event = event.unwrap();
#[cfg(feature = "dbus_mpris")]
if let Some(ref tx) = mpris_event_tx {
tx.send(event.clone()).unwrap();
}
if let Some(ref cmd) = self.player_event_program {
match spawn_program_on_event(&self.shell, cmd, event) {
Ok(child) => running_event_program = Box::pin(child.wait().fuse()),
Err(e) => error!("{}", e),
}
}
}
// a running program has finished
result = &mut running_event_program, if !running_event_program.is_terminated() => {
match result {
// Exited without error...
Ok(_) => (),
// Exited with error...
Err(e) => error!("{}", e),
}
}
)
}
#[cfg(feature = "dbus_mpris")]
if let Either::Left(dbus_server) = Either::as_pin_mut(dbus_server.as_mut())
&& let Err(err) = dbus_server.drop_session()
{
break 'mainloop Err(err).wrap_err("failed to reconfigure DBus server");
}
};
if let CredentialsProvider::Discovery { stream, .. } = self.credentials_provider {
let _ = stream.into_inner().shutdown().await;
}
#[cfg(feature = "dbus_mpris")]
if let Either::Left(dbus_server) = Either::as_pin_mut(dbus_server.as_mut())
&& dbus_server.shutdown()
&& let Err(err) = dbus_server.await
{
let err = Err(err).wrap_err("failed to shutdown DBus server");
if mainloop_result.is_ok() {
return err;
} else {
error!("additional error while shutting down: {err:?}");
}
}
mainloop_result
}
}
================================================
FILE: src/no_mixer.rs
================================================
use librespot_playback::mixer::{Mixer, MixerConfig};
pub struct NoMixer;
impl Mixer for NoMixer {
fn open(_: MixerConfig) -> Result {
Ok(NoMixer {})
}
fn volume(&self) -> u16 {
u16::MAX
}
fn set_volume(&self, _volume: u16) {}
}
================================================
FILE: src/oauth.rs
================================================
use color_eyre::{
Section as _,
eyre::{self, Context as _},
};
use librespot_core::SessionConfig;
use librespot_core::{Session, authentication::Credentials};
use librespot_oauth::OAuthClientBuilder;
use log::info;
use tokio::runtime::Runtime;
use crate::{LogTarget, config::CliConfig, setup_logger};
pub(crate) fn run_oauth(mut cli_config: CliConfig, oauth_port: u16) -> eyre::Result<()> {
setup_logger(LogTarget::Terminal, cli_config.verbose)?;
cli_config
.load_config_file_values()
.wrap_err("failed to read config file")?;
let cache = cli_config
.shared_config
.get_cache(true)
.with_note(|| "The result of the authentication needs to be cached to be usable later.")?;
const OAUTH_SCOPES: &[&str] = &[
"app-remote-control",
"playlist-modify",
"playlist-modify-private",
"playlist-modify-public",
"playlist-read",
"playlist-read-collaborative",
"playlist-read-private",
"streaming",
"ugc-image-upload",
"user-follow-modify",
"user-follow-read",
"user-library-modify",
"user-library-read",
"user-modify",
"user-modify-playback-state",
"user-modify-private",
"user-personalized",
"user-read-birthdate",
"user-read-currently-playing",
"user-read-email",
"user-read-play-history",
"user-read-playback-position",
"user-read-playback-state",
"user-read-private",
"user-read-recently-played",
"user-top-read",
];
let session_config = SessionConfig {
proxy: cli_config.shared_config.proxy_url(),
..Default::default()
};
let oauth_client = OAuthClientBuilder::new(
&session_config.client_id,
&format!("http://127.0.0.1:{oauth_port}/login"),
OAUTH_SCOPES.to_vec(),
)
.with_custom_message(r#"Authentication successful! You can now return to spotifyd.
"#)
.open_in_browser()
.build()
.wrap_err("client creation failed")?;
Runtime::new().unwrap().block_on(async move {
let token = oauth_client.get_access_token_async().await?;
let creds = Credentials::with_access_token(token.access_token);
let session = Session::new(session_config, Some(cache));
session.connect(creds, true).await
})?;
info!("\nLogin successful! You are now ready to run spotifyd.");
Ok(())
}
================================================
FILE: src/process.rs
================================================
use crate::error::Error;
use librespot_metadata::audio::AudioItem;
use librespot_playback::player::PlayerEvent;
use log::info;
use std::{collections::HashMap, process::Stdio};
use tokio::{
io::{self, AsyncWriteExt},
process::{self, Command},
};
/// Spawns provided command in a subprocess using the provided shell.
fn spawn_program(shell: &str, cmd: &str, env: HashMap<&str, String>) -> Result {
info!(
"Running {:?} using {:?} with environment variables {:?}",
cmd, shell, env
);
let inner = Command::new(shell)
.arg("-c")
.arg(cmd)
.envs(env.iter())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| Error::subprocess_with_err(shell, cmd, e))?;
let child = Child::new(cmd.to_string(), inner, shell.to_string());
Ok(child)
}
fn audio_item_to_env(audio_item: Box, env: &mut HashMap<&str, String>) {
env.insert("TRACK_ID", audio_item.track_id.to_id().unwrap_or_default());
env.insert("TRACK_NAME", audio_item.name);
env.insert("TRACK_DURATION", audio_item.duration_ms.to_string());
if let Some(cover) = audio_item.covers.into_iter().max_by_key(|c| c.width) {
env.insert("TRACK_COVER", cover.url);
}
}
/// Spawns provided command in a subprocess using the provided shell.
/// Various environment variables are included in the subprocess's environment
/// depending on the `PlayerEvent` that was passed in.
pub(crate) fn spawn_program_on_event(
shell: &str,
cmd: &str,
event: PlayerEvent,
) -> Result {
let mut env = HashMap::new();
match event {
PlayerEvent::TrackChanged { audio_item } => {
env.insert("PLAYER_EVENT", "change".to_string());
audio_item_to_env(audio_item, &mut env);
}
PlayerEvent::Playing {
track_id,
play_request_id,
position_ms,
} => {
env.insert("PLAYER_EVENT", "start".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
env.insert("POSITION_MS", position_ms.to_string());
}
PlayerEvent::Stopped {
track_id,
play_request_id,
} => {
env.insert("PLAYER_EVENT", "stop".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::Loading {
track_id,
play_request_id,
position_ms,
} => {
env.insert("PLAYER_EVENT", "load".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
env.insert("POSITION_MS", position_ms.to_string());
}
PlayerEvent::Paused {
track_id,
play_request_id,
position_ms,
} => {
env.insert("PLAYER_EVENT", "pause".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
env.insert("POSITION_MS", position_ms.to_string());
}
PlayerEvent::TimeToPreloadNextTrack {
track_id,
play_request_id,
} => {
env.insert("PLAYER_EVENT", "preload".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::EndOfTrack {
track_id,
play_request_id,
} => {
env.insert("PLAYER_EVENT", "endoftrack".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::VolumeChanged { volume } => {
env.insert("PLAYER_EVENT", "volumeset".to_string());
env.insert("VOLUME", volume.to_string());
}
PlayerEvent::Unavailable {
play_request_id,
track_id,
} => {
env.insert("PLAYER_EVENT", "unavailable".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::Preloading { track_id } => {
env.insert("PLAYER_EVENT", "preloading".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
}
PlayerEvent::PositionCorrection {
play_request_id,
track_id,
position_ms,
} => {
env.insert("PLAYER_EVENT", "positioncorrection".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("POSITION_MS", position_ms.to_string());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::Seeked {
play_request_id,
track_id,
position_ms,
} => {
env.insert("PLAYER_EVENT", "seeked".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("POSITION_MS", position_ms.to_string());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::PlayRequestIdChanged { play_request_id } => {
env.insert("PLAYER_EVENT", "playrequestid_changed".to_string());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
PlayerEvent::SessionConnected {
connection_id,
user_name,
} => {
env.insert("PLAYER_EVENT", "sessionconnected".to_string());
env.insert("USERNAME", user_name);
env.insert("CONNECTION_ID", connection_id);
}
PlayerEvent::SessionDisconnected {
connection_id,
user_name,
} => {
env.insert("PLAYER_EVENT", "sessiondisconnected".to_string());
env.insert("USERNAME", user_name);
env.insert("CONNECTION_ID", connection_id);
}
PlayerEvent::SessionClientChanged {
client_id,
client_name,
client_brand_name,
client_model_name,
} => {
env.insert("PLAYER_EVENT", "clientchanged".to_string());
env.insert("CLIENT_ID", client_id);
env.insert("CLIENT_NAME", client_name);
env.insert("CLIENT_BRAND", client_brand_name);
env.insert("CLIENT_MODEL", client_model_name);
}
PlayerEvent::ShuffleChanged { shuffle } => {
env.insert("PLAYER_EVENT", "shuffle_changed".to_string());
env.insert("SHUFFLE", shuffle.to_string());
}
PlayerEvent::RepeatChanged { context, track } => {
env.insert("PLAYER_EVENT", "repeat_changed".to_string());
let val = match context {
true => match track {
true => "track",
false => "all",
},
false => "none",
}
.to_string();
env.insert("REPEAT", val);
}
PlayerEvent::AutoPlayChanged { auto_play } => {
env.insert("PLAYER_EVENT", "autoplay_changed".to_string());
env.insert("AUTOPLAY", auto_play.to_string());
}
PlayerEvent::FilterExplicitContentChanged { filter } => {
env.insert("PLAYER_EVENT", "filterexplicit_changed".to_string());
env.insert("FILTEREXPLICIT", filter.to_string());
}
PlayerEvent::PositionChanged {
play_request_id,
position_ms,
track_id,
} => {
env.insert("PLAYER_EVENT", "position_changed".to_string());
env.insert("TRACK_ID", track_id.to_id().unwrap());
env.insert("POSITION_MS", position_ms.to_string());
env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
}
}
spawn_program(shell, cmd, env)
}
/// Wraps `tokio::process::Child` so that when this `Child` exits:
/// * successfully: It writes the contents of it's stdout to the stdout of the
/// main process.
/// * unsuccesfully: It returns an error that includes the contents it's stderr
/// as well as information on the command that was run and the shell that
/// invoked it.
pub(crate) struct Child {
cmd: String,
child: process::Child,
shell: String,
}
impl Child {
pub(crate) fn new(cmd: String, child: process::Child, shell: String) -> Self {
Self { cmd, child, shell }
}
pub(crate) async fn wait(self) -> Result<(), Error> {
let Child { cmd, shell, child } = self;
let output = child
.wait_with_output()
.await
.map_err(|e| Error::subprocess_with_err(&shell, &cmd, e))?;
if output.status.success() {
// If successful, write subprocess's stdout to main process's stdout...
let mut stdout = io::stdout();
stdout
.write_all(&output.stdout)
.await
.map_err(|e| Error::subprocess_with_err(&shell, &cmd, e))?;
stdout
.flush()
.await
.map_err(|e| Error::subprocess_with_err(&shell, &cmd, e))?;
Ok(())
} else {
// If unsuccessful, return an error that includes the contents of stderr...
let err = match String::from_utf8(output.stderr) {
Ok(stderr) => Error::subprocess_with_str(&shell, &cmd, &stderr),
Err(_) => Error::subprocess(&shell, &cmd),
};
Err(err)
}
}
}
================================================
FILE: src/setup.rs
================================================
#[cfg(feature = "alsa_backend")]
use crate::alsa_mixer;
use crate::{
config,
main_loop::{self, CredentialsProvider},
utils::Backoff,
};
use color_eyre::{Section, eyre::eyre};
use futures::StreamExt as _;
use librespot_playback::{
audio_backend::{self},
mixer::{self, Mixer, MixerConfig},
};
use log::{debug, error, info};
use std::{sync::Arc, thread};
pub(crate) fn initial_state(
config: config::SpotifydConfig,
) -> color_eyre::Result {
let mixer: Arc = {
match config.volume_controller {
config::VolumeController::None => {
info!("Using no volume controller.");
Arc::new(crate::no_mixer::NoMixer)
}
#[cfg(feature = "alsa_backend")]
config::VolumeController::Alsa | config::VolumeController::AlsaLinear => {
let device = config
.alsa_config
.mixer
.as_deref()
.or(config.audio_device.as_deref())
.unwrap_or("default")
.to_string();
let control = config
.alsa_config
.control
.as_deref()
.unwrap_or("Master")
.to_string();
info!("Using alsa volume controller.");
use librespot_playback::config::VolumeCtrl;
let volume_ctrl = if matches!(
config.volume_controller,
config::VolumeController::AlsaLinear
) {
VolumeCtrl::Linear
} else {
VolumeCtrl::Log(0.0) /* this value is ignored */
};
Arc::new(alsa_mixer::AlsaMixer::open(MixerConfig {
device,
control,
index: 0,
volume_ctrl,
}).with_suggestion(|| {
match alsa_mixer::get_available_controls() {
Err(err) => format!("there are no controls available, maybe check that alsa is available: {err}"),
Ok(controls) => {
format!("maybe try one of the following as 'mixer':{}", controls.filter_map(|hint| hint.name.map(|name| format!("\n- {name}"))).collect::())
}
}
})?)
}
_ => {
info!("Using software volume controller.");
let mixer = mixer::softmixer::SoftMixer::open(MixerConfig::default())
.expect("SoftMixer::open never returns an Error");
Arc::new(mixer)
}
}
};
let player_config = config.player_config;
let session_config = config.session_config;
let backend = config.backend.clone();
let zeroconf_port = config.zeroconf_port.unwrap_or(0);
let creds = if let Some(creds) = config.oauth_cache.as_ref().and_then(|c| c.credentials()) {
info!(
"Login via OAuth as user {}.",
creds.username.as_deref().unwrap_or("unknown")
);
Some(creds)
} else if let Some(creds) = config.cache.as_ref().and_then(|c| c.credentials()) {
info!(
"Restoring previous login as user {}.",
creds.username.as_deref().unwrap_or("unknown")
);
Some(creds)
} else {
None
};
let discovery = if config.discovery {
info!("Starting zeroconf server to advertise on local network.");
debug!("Using device id '{}'", session_config.device_id);
let mut retry_backoff = Backoff::default();
loop {
match librespot_discovery::Discovery::builder(
session_config.device_id.clone(),
session_config.client_id.clone(),
)
.name(config.device_name.clone())
.device_type(config.device_type)
.port(zeroconf_port)
.launch()
{
Ok(discovery_stream) => break Some(discovery_stream),
Err(err) => {
error!("failed to enable discovery: {err}");
let Ok(backoff) = retry_backoff.next_backoff() else {
error!("maximum amount of retries exceeded");
break None;
};
info!("retrying discovery in {} seconds", backoff.as_secs());
thread::sleep(backoff);
info!(
"trying to enable discovery (retry {}/{})",
retry_backoff.retries(),
retry_backoff.max_retries()
);
}
}
}
} else {
None
};
let credentials_provider = match (discovery, creds) {
(Some(stream), creds) => CredentialsProvider::Discovery {
stream: stream.peekable(),
last_credentials: creds,
},
(None, Some(creds)) => CredentialsProvider::CredentialsOnly(creds),
(None, None) => {
return Err(
eyre!("Discovery unavailable and no credentials found.").with_suggestion(
|| "Try enabling discovery or logging in first with `spotifyd authenticate`.",
),
);
}
};
let backend = audio_backend::find(backend).expect("available backends should match ours");
Ok(main_loop::MainLoop {
credentials_provider,
mixer,
session_config,
cache: config.cache,
audio_device: config.audio_device,
audio_format: config.audio_format,
player_config,
backend,
initial_volume: config.initial_volume,
disable_volume: false,
shell: config.shell,
device_type: config.device_type,
device_name: config.device_name,
player_event_program: config.onevent,
#[cfg(feature = "dbus_mpris")]
mpris_config: config.mpris,
})
}
================================================
FILE: src/utils.rs
================================================
use log::trace;
use std::{env, time::Duration};
#[cfg(any(
target_os = "freebsd",
target_os = "linux",
target_os = "openbsd",
target_os = "android"
))]
fn get_shell_ffi() -> Option {
use libc::{geteuid, getpwuid_r};
use std::{ffi::CStr, mem, ptr};
trace!("Retrieving user shell through libc calls");
let mut result = ptr::null_mut();
unsafe {
let amt: usize = match libc::sysconf(libc::_SC_GETPW_R_SIZE_MAX) {
n if n < 0 => 512,
n => n as usize,
};
let mut buf = Vec::with_capacity(amt);
let mut passwd: libc::passwd = mem::zeroed();
match getpwuid_r(
geteuid(),
&mut passwd,
buf.as_mut_ptr(),
buf.capacity() as libc::size_t,
&mut result,
) {
0 if !result.is_null() => {
let ptr = passwd.pw_shell as *const _;
let shell = CStr::from_ptr(ptr)
.to_str()
.expect("Failed to retrieve shell")
.to_owned();
Some(shell)
}
_ => None,
}
}
}
// If the SHELL environment variable is not set and on we're on macOS,
// query the Directory Service command line utility (dscl) for the user's shell,
// as macOS does not use the /etc/passwd file
#[cfg(target_os = "macos")]
fn get_shell_ffi() -> Option {
use std::process::Command;
trace!("Retrieving user shell through Directory Discovery Services");
let username = whoami::username();
let output = Command::new("dscl")
.args([".", "-read", &format!("/Users/{}", username), "UserShell"])
.output()
.ok()?;
if output.status.success() {
let stdout = std::str::from_utf8(&output.stdout).ok()?;
// The output of the dscl command should be:
// "UserShell: /path/to/shell"
if stdout.starts_with("UserShell: ") {
let shell = stdout.split_whitespace().nth(1)?;
return Some(shell.to_string());
}
}
None
}
#[cfg(target_os = "windows")]
fn get_shell_ffi() -> Option {
Some(String::from("cmd"))
}
pub(crate) fn get_shell() -> Option {
let shell = env::var("SHELL").ok().or_else(get_shell_ffi);
trace!("Found user shell: {:?}", &shell);
shell
}
/// Implements basic exponential backoff.
/// The used base is 2.
pub(crate) struct Backoff {
retry_counter: u8,
max_retries: u8,
initial_backoff: Duration,
}
impl Backoff {
pub(crate) fn new(max_retries: u8, initial_backoff: Duration) -> Self {
Self {
retry_counter: 0,
max_retries,
initial_backoff,
}
}
/// Get the next backoff duration.
///
/// Increases the retry counter and returns the next required backoff duration,
/// if available.
pub(crate) fn next_backoff(&mut self) -> Result {
if self.retry_counter >= self.max_retries {
return Err(());
}
let backoff_duration = self.initial_backoff * 2u32.pow(self.retry_counter as u32);
self.retry_counter += 1;
Ok(backoff_duration)
}
pub(crate) fn retries(&self) -> u8 {
self.retry_counter
}
pub(crate) fn max_retries(&self) -> u8 {
self.max_retries
}
}
impl Default for Backoff {
fn default() -> Self {
Self::new(4, Duration::from_secs(5))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn init_logger() {
let _ = env_logger::builder().is_test(true).try_init();
}
#[test]
fn test_envvar_discovery() {
init_logger();
// SAFETY: this is part of the single-threaded tests
unsafe {
env::set_var("SHELL", "fantasy_shell");
}
let shell = get_shell().unwrap();
assert_eq!(shell, "fantasy_shell");
}
#[test]
fn test_ffi_discovery() {
init_logger();
let shell = get_shell_ffi();
assert!(shell.is_some());
}
}
