Compare commits

...

83 Commits
v0.1.8 ... main

Author SHA1 Message Date
Sijmen d1fd1da54b
Fix a couple JavaScript errors 2024-01-06 01:30:53 +01:00
Sijmen 31a2719ca2
Update front-end dependencies 2024-01-06 01:30:38 +01:00
Sijmen 2768cbe2af
Do a couple small Dockerfile improvements
continuous-integration/drone/push Build was killed Details
2024-01-05 23:12:39 +01:00
Sijmen 7b59d7db50
Fix a couple duplications 2024-01-05 23:12:23 +01:00
Sijmen f4b66a2c5f
Bump version to 0.2.3
continuous-integration/drone/push Build was killed Details
2024-01-05 17:49:33 +01:00
Sijmen 20bc6352b6
Allow clicking on queue items to change songs
continuous-integration/drone/push Build was killed Details
2024-01-05 17:43:11 +01:00
Sijmen 69a1ca0a6c
Improve button appearance
continuous-integration/drone/push Build was killed Details
2024-01-05 05:20:23 +01:00
Sijmen 25889df62e
Scroll current song into view when song changes 2024-01-05 05:20:23 +01:00
Sijmen 29103c1c8a
Better signal that queue items can be dragged and dropped 2024-01-05 05:20:22 +01:00
Sijmen 466f10e07a
Update issue templates 2024-01-05 04:40:21 +01:00
Sijmen 88acc76463
Update issue templates 2024-01-05 04:39:54 +01:00
Sijmen 546d7b4703
Create CODE_OF_CONDUCT.md 2024-01-05 04:36:08 +01:00
Sijmen 51ffc1f671 Bump version to 0.2.2
continuous-integration/drone/push Build was killed Details
2023-12-26 17:38:13 +01:00
Sijmen 992f286c0a Convert to actix
continuous-integration/drone/push Build was killed Details
2023-12-26 17:22:46 +01:00
Sijmen 8a01102302
Move sse route to separate module
continuous-integration/drone/push Build was killed Details
2023-12-23 10:55:18 +01:00
Sijmen 59bc10a329
Update screenshot
continuous-integration/drone/push Build was killed Details
2023-12-23 10:43:37 +01:00
Sijmen 34e093b63b
Bump version to 0.2.1
continuous-integration/drone Build was killed Details
2023-12-23 10:12:22 +01:00
Sijmen fbca4466d0
Move control routes to separate module and DRY them 2023-12-23 10:11:45 +01:00
Sijmen 16e4052890
Add button to shuffle the queue 2023-12-23 09:58:45 +01:00
Sijmen 31549b5b49
Make settings buttons slightly smaller 2023-12-23 09:58:28 +01:00
Sijmen 9c7871ed87
Add repeat button 2023-12-23 09:28:57 +01:00
Sijmen d566d8792f
Add consume and shuffle buttons 2023-12-23 09:25:57 +01:00
Sijmen b9ac839964
Update screenshot 2023-12-23 06:57:47 +01:00
Sijmen 4eb74be839
Update dependencies 2023-12-23 06:55:24 +01:00
Sijmen b872019cb0
Reconnect to mpd on unexpected response 2023-12-23 06:54:46 +01:00
Sijmen f05e17ee3a
Show track numbers 2023-12-23 06:27:23 +01:00
Sijmen 02f4025de3
Merge pull request #19 from vijfhoek/dependabot/cargo/rustix-0.37.25
Bump rustix from 0.37.23 to 0.37.25
2023-12-23 06:19:14 +01:00
Sijmen f338ab751a
Fix Windows executable name in README 2023-12-23 06:18:36 +01:00
Sijmen 4119956810
Run rustfmt 2023-12-23 06:16:59 +01:00
Sijmen ef43275561
Reuse the same mpd connection 2023-12-23 06:16:50 +01:00
dependabot[bot] b3525c786f
Bump rustix from 0.37.23 to 0.37.25
Bumps [rustix](https://github.com/bytecodealliance/rustix) from 0.37.23 to 0.37.25.
- [Release notes](https://github.com/bytecodealliance/rustix/releases)
- [Commits](https://github.com/bytecodealliance/rustix/compare/v0.37.23...v0.37.25)

---
updated-dependencies:
- dependency-name: rustix
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
2023-10-18 18:52:12 +00:00
Sijmen b8416b29dd
Split routes up into smaller modules 2023-07-13 00:37:36 +02:00
Sijmen 3900a5c5c0
Update dependencies 2023-07-13 00:37:30 +02:00
Sijmen c2fbf6c916
Bump version to 0.2.0 2023-06-25 18:46:07 +02:00
Sijmen c6c61570e9
Bump version to 0.2.0-pre1
continuous-integration/drone/push Build is passing Details
2023-05-16 02:13:54 +02:00
Sijmen 43139b2b4b
Update dependencies
continuous-integration/drone/push Build is passing Details
2023-05-16 02:04:59 +02:00
Sijmen dae598e15c
Use raw strings for mpd commands
continuous-integration/drone/push Build is passing Details
2023-05-16 02:03:06 +02:00
Sijmen 9dfa38225f
Throw error when mpd returns an unexpected response 2023-05-16 02:02:21 +02:00
Sijmen 62651ea80b
Make Mpd::connect use Mpd::command 2023-05-16 02:01:26 +02:00
Sijmen 1cf1429753
Add CommandResult::new and CommandResult::new_binary methods 2023-05-16 02:00:43 +02:00
Sijmen 05dddfde6d
Fix error when no track is playing 2023-05-16 01:59:57 +02:00
Sijmen 26a3381a25
Remove dbg! calls in mpd.rs
continuous-integration/drone/push Build is passing Details
2023-05-14 15:52:43 +02:00
Sijmen 138446e040
Format and apply Clippy suggestions 2023-05-14 15:46:43 +02:00
Sijmen 8e7a087e41
Move split_properties to CommandResult
continuous-integration/drone/push Build is failing Details
2023-05-14 15:40:51 +02:00
Sijmen 41a06eb9d1
Update dependencies
continuous-integration/drone/push Build is failing Details
2023-05-14 15:33:42 +02:00
Sijmen 039509a08d
Replace mpdrs with own implementation
continuous-integration/drone/push Build is failing Details
2023-05-14 15:31:16 +02:00
Sijmen 751d19f4f3
Call readpicture when albumart doesnt return art
continuous-integration/drone/push Build is passing Details
2023-05-13 14:53:12 +02:00
Sijmen 5e1faf887e
Add albumart and readpicture commands to Mpd 2023-05-13 14:52:49 +02:00
Sijmen 3b018da07e
Fix URL encoding showing up in title 2023-05-13 14:51:22 +02:00
Sijmen cac047d121
Add current Empede version as HTML comment
continuous-integration/drone/push Build is passing Details
2023-05-13 14:21:55 +02:00
Sijmen 1fb778da54
Use latest Rust in Dockerfile 2023-05-10 14:57:40 +02:00
Sijmen 12baf4095b
Bump version to 0.1.13 2023-05-10 14:57:39 +02:00
Sijmen e2ed3dc55b
Fix CSS getting messed up 2023-05-10 14:57:38 +02:00
Sijmen 307bbd804b
Bump version to 0.1.12 2023-05-10 14:57:23 +02:00
Sijmen 95b722c606
Create dependabot.yml 2023-05-10 14:56:42 +02:00
Sijmen 657b7245f4
Update libc from v0.2.143 to v0.2.144
continuous-integration/drone/push Build is passing Details
2023-05-08 16:36:06 +02:00
Sijmen e713a65f06
Add button to remove song from queue
continuous-integration/drone/push Build is passing Details
2023-05-08 16:33:44 +02:00
Sijmen 63a365d11d
Add album art placeholder
continuous-integration/drone/push Build is passing Details
2023-05-08 13:56:10 +02:00
Sijmen 68a00bfe80
Replace all pub(crate)s with pubs 2023-05-08 11:38:07 +02:00
Sijmen f610171d7d
Only show filename for untagged songs
continuous-integration/drone/push Build is passing Details
2023-05-07 04:06:21 +02:00
Sijmen 4eab50d8cc
Update screenshot for v0.1.11
continuous-integration/drone/push Build is passing Details
2023-05-07 03:11:48 +02:00
Sijmen f7a63f7120
Bump version to 0.1.11
continuous-integration/drone/push Build is passing Details
2023-05-07 02:57:11 +02:00
Sijmen 9ccacd92cb
Make queue scrollable
continuous-integration/drone/push Build is passing Details
2023-05-07 02:51:34 +02:00
Sijmen d0ec23dc5a
Show a ▶ or ⏸ icon in the title when playing
continuous-integration/drone/push Build is passing Details
2023-05-07 02:12:45 +02:00
Sijmen c4936dc4ff
Add buttons to play/queue an entire folder
continuous-integration/drone/push Build is passing Details
Fixes #2
2023-05-07 01:50:06 +02:00
Sijmen 7a1adb37b2
Get rid of GitHub Actions
continuous-integration/drone/push Build is passing Details
2023-05-06 23:14:00 +02:00
Sijmen be5cab22fd
Update lockfile
continuous-integration/drone/push Build is passing Details
2023-05-06 23:12:52 +02:00
Sijmen 68b05c85e7
Version bump
continuous-integration/drone/push Build is passing Details
2023-05-06 21:53:17 +02:00
Sijmen fcf325da52
Fix HTML encoding showing up in title
continuous-integration/drone/push Build is passing Details
2023-05-06 21:48:53 +02:00
Sijmen 88b9378678
Add Nix flake 2023-05-06 21:41:34 +02:00
Sijmen 7ecde917f9
Update dependencies 2023-05-06 21:27:48 +02:00
Sijmen ef46017ed8
Add support for an MPD password
continuous-integration/drone/push Build is passing Details
2023-05-06 21:10:57 +02:00
Sijmen 4455b9013b
Fix queue clear button disappearing 2023-05-06 21:07:51 +02:00
Sijmen 66d263bc5f
Make README badges clickable
continuous-integration/drone/push Build is passing Details
2023-05-03 15:26:09 +02:00
Sijmen ee6f27f692
Add repo to Cargo.toml 2023-05-03 15:25:44 +02:00
Sijmen 0a1fb9a457
Slightly reduce padding for directories 2023-05-03 12:00:16 +02:00
Sijmen 6c3719222c
Enable caching in CI
continuous-integration/drone/push Build is passing Details
2023-05-03 00:42:09 +02:00
Sijmen da8793f3f5
Check rustfmt and clippy in CI
continuous-integration/drone/push Build is passing Details
2023-05-03 00:25:42 +02:00
Sijmen 5c500e0f30
Revert "Scale images before sending to the browser"
continuous-integration/drone/push Build is passing Details
This reverts commit f095160817.
2023-05-02 15:53:28 +02:00
Sijmen f095160817
Scale images before sending to the browser
continuous-integration/drone/push Build is passing Details
2023-05-02 15:47:41 +02:00
Sijmen b14f034a50
Bump version to 0.1.9
continuous-integration/drone/push Build is passing Details
2023-05-02 11:58:30 +02:00
Sijmen c3b9e3fb72
Add version to release archive 2023-05-02 11:40:50 +02:00
Sijmen 6088dde2da
Add some more missing urlencodes 2023-05-02 11:40:18 +02:00
36 changed files with 2596 additions and 1854 deletions

View File

@ -7,11 +7,36 @@ platform:
arch: amd64
steps:
- name: restore-cache-with-filesystem
image: meltwater/drone-cache
pull: true
settings:
backend: "filesystem"
restore: true
cache_key: "volume"
mount:
- target
- /usr/local/cargo/env
volumes:
- name: cache
path: /tmp/cache
- name: lint
image: rust:latest
commands:
- rustup component add rustfmt clippy
- cargo fmt --check
- cargo clippy
depends_on:
- restore-cache-with-filesystem
- name: build-x86_64-unknown-linux-gnu
image: rust:latest
commands:
- cargo build --release
- strip target/release/empede
depends_on:
- restore-cache-with-filesystem
- name: build-aarch64-unknown-linux-gnu
image: rust:latest
@ -23,6 +48,8 @@ steps:
- aarch64-linux-gnu-strip target/aarch64-unknown-linux-gnu/release/empede
when:
event: tag
depends_on:
- restore-cache-with-filesystem
- name: build-x86_64-pc-windows-gnu
image: rust:latest
@ -33,6 +60,8 @@ steps:
- x86_64-w64-mingw32-strip target/x86_64-pc-windows-gnu/release/empede.exe
when:
event: tag
depends_on:
- restore-cache-with-filesystem
- name: package
image: alpine
@ -40,19 +69,19 @@ steps:
- apk add --no-cache tar gzip zip
# x86_64-unknown-linux-gnu
- mkdir empede-x86_64-unknown-linux-gnu
- cp -r target/release/empede static/ README.md empede-x86_64-unknown-linux-gnu
- tar czf empede-x86_64-unknown-linux-gnu.tar.gz empede-x86_64-unknown-linux-gnu/
- mkdir empede-x86_64-unknown-linux-gnu-${DRONE_TAG}
- cp -r target/release/empede static/ README.md empede-x86_64-unknown-linux-gnu-${DRONE_TAG}/
- tar czf empede-x86_64-unknown-linux-gnu-${DRONE_TAG}.tar.gz empede-x86_64-unknown-linux-gnu-${DRONE_TAG}/
# aarch64-unknown-linux-gnu
- mkdir empede-aarch64-unknown-linux-gnu
- cp -r target/aarch64-unknown-linux-gnu/release/empede static/ README.md empede-aarch64-unknown-linux-gnu
- tar czf empede-aarch64-unknown-linux-gnu.tar.gz empede-aarch64-unknown-linux-gnu/
- mkdir empede-aarch64-unknown-linux-gnu-${DRONE_TAG}
- cp -r target/aarch64-unknown-linux-gnu/release/empede static/ README.md empede-aarch64-unknown-linux-gnu-${DRONE_TAG}/
- tar czf empede-aarch64-unknown-linux-gnu-${DRONE_TAG}.tar.gz empede-aarch64-unknown-linux-gnu-${DRONE_TAG}/
# x86_64-pc-windows-gnu
- mkdir empede-x86_64-pc-windows-gnu
- cp -r target/x86_64-pc-windows-gnu/release/empede.exe static/ README.md empede-x86_64-pc-windows-gnu
- zip -r empede-x86_64-pc-windows-gnu.zip empede-x86_64-pc-windows-gnu/
- mkdir empede-x86_64-pc-windows-gnu-${DRONE_TAG}
- cp -r target/x86_64-pc-windows-gnu/release/empede.exe static/ README.md empede-x86_64-pc-windows-gnu-${DRONE_TAG}/
- zip -r empede-x86_64-pc-windows-gnu-${DRONE_TAG}.zip empede-x86_64-pc-windows-gnu-${DRONE_TAG}/
depends_on:
- build-aarch64-unknown-linux-gnu
- build-x86_64-unknown-linux-gnu
@ -67,12 +96,34 @@ steps:
from_secret: GITEA_TOKEN
base_url: https://git.sijman.nl
files:
- empede-aarch64-unknown-linux-gnu.tar.gz
- empede-x86_64-unknown-linux-gnu.tar.gz
- empede-x86_64-pc-windows-gnu.zip
- empede-aarch64-unknown-linux-gnu-${DRONE_TAG}.tar.gz
- empede-x86_64-unknown-linux-gnu-${DRONE_TAG}.tar.gz
- empede-x86_64-pc-windows-gnu-${DRONE_TAG}.zip
depends_on:
- package
when:
event: tag
- name: rebuild-cache-with-filesystem
image: meltwater/drone-cache
pull: true
settings:
backend: "filesystem"
rebuild: true
cache_key: "volume"
mount:
- target
- /usr/local/cargo/env
volumes:
- name: cache
path: /tmp/cache
depends_on:
- build-aarch64-unknown-linux-gnu
- build-x86_64-unknown-linux-gnu
- build-x86_64-pc-windows-gnu
- lint
volumes:
- name: cache
host:
path: /var/lib/cache

1
.envrc Normal file
View File

@ -0,0 +1 @@
use flake

33
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@ -0,0 +1,33 @@
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Version information (please complete the following information):**
- OS: [e.g. NixOS 23.11]
- Browser [e.g. firefox, chrome]
- Empede version [e.g. v0.2.1]
- MPD version [e.g. 0.23.15]
**Additional context**
Add any other context about the problem here.

View File

@ -0,0 +1,20 @@
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.

7
.github/dependabot.yml vendored Normal file
View File

@ -0,0 +1,7 @@
# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
version: 2
updates:
- package-ecosystem: "cargo"
directory: "/"
schedule:
interval: "daily"

4
.gitignore vendored
View File

@ -1,2 +1,4 @@
/target
/release
# nix
/result

128
CODE_OF_CONDUCT.md Normal file
View File

@ -0,0 +1,128 @@
# Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
coc@vijf.life.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series
of actions.
**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within
the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.

2353
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -1,21 +1,25 @@
[package]
name = "empede"
description = "A web client for MPD"
version = "0.1.8"
version = "0.2.3"
edition = "2021"
license = "MIT"
repository = "https://github.com/vijfhoek/empede"
[dependencies]
anyhow = "1.0.70"
askama = { version = "0.12.0", default-features = false }
askama_tide = "0.15.0"
async-std = { version = "1.12.0", features = ["attributes"] }
infer = { version = "0.13.0", default-features = false }
mpdrs = "0.1.0"
askama = { version = "0.12.0", default-features = false, features = ["serde-json"] }
infer = { version = "0.15.0", default-features = false }
percent-encoding = "2.2.0"
serde = { version = "1.0.160", features = ["derive"] }
serde_qs = "0.12.0"
tide = "0.16.0"
tide-tracing = "0.0.12"
tracing = { version = "0.1.37", default-features = false, features = ["std"] }
tracing-subscriber = { version = "0.3.17", default-features = false, features = ["std", "fmt"] }
askama_actix = "0.14.0"
tokio = { version = "1.35.1", features = ["full"] }
actix-web = "4.4.0"
thiserror = "1.0.51"
actix-files = "0.6.2"
actix-web-lab = "0.20.1"
tokio-stream = "0.1.14"
futures = "0.3.29"
async-stream = "0.3.5"
env_logger = "0.10.1"

View File

@ -1,9 +1,9 @@
FROM rust:1.69-alpine as builder
FROM rust:alpine AS builder
WORKDIR /usr/src/empede
RUN apk add --no-cache build-base
COPY ./src ./src
COPY ./templates ./templates
COPY ./Cargo.* ./
COPY ./Cargo.toml ./Cargo.lock ./
RUN cargo install --path .
FROM alpine:latest

View File

@ -1,8 +1,8 @@
# Empede
![Drone (self-hosted)](https://img.shields.io/drone/build/_/empede?server=https%3A%2F%2Fci.sijman.nl)
![Docker Image Size (latest semver)](https://img.shields.io/docker/image-size/vijfhoek/empede)
![Crates.io](https://img.shields.io/crates/v/empede)
[![Drone (self-hosted)](https://img.shields.io/drone/build/_/empede?server=https%3A%2F%2Fci.sijman.nl)](https://ci.sijman.nl/_/empede)
[![Docker Image Size (latest semver)](https://img.shields.io/docker/image-size/vijfhoek/empede)](https://quay.io/repository/vijfhoek/empede)
[![Crates.io](https://img.shields.io/crates/v/empede)](https://crates.io/crates/empede)
**A web client for MPD.**
@ -11,11 +11,12 @@
## Configuration
Empede is configured using environment variables:
| Name | Default | Description |
| --------------- | ------------ | --------------------------------- |
| **MPD_HOST** | localhost | MPD server host |
| **MPD_PORT** | 6600 | MPD server port |
| **EMPEDE_BIND** | 0.0.0.0:8080 | Address for Empede to bind to |
| Name | Default | Description |
| ---------------- | ------------ | --------------------------------- |
| **MPD_HOST** | localhost | MPD server host |
| **MPD_PORT** | 6600 | MPD server port |
| **MPD_PASSWORD** | | MPD server password |
| **EMPEDE_BIND** | 0.0.0.0:8080 | Address for Empede to bind to |
## Running
### Linux
@ -25,7 +26,7 @@ Empede is configured using environment variables:
### Windows
1. Download and extract the [latest release](https://git.sijman.nl/_/empede/releases)
3. Run `.\empede` in a PowerShell (To specify a host and port, first set the `$env:MPD_HOST` and `$env:MPD_PORT` variables)
3. Run `.\empede.exe` in a PowerShell (To specify a host and port, first set the `$env:MPD_HOST` and `$env:MPD_PORT` variables)
3. Go to http://localhost:8080
### Building from source

7
default.nix Normal file
View File

@ -0,0 +1,7 @@
(import (
fetchTarball {
url = "https://github.com/edolstra/flake-compat/archive/99f1c2157fba4bfe6211a321fd0ee43199025dbf.tar.gz";
sha256 = "0x2jn3vrawwv9xp15674wjz9pixwjyj3j771izayl962zziivbx2"; }
) {
src = ./.;
}).defaultNix

95
flake.lock Normal file
View File

@ -0,0 +1,95 @@
{
"nodes": {
"naersk": {
"inputs": {
"nixpkgs": "nixpkgs"
},
"locked": {
"lastModified": 1679567394,
"narHash": "sha256-ZvLuzPeARDLiQUt6zSZFGOs+HZmE+3g4QURc8mkBsfM=",
"owner": "nix-community",
"repo": "naersk",
"rev": "88cd22380154a2c36799fe8098888f0f59861a15",
"type": "github"
},
"original": {
"owner": "nix-community",
"ref": "master",
"repo": "naersk",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1683353485,
"narHash": "sha256-Skp5El3egmoXPiINWjnoW0ktVfB7PR/xc4F4bhD+BJY=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "caf436a52b25164b71e0d48b671127ac2e2a5b75",
"type": "github"
},
"original": {
"id": "nixpkgs",
"type": "indirect"
}
},
"nixpkgs_2": {
"locked": {
"lastModified": 1683353485,
"narHash": "sha256-Skp5El3egmoXPiINWjnoW0ktVfB7PR/xc4F4bhD+BJY=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "caf436a52b25164b71e0d48b671127ac2e2a5b75",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"naersk": "naersk",
"nixpkgs": "nixpkgs_2",
"utils": "utils"
}
},
"systems": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
},
"utils": {
"inputs": {
"systems": "systems"
},
"locked": {
"lastModified": 1681202837,
"narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "cfacdce06f30d2b68473a46042957675eebb3401",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

21
flake.nix Normal file
View File

@ -0,0 +1,21 @@
{
inputs = {
naersk.url = "github:nix-community/naersk/master";
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, utils, naersk }:
utils.lib.eachDefaultSystem (system:
let
pkgs = import nixpkgs { inherit system; };
naersk-lib = pkgs.callPackage naersk { };
in
{
defaultPackage = naersk-lib.buildPackage ./.;
devShell = with pkgs; mkShell {
buildInputs = [ cargo rustc rustfmt pre-commit rustPackages.clippy ];
RUST_SRC_PATH = rustPlatform.rustLibSrc;
};
});
}

Binary file not shown.

Before

Width:  |  Height:  |  Size: 135 KiB

After

Width:  |  Height:  |  Size: 54 KiB

7
shell.nix Normal file
View File

@ -0,0 +1,7 @@
(import (
fetchTarball {
url = "https://github.com/edolstra/flake-compat/archive/99f1c2157fba4bfe6211a321fd0ee43199025dbf.tar.gz";
sha256 = "0x2jn3vrawwv9xp15674wjz9pixwjyj3j771izayl962zziivbx2"; }
) {
src = ./.;
}).shellNix

6
src/crate_version.rs Normal file
View File

@ -0,0 +1,6 @@
#[macro_export]
macro_rules! crate_version {
() => {
env!("CARGO_PKG_VERSION")
};
}

View File

@ -1,208 +1,43 @@
use std::path::Path;
use askama::Template;
use percent_encoding::percent_decode_str;
use serde::Deserialize;
use actix_web::{middleware::Logger, web, App, HttpServer};
mod crate_version;
mod mpd;
mod routes;
#[derive(Template)]
#[template(path = "index.html")]
struct IndexTemplate;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
let bind = std::env::var("EMPEDE_BIND").unwrap_or("0.0.0.0:8080".into());
let (host, port) = bind.split_once(':').unwrap();
#[derive(Deserialize, Default)]
#[serde(default)]
struct IndexQuery {
path: String,
}
env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
async fn get_index(_req: tide::Request<()>) -> tide::Result {
Ok(askama_tide::into_response(&IndexTemplate))
}
#[derive(Template)]
#[template(path = "queue.html")]
struct QueueTemplate {
queue: Vec<mpd::QueueItem>,
}
async fn get_queue(_req: tide::Request<()>) -> tide::Result {
let queue = mpd::playlist()?;
let template = QueueTemplate { queue };
Ok(template.into())
}
#[derive(Template)]
#[template(path = "player.html")]
struct PlayerTemplate {
song: Option<mpdrs::Song>,
name: Option<String>,
state: mpdrs::State,
elapsed: f32,
duration: f32,
}
async fn get_player(_req: tide::Request<()>) -> tide::Result {
let mut mpd = mpd::connect()?;
let song = mpd.currentsong()?;
let status = mpd.status()?;
let elapsed = status.elapsed.map(|d| d.as_secs_f32()).unwrap_or(0.0);
let duration = status.duration.map(|d| d.as_secs_f32()).unwrap_or(0.0);
let mut template = PlayerTemplate {
song: song.clone(),
name: None,
state: status.state,
elapsed,
duration,
};
if let Some(song) = song {
let name = song.title.unwrap_or(song.file);
template.name = Some(name);
}
Ok(template.into())
}
#[derive(Template)]
#[template(path = "browser.html")]
struct BrowserTemplate {
path: Vec<String>,
entries: Vec<mpd::Entry>,
}
async fn get_browser(req: tide::Request<()>) -> tide::Result {
let query: IndexQuery = req.query()?;
let path = percent_decode_str(&query.path).decode_utf8_lossy();
let entries = mpd::ls(&path)?;
let template = BrowserTemplate {
path: Path::new(&*path)
.iter()
.map(|s| s.to_string_lossy().to_string())
.collect(),
entries,
};
Ok(template.into())
}
#[derive(Deserialize)]
struct PostQueueQuery {
path: String,
}
async fn post_queue(req: tide::Request<()>) -> tide::Result {
let query: PostQueueQuery = req.query()?;
let path = percent_decode_str(&query.path).decode_utf8_lossy();
mpd::connect()?.add(&path)?;
Ok("".into())
}
async fn delete_queue(_req: tide::Request<()>) -> tide::Result {
mpd::connect()?.clear()?;
Ok("".into())
}
async fn post_play(_req: tide::Request<()>) -> tide::Result {
mpd::connect()?.play()?;
Ok("".into())
}
async fn post_pause(_req: tide::Request<()>) -> tide::Result {
mpd::connect()?.pause(true)?;
Ok("".into())
}
async fn post_previous(_req: tide::Request<()>) -> tide::Result {
mpd::connect()?.prev()?;
Ok("".into())
}
async fn post_next(_req: tide::Request<()>) -> tide::Result {
mpd::connect()?.next()?;
Ok("".into())
}
#[derive(Deserialize, Debug)]
struct UpdateQueueBody {
from: u32,
to: u32,
}
async fn post_queue_move(mut req: tide::Request<()>) -> tide::Result {
let body: UpdateQueueBody = req.body_json().await?;
let mut mpd = mpd::connect()?;
mpd.move_range(
mpdrs::song::Range(Some(body.from), Some(body.from + 1)),
body.to as usize,
)?;
Ok("".into())
}
async fn get_art(req: tide::Request<()>) -> tide::Result {
let query: IndexQuery = req.query()?;
let path = percent_decode_str(&query.path).decode_utf8_lossy();
let resp = if let Ok(art) = mpd::connect()?.albumart(&path) {
let mime = infer::get(&art)
.map(|k| k.mime_type())
.unwrap_or("application/octet-stream");
tide::Response::builder(tide::StatusCode::Ok)
.body(art)
.content_type(mime)
.header("cache-control", "max-age=3600")
} else {
tide::Response::builder(tide::StatusCode::NotFound)
};
Ok(resp.into())
}
async fn sse(_req: tide::Request<()>, sender: tide::sse::Sender) -> tide::Result<()> {
// Update everything on connect
sender.send("playlist", "", None).await?;
sender.send("player", "", None).await?;
loop {
let systems = mpd::idle(&["playlist", "player", "database"]).await?;
for system in systems {
sender.send(&system, "", None).await?;
}
}
}
#[async_std::main]
async fn main() -> tide::Result<()> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.init();
let mut app = tide::new();
app.with(tide_tracing::TraceMiddleware::new());
app.at("/").get(get_index);
app.at("/queue").get(get_queue);
app.at("/player").get(get_player);
app.at("/art").get(get_art);
app.at("/browser").get(get_browser);
app.at("/sse").get(tide::sse::endpoint(sse));
app.at("/queue").post(post_queue);
app.at("/queue").delete(delete_queue);
app.at("/queue/move").post(post_queue_move);
app.at("/play").post(post_play);
app.at("/pause").post(post_pause);
app.at("/previous").post(post_previous);
app.at("/next").post(post_next);
app.at("/static").serve_dir("static/")?;
let bind = std::env::var("EMPEDE_BIND").unwrap_or("0.0.0.0:8080".to_string());
app.listen(bind).await?;
HttpServer::new(|| {
App::new().wrap(Logger::default()).service(
web::scope("")
.service(routes::index::get_index)
.service(routes::player::get_player)
.service(routes::browser::get_browser)
.service(routes::art::get_art)
.service(routes::sse::idle)
.service(routes::queue::get_queue)
.service(routes::queue::post_queue)
.service(routes::queue::delete_queue)
.service(routes::queue::post_queue_move)
.service(routes::controls::post_play)
.service(routes::controls::post_pause)
.service(routes::controls::post_previous)
.service(routes::controls::post_next)
.service(routes::controls::post_consume)
.service(routes::controls::post_random)
.service(routes::controls::post_repeat)
.service(routes::controls::post_single)
.service(routes::controls::post_shuffle)
.service(actix_files::Files::new("/static", "./static")),
)
})
.bind((host, port.parse().unwrap()))?
.run()
.await?;
Ok(())
}

View File

@ -1,82 +1,31 @@
use std::borrow::Cow;
use std::collections::HashMap;
use anyhow::anyhow;
use async_std::{
io::{prelude::BufReadExt, BufReader, WriteExt},
use tokio::{
io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufStream},
net::TcpStream,
sync::{Mutex, MutexGuard, OnceCell},
};
use mpdrs::lsinfo::LsInfoResponse;
pub(crate) fn host() -> String {
pub fn host() -> String {
let host = std::env::var("MPD_HOST").unwrap_or("localhost".to_string());
let port = std::env::var("MPD_PORT").unwrap_or("6600".to_string());
format!("{host}:{port}")
}
pub(crate) fn connect() -> Result<mpdrs::Client, mpdrs::error::Error> {
mpdrs::Client::connect(host())
pub struct QueueItem {
pub id: u32,
pub position: i32,
pub file: String,
pub title: String,
pub artist: Option<String>,
pub playing: bool,
}
pub(crate) fn ls(path: &str) -> anyhow::Result<Vec<Entry>> {
let info = connect()?.lsinfo(path)?;
fn filename(path: &str) -> Cow<str> {
std::path::Path::new(path)
.file_name()
.map(|x| x.to_string_lossy())
.unwrap_or(Cow::Borrowed("n/a"))
}
Ok(info
.iter()
.map(|e| match e {
LsInfoResponse::Song(song) => Entry::Song {
name: song.title.as_ref().unwrap_or(&song.file).clone(),
artist: song.artist.clone().unwrap_or(String::new()),
path: song.file.clone(),
},
LsInfoResponse::Directory { path, .. } => Entry::Directory {
name: filename(path).to_string(),
path: path.to_string(),
},
LsInfoResponse::Playlist { path, .. } => Entry::Playlist {
name: filename(path).to_string(),
path: path.to_string(),
},
})
.collect())
}
pub(crate) struct QueueItem {
pub(crate) file: String,
pub(crate) title: String,
pub(crate) artist: Option<String>,
pub(crate) playing: bool,
}
pub(crate) fn playlist() -> anyhow::Result<Vec<QueueItem>> {
let mut client = connect()?;
let current = client.status()?.song;
let queue = client
.queue()?
.into_iter()
.map(|song| QueueItem {
file: song.file.clone(),
title: song.title.as_ref().unwrap_or(&song.file).clone(),
artist: song.artist.clone(),
playing: current == song.place,
})
.collect();
Ok(queue)
}
pub(crate) enum Entry {
#[derive(Debug)]
pub enum Entry {
Song {
track: Option<i32>,
name: String,
artist: String,
path: String,
@ -91,31 +40,332 @@ pub(crate) enum Entry {
},
}
pub(crate) async fn idle(systems: &[&str]) -> anyhow::Result<Vec<String>> {
let mut stream = TcpStream::connect(host()).await?;
let mut reader = BufReader::new(stream.clone());
#[derive(Debug)]
pub struct Mpd {
bufstream: Option<BufStream<TcpStream>>,
}
// skip OK MPD line
// TODO check if it is indeed OK
let mut buffer = String::new();
reader.read_line(&mut buffer).await?;
pub static INSTANCE: OnceCell<Mutex<Mpd>> = OnceCell::const_new();
let systems = systems.join(" ");
let command = format!("idle {systems}\n");
stream.write_all(command.as_bytes()).await?;
pub async fn get_instance() -> MutexGuard<'static, Mpd> {
INSTANCE
.get_or_init(|| async {
let mut mpd = Mpd::new();
mpd.connect().await.unwrap();
Mutex::from(mpd)
})
.await
.lock()
.await
}
let mut updated = vec![];
loop {
buffer.clear();
reader.read_line(&mut buffer).await?;
if buffer == "OK\n" {
break Ok(updated);
pub async fn command(command: &str) -> anyhow::Result<CommandResult> {
get_instance().await.command(command).await
}
pub struct CommandResult {
properties: Vec<(String, String)>,
binary: Option<Vec<u8>>,
}
impl CommandResult {
pub fn new(properties: Vec<(String, String)>) -> Self {
Self {
properties,
binary: None,
}
}
pub fn new_binary(properties: Vec<(String, String)>, binary: Vec<u8>) -> Self {
Self {
properties,
binary: Some(binary),
}
}
pub fn into_hashmap(self) -> HashMap<String, String> {
self.properties.into_iter().collect()
}
pub fn into_hashmaps(self, split_at: &[&str]) -> Vec<HashMap<String, String>> {
let mut output = Vec::new();
let mut current = None;
for (key, value) in self.properties {
if split_at.contains(&key.as_str()) {
if let Some(current) = current {
output.push(current);
}
current = Some(HashMap::new());
}
if let Some(current) = current.as_mut() {
current.insert(key, value);
}
}
let (_, changed) = buffer
.trim_end()
.split_once(": ")
.ok_or(anyhow!("unexpected response from MPD"))?;
updated.push(changed.to_string());
if let Some(current) = current {
output.push(current);
}
output
}
}
impl Mpd {
pub fn escape_str(s: &str) -> String {
s.replace('\"', "\\\"").replace('\'', "\\'")
}
pub fn new() -> Self {
Self { bufstream: None }
}
pub async fn connect(&mut self) -> anyhow::Result<()> {
let stream = TcpStream::connect(host()).await?;
let mut bufstream = BufStream::new(stream);
// skip OK MPD line
// TODO check if it is indeed OK
let mut buffer = String::new();
bufstream.read_line(&mut buffer).await?;
let password = std::env::var("MPD_PASSWORD").unwrap_or_default();
if !password.is_empty() {
let password = Self::escape_str(&password);
bufstream
.write_all(format!("password \"{password}\"\n").as_bytes())
.await?;
bufstream.flush().await?;
bufstream.read_line(&mut buffer).await?;
}
bufstream
.write_all("binarylimit 1048576\n".as_bytes())
.await?;
bufstream.flush().await?;
bufstream.read_line(&mut buffer).await?;
self.bufstream = Some(bufstream);
Ok(())
}
async fn read_binary_data(&mut self, size: usize) -> anyhow::Result<Vec<u8>> {
let mut binary = vec![0u8; size];
self.bufstream
.as_mut()
.unwrap()
.read_exact(&mut binary)
.await?;
let mut buffer = String::new();
// Skip the newline after the binary data
self.bufstream
.as_mut()
.unwrap()
.read_line(&mut buffer)
.await?;
// Skip the "OK" after the binary data
// TODO Check if actually OK
self.bufstream
.as_mut()
.unwrap()
.read_line(&mut buffer)
.await?;
Ok(binary)
}
pub async fn command(&mut self, command: &str) -> anyhow::Result<CommandResult> {
let mut properties = Vec::new();
'retry: loop {
self.bufstream
.as_mut()
.unwrap()
.write_all(format!("{command}\n").as_bytes())
.await?;
self.bufstream.as_mut().unwrap().flush().await?;
let mut buffer = String::new();
break 'retry (loop {
buffer.clear();
self.bufstream
.as_mut()
.unwrap()
.read_line(&mut buffer)
.await?;
if let Some((key, value)) = buffer.split_once(": ") {
let value = value.trim_end();
properties.push((key.to_string(), value.to_string()));
if key == "binary" {
let binary = self.read_binary_data(value.parse()?).await?;
break Ok(CommandResult::new_binary(properties, binary));
}
} else if buffer.starts_with("OK") {
break Ok(CommandResult::new(properties));
} else if buffer.starts_with("ACK") {
break Err(anyhow!(buffer));
} else {
println!("Unexpected MPD response '{buffer}'");
self.connect().await.unwrap();
continue 'retry;
}
});
}
}
pub async fn command_binary(&mut self, command: &str) -> anyhow::Result<CommandResult> {
let mut buffer = Vec::new();
loop {
let command = format!("{} {}", command, buffer.len());
let result = self.command(&command).await?;
if let Some(mut binary) = result.binary {
if !binary.is_empty() {
buffer.append(&mut binary);
} else {
return Ok(CommandResult::new_binary(result.properties, buffer));
}
} else {
return Ok(CommandResult::new(result.properties));
}
}
}
pub async fn clear(&mut self) -> anyhow::Result<()> {
self.command("clear").await?;
Ok(())
}
pub async fn add(&mut self, path: &str) -> anyhow::Result<()> {
let path = Self::escape_str(path);
self.command(&format!("add \"{path}\"")).await?;
Ok(())
}
pub async fn add_position(&mut self, path: &str, position: &str) -> anyhow::Result<()> {
let path = Self::escape_str(path);
let position = Self::escape_str(position);
self.command(&format!(r#"add "{path}" "{position}""#))
.await?;
Ok(())
}
pub async fn play(&mut self, position: Option<&str>) -> anyhow::Result<()> {
let command = match position {
Some(position) => format!(r#"play "{position}""#),
None => "play".into(),
};
self.command(&command).await?;
Ok(())
}
pub async fn idle(&mut self, systems: &[&str]) -> anyhow::Result<Vec<String>> {
let systems = systems.join(" ");
let result = self.command(&format!("idle {systems}")).await?;
let changed = result
.properties
.iter()
.filter(|(key, _)| key == "changed")
.map(|(_, value)| value.clone())
.collect();
Ok(changed)
}
pub async fn albumart(&mut self, path: &str) -> anyhow::Result<Vec<u8>> {
let path = Self::escape_str(path);
let result = self
.command_binary(&format!(r#"albumart "{path}""#))
.await?;
match result.binary {
Some(binary) => Ok(binary),
None => Err(anyhow!("no album art")),
}
}
pub async fn readpicture(&mut self, path: &str) -> anyhow::Result<Vec<u8>> {
let path = Self::escape_str(path);
let result = self
.command_binary(&format!(r#"readpicture "{path}""#))
.await?;
match result.binary {
Some(binary) => Ok(binary),
None => Err(anyhow!("no album art")),
}
}
#[allow(clippy::manual_map)]
pub async fn ls(&mut self, path: &str) -> anyhow::Result<Vec<Entry>> {
fn get_filename(path: &str) -> String {
std::path::Path::new(path)
.file_name()
.map(|x| x.to_string_lossy().to_string())
.unwrap_or("n/a".to_string())
}
let path = Self::escape_str(path);
let result = self
.command(&format!(r#"lsinfo "{path}""#))
.await?
.into_hashmaps(&["file", "directory", "playlist"]);
let files = result
.iter()
.flat_map(|prop| {
if let Some(file) = prop.get("file") {
Some(Entry::Song {
track: prop.get("Track").and_then(|track| track.parse().ok()),
name: prop.get("Title").unwrap_or(&get_filename(file)).clone(),
artist: prop.get("Artist").unwrap_or(&String::new()).clone(),
path: file.to_string(),
})
} else if let Some(file) = prop.get("directory") {
Some(Entry::Directory {
name: get_filename(file),
path: file.to_string(),
})
} else if let Some(file) = prop.get("playlist") {
Some(Entry::Playlist {
name: get_filename(file),
path: file.to_string(),
})
} else {
None
}
})
.collect();
Ok(files)
}
pub async fn playlist(&mut self) -> anyhow::Result<Vec<QueueItem>> {
let status = self.command("status").await?.into_hashmap();
let current_songid = status.get("songid");
let playlistinfo = self.command("playlistinfo").await?;
let queue = playlistinfo.into_hashmaps(&["file"]);
let queue = queue
.iter()
.map(|song| QueueItem {
id: song["Id"].parse().unwrap(),
position: song["Pos"].parse().unwrap(),
file: song["file"].clone(),
title: song.get("Title").unwrap_or(&song["file"]).clone(),
artist: song.get("Artist").cloned(),
playing: current_songid == song.get("Id"),
})
.collect();
Ok(queue)
}
}

42
src/routes/art.rs Normal file
View File

@ -0,0 +1,42 @@
use crate::mpd;
use actix_web::{
get,
http::header::{self, CacheDirective},
web, HttpResponse, Responder,
};
use percent_encoding::percent_decode_str;
use serde::Deserialize;
#[derive(Deserialize, Default)]
#[serde(default)]
struct ArtQuery {
path: String,
}
#[get("/art")]
pub async fn get_art(query: web::Query<ArtQuery>) -> impl Responder {
let path = percent_decode_str(&query.path).decode_utf8_lossy();
let mut mpd = mpd::get_instance().await;
if let Ok(art) = mpd.albumart(&path).await {
let mime = infer::get(&art)
.map(|k| k.mime_type())
.unwrap_or("application/octet-stream");
HttpResponse::Ok()
.content_type(mime)
.append_header(header::CacheControl(vec![CacheDirective::MaxAge(3600)]))
.body(art)
} else if let Ok(art) = mpd.readpicture(&path).await {
let mime = infer::get(&art)
.map(|k| k.mime_type())
.unwrap_or("application/octet-stream");
HttpResponse::Ok()
.content_type(mime)
.append_header(header::CacheControl(vec![CacheDirective::MaxAge(3600)]))
.body(art)
} else {
HttpResponse::NotFound().finish()
}
}

34
src/routes/browser.rs Normal file
View File

@ -0,0 +1,34 @@
use crate::mpd;
use actix_web::{get, web, Responder};
use askama::Template;
use percent_encoding::percent_decode_str;
use serde::Deserialize;
use std::path::Path;
#[derive(Template)]
#[template(path = "browser.html")]
struct BrowserTemplate {
path: Vec<String>,
entries: Vec<mpd::Entry>,
}
#[derive(Deserialize, Default)]
#[serde(default)]
struct BrowserQuery {
path: String,
}
#[get("/browser")]
pub async fn get_browser(query: web::Query<BrowserQuery>) -> impl Responder {
let path = percent_decode_str(&query.path).decode_utf8_lossy();
let mut mpd = mpd::get_instance().await;
let entries = mpd.ls(&path).await.unwrap();
BrowserTemplate {
path: Path::new(&*path)
.iter()
.map(|s| s.to_string_lossy().to_string())
.collect(),
entries,
}
}

76
src/routes/controls.rs Normal file
View File

@ -0,0 +1,76 @@
use actix_web::{post, web, HttpResponse, Responder};
use serde::Deserialize;
use crate::mpd;
async fn toggle_setting(setting: &str) -> anyhow::Result<()> {
let mut mpd = mpd::get_instance().await;
let status = mpd.command("status").await?.into_hashmap();
let value = status[setting] == "1";
mpd.command(&format!("{} {}", setting, if value { 0 } else { 1 }))
.await?;
Ok(())
}
#[derive(Deserialize)]
struct PostPlayQuery {
#[serde(default)]
position: Option<String>,
}
#[post("/play")]
pub async fn post_play(query: web::Query<PostPlayQuery>) -> impl Responder {
let mut mpd = mpd::get_instance().await;
mpd.play(query.position.as_deref()).await.unwrap();
HttpResponse::NoContent()
}
#[post("/pause")]
pub async fn post_pause() -> impl Responder {
mpd::command("pause 1").await.unwrap();
HttpResponse::NoContent()
}
#[post("/previous")]
pub async fn post_previous() -> impl Responder {
mpd::command("previous").await.unwrap();
HttpResponse::NoContent()
}
#[post("/next")]
pub async fn post_next() -> impl Responder {
mpd::command("next").await.unwrap();
HttpResponse::NoContent()
}
#[post("/consume")]
pub async fn post_consume() -> impl Responder {
toggle_setting("consume").await.unwrap();
HttpResponse::NoContent()
}
#[post("/random")]
pub async fn post_random() -> impl Responder {
toggle_setting("random").await.unwrap();
HttpResponse::NoContent()
}
#[post("/repeat")]
pub async fn post_repeat() -> impl Responder {
toggle_setting("repeat").await.unwrap();
HttpResponse::NoContent()
}
#[post("/shuffle")]
pub async fn post_shuffle() -> impl Responder {
mpd::command("shuffle").await.unwrap();
HttpResponse::NoContent()
}
#[post("/single")]
pub async fn post_single() -> impl Responder {
toggle_setting("single").await.unwrap();
HttpResponse::NoContent()
}

19
src/routes/index.rs Normal file
View File

@ -0,0 +1,19 @@
use crate::crate_version;
use actix_web::{get, Responder};
use askama::Template;
use serde::Deserialize;
#[derive(Template)]
#[template(path = "index.html")]
struct IndexTemplate;
#[derive(Deserialize, Default)]
#[serde(default)]
struct IndexQuery {
path: String,
}
#[get("/")]
pub async fn get_index() -> impl Responder {
IndexTemplate
}

7
src/routes/mod.rs Normal file
View File

@ -0,0 +1,7 @@
pub mod art;
pub mod browser;
pub mod controls;
pub mod index;
pub mod player;
pub mod queue;
pub mod sse;

57
src/routes/player.rs Normal file
View File

@ -0,0 +1,57 @@
use crate::mpd;
use actix_web::{get, Responder};
use askama::Template;
use std::collections::HashMap;
#[derive(Template)]
#[template(path = "player.html")]
struct PlayerTemplate {
song: Option<HashMap<String, String>>,
name: Option<String>,
state: String,
consume: bool,
random: bool,
repeat: bool,
single: bool,
elapsed: f32,
duration: f32,
}
#[get("/player")]
pub async fn get_player() -> impl Responder {
let mut mpd = mpd::get_instance().await;
let song = mpd.command("currentsong").await.unwrap().into_hashmap();
let status = mpd.command("status").await.unwrap().into_hashmap();
let elapsed = status
.get("elapsed")
.and_then(|e| e.parse().ok())
.unwrap_or(0.0);
let duration = status
.get("duration")
.and_then(|e| e.parse().ok())
.unwrap_or(1.0);
let mut template = PlayerTemplate {
song: if song.is_empty() {
None
} else {
Some(song.clone())
},
name: None,
state: status["state"].clone(),
consume: status["consume"] == "1",
random: status["random"] == "1",
repeat: status["repeat"] == "1",
single: status["single"] == "1",
elapsed,
duration,
};
if !song.is_empty() {
let name = song.get("Title").unwrap_or(&song["file"]).to_string();
template.name = Some(name);
}
template
}

84
src/routes/queue.rs Normal file
View File

@ -0,0 +1,84 @@
use crate::mpd;
use actix_web::{delete, get, post, web, HttpResponse, Responder};
use askama::Template;
use percent_encoding::percent_decode_str;
use serde::Deserialize;
#[derive(Template)]
#[template(path = "queue.html")]
struct QueueTemplate {
queue: Vec<mpd::QueueItem>,
}
#[get("/queue")]
pub async fn get_queue() -> impl Responder {
let mut mpd = mpd::get_instance().await;
let queue = mpd.playlist().await.unwrap();
QueueTemplate { queue }
}
#[derive(Deserialize)]
struct PostQueueQuery {
path: String,
#[serde(default)]
replace: bool,
#[serde(default)]
next: bool,
#[serde(default)]
play: bool,
}
#[post("/queue")]
pub async fn post_queue(query: web::Query<PostQueueQuery>) -> impl Responder {
let path = percent_decode_str(&query.path).decode_utf8_lossy();
let mut mpd = mpd::get_instance().await;
if query.replace {
mpd.clear().await.unwrap();
}
if query.next {
mpd.add_position(&path, "+0").await.unwrap();
} else {
mpd.add(&path).await.unwrap();
}
if query.play {
mpd.play(None).await.unwrap();
}
HttpResponse::NoContent()
}
#[derive(Deserialize)]
struct DeleteQueueQuery {
#[serde(default)]
id: Option<u32>,
}
#[delete("/queue")]
pub async fn delete_queue(query: web::Query<DeleteQueueQuery>) -> impl Responder {
let mut mpd = mpd::get_instance().await;
if let Some(id) = query.id {
mpd.command(&format!("deleteid {id}")).await.unwrap();
} else {
mpd.command("clear").await.unwrap();
}
HttpResponse::NoContent()
}
#[derive(Deserialize, Debug)]
struct UpdateQueueBody {
from: u32,
to: u32,
}
#[post("/queue/move")]
pub async fn post_queue_move(body: web::Json<UpdateQueueBody>) -> impl Responder {
let mut mpd = mpd::get_instance().await;
mpd.command(&format!("move {} {}", body.from, body.to))
.await
.unwrap();
HttpResponse::NoContent()
}

33
src/routes/sse.rs Normal file
View File

@ -0,0 +1,33 @@
use std::time::Duration;
use actix_web::{get, Responder};
use actix_web_lab::sse;
use crate::mpd::Mpd;
#[get("/idle")]
pub async fn idle() -> impl Responder {
let mut mpd = Mpd::new();
mpd.connect().await.unwrap();
const SYSTEMS: &[&str] = &["playlist", "player", "database", "options"];
let (tx, rx) = tokio::sync::mpsc::channel(10);
for system in SYSTEMS {
_ = tx
.send(sse::Data::new("").event(system.to_owned()).into())
.await;
}
actix_web::rt::spawn(async move {
loop {
let systems = mpd.idle(SYSTEMS).await.unwrap();
for system in systems {
_ = tx.send(sse::Data::new("").event(system).into()).await;
}
}
});
sse::Sse::from_infallible_receiver(rx).with_retry_duration(Duration::from_secs(10))
}

BIN
static/placeholder.webp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 5.4 KiB

View File

@ -24,14 +24,28 @@ body {
}
}
body > div {
padding: 1rem;
}
button {
background-color: transparent;
border: none;
color: inherit;
font-weight: bold;
display: flex;
line-height: 24px;
cursor: pointer;
padding: 0.25rem 0.5rem;
}
button:hover {
background-color: rgba(255, 255, 255, 0.1);
border-radius: 0.25rem;
}
button .material-symbols-outlined {
margin-right: 0.25rem;
}
.active {
color: #99f;
}
.browser {
@ -62,65 +76,96 @@ ul {
margin: 0;
}
.player > .queue {
flex: 1;
display: flex;
flex-flow: column;
}
.queue-header {
margin-top: 1.0rem;
display: flex;
align-items: center;
}
.queue-next {
font-weight: bold;
flex: 1;
}
.queue-clear {
font-weight: bold;
display: flex;
line-height: 24px;
}
.queue-clear .material-symbols-outlined {
margin-right: 0.25rem;
}
.queue {
margin-top: 0.5rem;
overflow: auto;
scroll-behavior: smooth;
}
.queue li {
.queue ul li {
padding: 0 0.5rem;
border-radius: .25rem;
display: flex;
align-items: center;
cursor: grab;
}
.queue ul li:hover {
background-color: #223;
}
.queue li.playing {
.queue ul li.playing {
background-color: #334;
}
@media (prefers-contrast: more) {
.queue li.playing {
.queue ul li.playing {
background-color: black;
border: 2px solid white;
}
}
.queue .metadata {
.queue ul .metadata {
flex: 1;
}
.queue .song__name {
.queue ul .metadata * {
-webkit-line-clamp: 1;
line-clamp: 1;
-webkit-box-orient: vertical;
}
.queue ul .song__name {
overflow: hidden;
display: -webkit-box;
-webkit-line-clamp: 2; /* number of lines to show */
line-clamp: 2;
-webkit-box-orient: vertical;
}
.queue ul li:not(:hover) .remove {
display: none;
}
.queue .remove button {
padding: 0.25rem;
}
.browser .header {
display: flex;
flex-flow: column;
background-color: #334;
border-radius: 0.25rem;
padding: 0.75rem 0.5rem;
margin: 16px 16px 0;
}
.browser .buttons {
display: flex;
flex-flow: row;
margin-top: 0.25rem;
}
.browser .buttons button {
margin-right: 0.5rem;
}
ul.breadcrumb {
display: flex;
margin-bottom: 1rem;
flex-wrap: wrap;
list-style: none;
background-color: #334;
border-radius: .25rem;
padding: .75rem 1rem;
margin: 16px 16px 0;
margin-left: 0.5rem;
}
@media (prefers-contrast: more) {
ul.breadcrumb {
@ -149,7 +194,7 @@ ul.dir li {
cursor: pointer;
padding: 0.5rem 0.5rem;
border-radius: 0.25rem;
min-height: 4rem;
min-height: 3rem;
display: flex;
align-items: center;
@ -170,14 +215,24 @@ ul.dir li .material-symbols-outlined {
.albumart {
border-radius: 0.25rem;
background-color: #445;
width: 48px;
height: 48px;
background: #445 url(/static/placeholder.webp);
background-size: contain;
}
.albumart a {
display: block;
}
.albumart img {
visibility: hidden;
border-radius: 0.25rem;
width: 100%;
height: 100%;
object-fit: cover;
}
.queue .albumart {
margin: 0.75rem;
margin-left: 0;
@ -187,15 +242,15 @@ ul.dir li .material-symbols-outlined {
margin-right: 0.75rem;
}
.albumart img {
border-radius: 0.25rem;
width: 100%;
height: 100%;
object-fit: cover;
.track {
margin-right: 0.75rem;
}
.player {
width: 25rem;
padding: 1rem 1rem 0;
display: flex;
flex-flow: column;
}
.player .nowplaying {
@ -204,7 +259,7 @@ ul.dir li .material-symbols-outlined {
flex-flow: column;
background-color: #334;
border-radius: 0.25rem;
height: 10.0rem;
height: 13.0rem;
}
@media (prefers-contrast: more) {
.player .nowplaying {
@ -224,15 +279,23 @@ ul.dir li .material-symbols-outlined {
bottom: 0;
}
.player .controls {
.player .controls,
.player .settings {
display: flex;
justify-content: space-around;
padding: 0 0.5rem 1.0rem;
padding: 0 0.5rem 0.25rem;
}
.player .control {
.player .settings {
margin-bottom: 0.5rem;
}
.player .controls button {
font-size: 40px;
}
.player .settings button {
font-size: 25px;
}
.player .current {
display: flex;

File diff suppressed because one or more lines are too long

View File

@ -5,7 +5,7 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
*/
(function(){
(function() {
/** @type {import("../htmx").HtmxInternalApi} */
var api;
@ -39,17 +39,19 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
switch (name) {
// Try to remove remove an EventSource when elements are removed
case "htmx:beforeCleanupElement":
var internalData = api.getInternalData(evt.target)
if (internalData.sseEventSource) {
internalData.sseEventSource.close();
}
return;
case "htmx:beforeCleanupElement":
var internalData = api.getInternalData(evt.target)
// Try to remove remove an EventSource when elements are removed
if (internalData.sseEventSource) {
internalData.sseEventSource.close();
}
// Try to create EventSources when elements are processed
case "htmx:afterProcessNode":
createEventSourceOnElement(evt.target);
return;
// Try to create EventSources when elements are processed
case "htmx:afterProcessNode":
ensureEventSourceOnElement(evt.target);
registerSSE(evt.target);
}
}
});
@ -66,8 +68,8 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
* @param {string} url
* @returns EventSource
*/
function createEventSource(url) {
return new EventSource(url, {withCredentials:true});
function createEventSource(url) {
return new EventSource(url, { withCredentials: true });
}
function splitOnWhitespace(trigger) {
@ -90,7 +92,7 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
function getLegacySSESwaps(elt) {
var legacySSEValue = api.getAttributeValue(elt, "hx-sse");
var returnArr = [];
if (legacySSEValue) {
if (legacySSEValue != null) {
var values = splitOnWhitespace(legacySSEValue);
for (var i = 0; i < values.length; i++) {
var value = values[i].split(/:(.+)/);
@ -103,63 +105,24 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
}
/**
* createEventSourceOnElement creates a new EventSource connection on the provided element.
* If a usable EventSource already exists, then it is returned. If not, then a new EventSource
* is created and stored in the element's internalData.
* registerSSE looks for attributes that can contain sse events, right
* now hx-trigger and sse-swap and adds listeners based on these attributes too
* the closest event source
*
* @param {HTMLElement} elt
* @param {number} retryCount
* @returns {EventSource | null}
*/
function createEventSourceOnElement(elt, retryCount) {
if (elt == null) {
return null;
function registerSSE(elt) {
// Find closest existing event source
var sourceElement = api.getClosestMatch(elt, hasEventSource);
if (sourceElement == null) {
// api.triggerErrorEvent(elt, "htmx:noSSESourceError")
return null; // no eventsource in parentage, orphaned element
}
var internalData = api.getInternalData(elt);
// Set internalData and source
var internalData = api.getInternalData(sourceElement);
var source = internalData.sseEventSource;
// get URL from element's attribute
var sseURL = api.getAttributeValue(elt, "sse-connect");
if (sseURL == undefined) {
var legacyURL = getLegacySSEURL(elt)
if (legacyURL) {
sseURL = legacyURL;
} else {
return null;
}
}
// Connect to the EventSource
var source = htmx.createEventSource(sseURL);
internalData.sseEventSource = source;
// Create event handlers
source.onerror = function (err) {
// Log an error event
api.triggerErrorEvent(elt, "htmx:sseError", {error:err, source:source});
// If parent no longer exists in the document, then clean up this EventSource
if (maybeCloseSSESource(elt)) {
return;
}
// Otherwise, try to reconnect the EventSource
if (source.readyState === EventSource.CLOSED) {
retryCount = retryCount || 0;
var timeout = Math.random() * (2 ^ retryCount) * 500;
window.setTimeout(function() {
createEventSourceOnElement(elt, Math.min(7, retryCount+1));
}, timeout);
}
};
source.onopen = function (evt) {
api.triggerEvent(elt, "htmx::sseOpen", {source: source});
}
// Add message handlers for every `sse-swap` attribute
queryAttributeOnThisOrChildren(elt, "sse-swap").forEach(function(child) {
@ -170,23 +133,27 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
var sseEventNames = getLegacySSESwaps(child);
}
for (var i = 0 ; i < sseEventNames.length ; i++) {
for (var i = 0; i < sseEventNames.length; i++) {
var sseEventName = sseEventNames[i].trim();
var listener = function(event) {
// If the parent is missing then close SSE and remove listener
if (maybeCloseSSESource(elt)) {
source.removeEventListener(sseEventName, listener);
// If the source is missing then close SSE
if (maybeCloseSSESource(sourceElement)) {
return;
}
// If the body no longer contains the element, remove the listener
if (!api.bodyContains(child)) {
source.removeEventListener(sseEventName, listener);
}
// swap the response into the DOM and trigger a notification
swap(child, event.data);
api.triggerEvent(elt, "htmx:sseMessage", event);
};
// Register the new listener
api.getInternalData(elt).sseEventListener = listener;
api.getInternalData(child).sseEventListener = listener;
source.addEventListener(sseEventName, listener);
}
});
@ -203,24 +170,86 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
if (sseEventName.slice(0, 4) != "sse:") {
return;
}
// remove the sse: prefix from here on out
sseEventName = sseEventName.substr(4);
var listener = function(event) {
// If parent is missing, then close SSE and remove listener
if (maybeCloseSSESource(elt)) {
source.removeEventListener(sseEventName, listener);
return;
var listener = function() {
if (maybeCloseSSESource(sourceElement)) {
return
}
// Trigger events to be handled by the rest of htmx
htmx.trigger(child, sseEventName, event);
htmx.trigger(child, "htmx:sseMessage", event);
if (!api.bodyContains(child)) {
source.removeEventListener(sseEventName, listener);
}
}
});
}
/**
* ensureEventSourceOnElement creates a new EventSource connection on the provided element.
* If a usable EventSource already exists, then it is returned. If not, then a new EventSource
* is created and stored in the element's internalData.
* @param {HTMLElement} elt
* @param {number} retryCount
* @returns {EventSource | null}
*/
function ensureEventSourceOnElement(elt, retryCount) {
if (elt == null) {
return null;
}
// handle extension source creation attribute
queryAttributeOnThisOrChildren(elt, "sse-connect").forEach(function(child) {
var sseURL = api.getAttributeValue(child, "sse-connect");
if (sseURL == null) {
return;
}
// Register the new listener
api.getInternalData(elt).sseEventListener = listener;
source.addEventListener(sseEventName.slice(4), listener);
ensureEventSource(child, sseURL, retryCount);
});
// handle legacy sse, remove for HTMX2
queryAttributeOnThisOrChildren(elt, "hx-sse").forEach(function(child) {
var sseURL = getLegacySSEURL(child);
if (sseURL == null) {
return;
}
ensureEventSource(child, sseURL, retryCount);
});
}
function ensureEventSource(elt, url, retryCount) {
var source = htmx.createEventSource(url);
source.onerror = function(err) {
// Log an error event
api.triggerErrorEvent(elt, "htmx:sseError", { error: err, source: source });
// If parent no longer exists in the document, then clean up this EventSource
if (maybeCloseSSESource(elt)) {
return;
}
// Otherwise, try to reconnect the EventSource
if (source.readyState === EventSource.CLOSED) {
retryCount = retryCount || 0;
var timeout = Math.random() * (2 ^ retryCount) * 500;
window.setTimeout(function() {
ensureEventSourceOnElement(elt, Math.min(7, retryCount + 1));
}, timeout);
}
};
source.onopen = function(evt) {
api.triggerEvent(elt, "htmx:sseOpen", { source: source });
}
api.getInternalData(elt).sseEventSource = source;
}
/**
@ -253,12 +282,12 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
var result = [];
// If the parent element also contains the requested attribute, then add it to the results too.
if (api.hasAttribute(elt, attributeName) || api.hasAttribute(elt, "hx-sse")) {
if (api.hasAttribute(elt, attributeName)) {
result.push(elt);
}
// Search all child nodes that match the requested attribute
elt.querySelectorAll("[" + attributeName + "], [data-" + attributeName + "], [hx-sse], [data-hx-sse]").forEach(function(node) {
elt.querySelectorAll("[" + attributeName + "], [data-" + attributeName + "]").forEach(function(node) {
result.push(node);
});
@ -281,7 +310,7 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
api.selectAndSwap(swapSpec.swapStyle, target, elt, content, settleInfo);
settleInfo.elts.forEach(function (elt) {
settleInfo.elts.forEach(function(elt) {
if (elt.classList) {
elt.classList.add(htmx.config.settlingClass);
}
@ -306,11 +335,11 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
function doSettle(settleInfo) {
return function() {
settleInfo.tasks.forEach(function (task) {
settleInfo.tasks.forEach(function(task) {
task.call();
});
settleInfo.elts.forEach(function (elt) {
settleInfo.elts.forEach(function(elt) {
if (elt.classList) {
elt.classList.remove(htmx.config.settlingClass);
}
@ -319,4 +348,8 @@ This extension adds support for Server Sent Events to htmx. See /www/extensions
}
}
})();
function hasEventSource(node) {
return api.getInternalData(node).sseEventSource != null;
}
})();

File diff suppressed because one or more lines are too long

View File

@ -1,38 +1,56 @@
{# #}
<ul class="breadcrumb">
<li>
<a
href="/"
hx-replace-url="/"
hx-get="/browser"
hx-vals='{"path": ""}'
hx-target=".browser"
>Root</a>
</li>
{% for (i, component) in path.iter().enumerate() %}
<li>
{% if i == path.len() - 1 %}
{{ component }}
{% else %}
<a
{% let encoded = path[..i + 1].join("/")|urlencode %}
href="/?path={{ encoded }}"
hx-replace-url="/?path={{ encoded }}"
hx-get="/browser"
hx-vals='{"path": "{{ encoded }}"}'
hx-target=".browser"
>{{ component }}</a>
{% endif %}
</li>
{% endfor %}
</ul>
<div class="header">
<ul class="breadcrumb">
<li>
<a
href="/"
hx-replace-url="/"
hx-get="/browser"
hx-vals='{"path": ""}'
hx-target=".browser"
>Root</a>
</li>
{% for (i, component) in path.iter().enumerate() %}
<li>
{% if i == path.len() - 1 %}
{{ component }}
{% else %}
<a
{% let encoded = path[..i + 1].join("/")|urlencode %}
href="/?path={{ encoded }}"
hx-replace-url="/?path={{ encoded }}"
hx-get="/browser"
hx-vals='{"path": "{{ encoded }}"}'
hx-target=".browser"
>{{ component }}</a>
{% endif %}
</li>
{% endfor %}
</ul>
<div class="buttons">
{% let encoded = path.join("/")|urlencode %}
<button hx-delete="/queue" hx-swap="none" hx-post="/queue?path={{ encoded }}">
<span class="material-symbols-outlined">playlist_add</span>
Queue all
</button>
<button hx-delete="/queue" hx-swap="none" hx-post="/queue?path={{ encoded }}&replace=true&play=true">
<span class="material-symbols-outlined">playlist_play</span>
Play all
</button>
<button hx-delete="/queue" hx-swap="none" hx-post="/queue?path={{ encoded }}&next=true">
<span class="material-symbols-outlined">playlist_add</span>
Play next
</button>
</div>
</div>
<ul class="dir" hx-boost="true" tabindex="-1">
{% for entry in entries %}
{% match entry %}
{% when mpd::Entry::Song with { name, path, artist } %}
{% when mpd::Entry::Song with { track, name, path, artist } %}
<li
hx-post="/queue?path={{path}}"
hx-post="/queue?path={{ path|urlencode }}"
hx-trigger="click,keyup[key=='Enter']"
hx-swap="none"
role="button"
@ -40,8 +58,17 @@
>
<span class="material-symbols-outlined" title="Song">music_note</span>
<div class="albumart">
<img src="/art?path={{path}}" onerror="this.style.visibility = 'hidden'">
<img
src="/art?path={{ path|urlencode }}"
onload="this.style.visibility = 'visible'"
alt="Album art"
>
</div>
{% if let Some(track) = track %}
<div class="track">
{{ track }}.
</div>
{% endif %}
<div class="song">
<div class="song__name">{{ name }}</div>
<div class="song__artist">{{ artist }}</div>

View File

@ -3,6 +3,8 @@
<html lang="en">
<head>
<title>Empede</title>
<!-- Empede version: {{ crate_version!() }} -->
<!-- Source: https://github.com/bigskysoftware/htmx -->
<script src="/static/vendor/htmx.min.js"></script>
@ -22,7 +24,7 @@
</script>
</head>
<body hx-ext="sse" sse-connect="/sse">
<body hx-ext="sse" sse-connect="/idle">
<div
class="browser"
hx-trigger="load,sse:database"
@ -31,8 +33,21 @@
></div>
<div class="player">
<div hx-trigger="sse:player" hx-get="/player"></div>
<div hx-trigger="sse:playlist,sse:player" hx-get="/queue"></div>
<div class="nowplaying" hx-trigger="sse:player,sse:options" hx-get="/player"></div>
<div class="queue-header">
<div class="queue-next">Next in queue</div>
<button hx-delete="/queue" hx-swap="none">
<span class="material-symbols-outlined">playlist_remove</span>
Clear
</button>
<button hx-post="/shuffle" hx-swap="none">
<span class="material-symbols-outlined">shuffle</span>
Shuffle
</button>
</div>
<div class="queue" hx-trigger="sse:playlist,sse:player" hx-get="/queue"></div>
</div>
</body>
</html>

View File

@ -1,70 +1,98 @@
{# #}
<!DOCTYPE html>
<div class="nowplaying">
<div class="current">
{% if let Some(song) = song %}
<div class="albumart">
<a href="/art?path={{ song.file|urlencode }}" target="_blank">
<img
src="/art?path={{ song.file|urlencode }}"
onerror="this.style.opacity = 0"
alt="Album art"
title="Album art"
>
</a>
</div>
<div class="metadata">
{% if let Some(name) = name %}
<div class="song__name" title="Song name">{{ name }}</div>
{% endif %}
{% if let Some(artist) = song.artist %}
<div class="song__artist" title="Artist">{{ artist }}</div>
{% endif %}
</div>
{% else %}
<div class="metadata idle">
Nothing playing right now
</div>
<div class="current">
{% if let Some(song) = song %}
<div class="albumart">
<a href="/art?path={{ song["file"]|urlencode }}" target="_blank">
<img
src="/art?path={{ song["file"]|urlencode }}"
onload="this.style.visibility = 'visible'"
alt="Album art"
>
</a>
</div>
<div class="metadata">
{% if let Some(name) = name %}
<div class="song__name" title="Song name">{{ name }}</div>
{% endif %}
{% if let Some(artist) = song.get("Artist") %}
<div class="song__artist" title="Artist">{{ artist }}</div>
{% endif %}
</div>
<div class="controls" hx-swap="none" hx-trigger="click,keyUp[key=='Enter']">
<button
hx-post="/previous"
class="control material-symbols-outlined" role="button" title="Previous track"
>skip_previous</button>
{% if state == mpdrs::State::Play %}
<button
hx-post="/pause"
class="control material-symbols-outlined" role="button" title="Pause"
>pause</button>
{% else %}
<button
hx-post="/play"
class="control material-symbols-outlined" role="button" title="Play"
>play_arrow</button>
{% endif %}
<button
hx-post="/next"
class="control material-symbols-outlined" role="button" title="Next track"
>skip_next</button>
{% else %}
<div class="metadata idle">
Nothing playing right now
</div>
<div class="progress" style="width: {{ elapsed / duration * 100.0 }}%"></div>
{% endif %}
</div>
<div class="controls" hx-swap="none" hx-trigger="click,keyUp[key=='Enter']">
<button
hx-post="/previous"
class="control material-symbols-outlined" role="button" title="Previous track"
>skip_previous</button>
{% if state == "play" %}
<button
hx-post="/pause"
class="control material-symbols-outlined" role="button" title="Pause"
>pause</button>
{% else %}
<button
hx-post="/play"
class="control material-symbols-outlined" role="button" title="Play"
>play_arrow</button>
{% endif %}
<button
hx-post="/next"
class="control material-symbols-outlined" role="button" title="Next track"
>skip_next</button>
</div>
<div class="settings" hx-swap="none" hx-trigger="click,keyUp[key=='Enter']">
<button
hx-post="/consume"
class="control material-symbols-outlined {% if consume %}active{% endif %}"
role="button" title="Consume"
style="font-size: 32px"
>delete_sweep</button>
<button
hx-post="/random"
class="control material-symbols-outlined {% if random %}active{% endif %}"
role="button" title="Shuffle"
>shuffle</button>
<button
hx-post="/repeat"
class="control material-symbols-outlined {% if repeat %}active{% endif %}"
role="button" title="Repeat"
>repeat</button>
<button
hx-post="/single"
class="control material-symbols-outlined {% if single %}active{% endif %}"
role="button" title="Single"
>filter_1</button>
</div>
<div class="progress" style="width: {{ elapsed / duration * 100.0 }}%"></div>
<script>
{% if let Some(name) = name %}
document.title = "{{ name }} - Empede";
{% if state == "play" %}
document.title = "▶ " + {{ name|json|safe }} + " - Empede";
{% else %}
document.title = "⏸ " + {{ name|json|safe }} + " - Empede";
{% endif %}
{% else %}
document.title = "Empede";
{% endif %}
{% if state == mpdrs::State::Play %}
{% if state == "play" %}
progressBar = document.querySelector(".nowplaying .progress");
elapsed = {{ elapsed }};
duration = {{ duration }};
@ -79,4 +107,4 @@
progressBar.style.width = `${progress * 100}%`;
}, 1000);
{% endif %}
</script>
</script>

View File

@ -1,23 +1,19 @@
{# Template #}
<!DOCTYPE html>
<div class="queue-header">
<div class="queue-next">Next in queue</div>
<button class="queue-clear" role="button" hx-delete="/queue">
<span class="material-symbols-outlined">playlist_remove</span>
Clear
</div>
</div>
<ul class="queue">
<ul>
{% for item in queue %}
<li {% if item.playing %}class="playing"{% endif %}>
<li
{% if item.playing %}class="playing"{% endif %}
hx-post="/play?position={{ item.position|urlencode }}"
hx-trigger="click,keyup[key='Enter']"
hx-swap="none"
>
<div class="albumart">
<img
src="/art?path={{ item.file|urlencode }}"
onerror="this.style.opacity = 0"
onload="this.style.visibility = 'visible'"
alt="Album art"
title="Album art"
>
</div>
<div class="metadata">
@ -26,17 +22,28 @@
<div class="song__artist" title="Artist">{{ artist }}</div>
{% endif %}
</div>
<div class="remove">
<button class="material-symbols-outlined" title="Remove" hx-delete="/queue?id={{ item.id }}">close</button>
</div>
</li>
{% endfor %}
</ul>
<script>
htmx.onLoad(() => {
const scrollCurrentSongIntoView = () => {
const hoveredSong = document.querySelector(".queue li:hover");
if (hoveredSong === null) {
const currentSong = document.querySelector(".queue li.playing");
currentSong?.scrollIntoView({ block: "nearest" });
}
}
const isReduced = window
.matchMedia("(prefers-reduced-motion: reduce)")
.matches;
new Sortable(document.querySelector(".queue"), {
new Sortable(document.querySelector(".queue ul"), {
animation: isReduced ? 0 : 100,
onEnd: (event) => fetch("/queue/move", {
method: "POST",
@ -44,5 +51,7 @@ htmx.onLoad(() => {
body: JSON.stringify({from: event.oldIndex, to: event.newIndex}),
}),
});
scrollCurrentSongIntoView();
});
</script>
</script>