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