Port Kaleido Desktop to macOS
macOS (Apple silicon) now plays, browses and updates like Windows: - Video: libmpv's render API draws into a CAOpenGLLayer beneath the WKWebView, with the miniplayer rectangle, HDR passthrough through extended dynamic range (PQ/BT.2020) and display-sleep prevention. - Window: native traffic lights on the top bar's centre line, hidden with the player's controls; the page's caption buttons are Windows-only. - Interface: macOS shortcut labels (⌘K, ⌘[, ⌃⌘F), Plex identifies the player as a Mac, and header values are kept ASCII (Mac computer names usually contain a curly apostrophe). - The window appears without waiting for an animation frame, which WKWebView doesn't run in a hidden window. - Credentials: release builds use the Keychain and are signed with a lasting self-signed certificate so access survives updates; debug builds keep tokens in a private file to avoid prompts on every rebuild. - Bundling: scripts/fetch-libmpv.sh makes Homebrew's libmpv and its libraries self-contained; scripts/build.sh builds the .app, .dmg and signed update archive. Releases now carry both platforms: publish-release.mjs uploads each machine's build into one release, and update-manifest.mjs writes the feed from that release's assets, refusing while a platform is missing. The updater uses a new signing key (public key in tauri.conf.json), so existing installs must be reinstalled once. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
a3c05e9062
commit
7d0803481b
39 changed files with 1191 additions and 230 deletions
|
|
@ -1,8 +1,8 @@
|
|||
name: Build Kaleido Desktop installers
|
||||
# Started by hand (Actions, then this workflow, then Run). Each platform needs a runner
|
||||
# with its label; without one the job would wait indefinitely, so this never runs on
|
||||
# push. Releases can instead be built with scripts/build.ps1 and published with
|
||||
# scripts/publish-release.mjs.
|
||||
# push. Releases can instead be built with scripts/build.ps1 (Windows) or
|
||||
# scripts/build.sh (macOS) and published with scripts/publish-release.mjs.
|
||||
on:
|
||||
workflow_dispatch:
|
||||
|
||||
|
|
@ -29,11 +29,14 @@ jobs:
|
|||
TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
|
||||
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
|
||||
run: ./scripts/build.ps1
|
||||
- name: Build (macOS / Linux)
|
||||
if: matrix.os != 'windows'
|
||||
- name: Build (macOS)
|
||||
if: matrix.os == 'macos'
|
||||
env:
|
||||
TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
|
||||
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
|
||||
run: sh scripts/build.sh
|
||||
- name: Build (Linux)
|
||||
if: matrix.os == 'linux'
|
||||
run: |
|
||||
sh scripts/fetch-libmpv.sh
|
||||
npm ci
|
||||
|
|
|
|||
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -10,5 +10,6 @@ vendor/mpv/*/
|
|||
.env
|
||||
.env.*
|
||||
evidence/
|
||||
.DS_Store
|
||||
*.log
|
||||
.claude/
|
||||
|
|
|
|||
19
AGENTS.md
19
AGENTS.md
|
|
@ -11,7 +11,7 @@
|
|||
- Keep the interface restrained: no redundant buttons or navigation.
|
||||
- `.env` (`PLEX_SERVER_URL`, `PLEX_TOKEN`) is for local testing only. Never print,
|
||||
commit or embed credentials. `.tools/updater.key` signs updates; never commit or
|
||||
replace it.
|
||||
replace it. `.tools/macos-signing.*` backs up the macOS signing certificate; same rules.
|
||||
- Shared code goes in `src/` and `src-tauri/src/`; anything OS-specific goes in
|
||||
`src-tauri/src/platform/<os>.rs` or `tauri.<os>.conf.json`.
|
||||
|
||||
|
|
@ -19,19 +19,20 @@
|
|||
|
||||
- `npm run typecheck`, `npm test`, `cargo check --manifest-path src-tauri/Cargo.toml`.
|
||||
- UI: `npm run dev` and a browser at http://localhost:1420 (signs in from `.env`).
|
||||
- Native: `npm run tauri dev` with `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9333`;
|
||||
`window.__kaleido` exposes the stores in development.
|
||||
- Native: `npm run tauri dev` (on Windows with `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9333`);
|
||||
`window.__kaleido` exposes the stores in development. On macOS the Rust toolchain is
|
||||
Homebrew's keg-only `rustup` (`export PATH=/opt/homebrew/opt/rustup/bin:$PATH`).
|
||||
- Mute before playback tests (`__kaleido.useSettings.getState().set('volume', 0)`).
|
||||
Playback changes real Plex progress and track selections; restore them.
|
||||
|
||||
## Releases
|
||||
|
||||
Built and published locally (CI only validates). In short: bump the version in
|
||||
`package.json`, `src-tauri/Cargo.toml`, `src-tauri/tauri.conf.json` (+ lockfile), add a
|
||||
`CHANGELOG.md` section, `.\scripts\build.ps1`, commit + tag `vX.Y.Z` + push,
|
||||
`node scripts/publish-release.mjs X.Y.Z [--prerelease]`, then
|
||||
`node scripts/update-manifest.mjs X.Y.Z <release download URL>` and commit/push
|
||||
`updates/latest.json`. Full checklist: `docs/development.md` → Releases. Only push or
|
||||
Built and published locally, Windows and macOS each on their own machine, into one
|
||||
release (CI only validates). In short: bump the version in `package.json`,
|
||||
`src-tauri/Cargo.toml`, `src-tauri/tauri.conf.json` (+ lockfile), add a `CHANGELOG.md`
|
||||
section, commit + tag `vX.Y.Z` + push; on each OS build (`.\scripts\build.ps1` /
|
||||
`sh scripts/build.sh`) and `node scripts/publish-release.mjs X.Y.Z [--prerelease]`; then
|
||||
`node scripts/update-manifest.mjs X.Y.Z` and commit/push `updates/latest.json`. Full checklist: `docs/development.md` → Releases. Only push or
|
||||
publish when the user asks. `FORGEJO_TOKEN` lives in the ignored `.env`.
|
||||
|
||||
See `docs/architecture.md` and `docs/development.md`.
|
||||
|
|
|
|||
26
README.md
26
README.md
|
|
@ -4,9 +4,10 @@ A cinematic Plex client for the desktop, built in the same artwork-led style as
|
|||
[Kaleido for Android TV](https://git.elijahkuntz.com/Elijah/Kaleido), and designed for
|
||||
mouse and keyboard.
|
||||
|
||||
Windows is supported today. The repository is structured for Windows, macOS and Linux:
|
||||
the interface and nearly all of the native core are shared, and each platform's
|
||||
differences live in one place (see [Architecture](docs/architecture.md)).
|
||||
Kaleido runs on Windows and macOS (Apple silicon) with the same interface and features;
|
||||
each release carries both, and installed copies update themselves. The interface and
|
||||
nearly all of the native core are shared, and each platform's differences live in one
|
||||
place (see [Architecture](docs/architecture.md)). Linux builds browse but don't play yet.
|
||||
|
||||
## What's in the app
|
||||
|
||||
|
|
@ -61,18 +62,20 @@ differences live in one place (see [Architecture](docs/architecture.md)).
|
|||
|
||||
| Browsing | | Player | |
|
||||
| --- | --- | --- | --- |
|
||||
| Ctrl+K | Search | Space / K | Play/pause |
|
||||
| Ctrl+K (⌘K) | Search | Space / K | Play/pause |
|
||||
| Arrow keys | Move between titles | ← / → | Seek (Shift: 1 min) |
|
||||
| Enter / Space | Open / play | ↑ / ↓, wheel | Volume |
|
||||
| Menu or Shift+F10 | Title actions | F, double-click | Full screen |
|
||||
| Alt+← / mouse back | Back | C | Next subtitle |
|
||||
| Alt+← (⌘[) / mouse back | Back | C | Next subtitle |
|
||||
| / | Focus search | Shift+N | Next episode |
|
||||
| F11 | Full screen | Esc | Exit full screen, then player |
|
||||
| F11 (⌃⌘F) | Full screen | Esc | Exit full screen, then player |
|
||||
|
||||
Keys in brackets are the macOS equivalents.
|
||||
|
||||
## Build from source
|
||||
|
||||
Requirements: Node 22+, Rust (stable), and on Windows the Visual Studio C++ build tools
|
||||
and 7-Zip.
|
||||
Requirements: Node 22+, Rust (stable); on Windows the Visual Studio C++ build tools and
|
||||
7-Zip, on macOS the Xcode command line tools and Homebrew.
|
||||
|
||||
```powershell
|
||||
npm ci
|
||||
|
|
@ -81,6 +84,13 @@ npm run tauri dev # development app
|
|||
.\scripts\build.ps1 # signed release installer (NSIS)
|
||||
```
|
||||
|
||||
```bash
|
||||
npm ci
|
||||
sh scripts/fetch-libmpv.sh # libmpv and its libraries into vendor/mpv/macos
|
||||
npm run tauri dev # development app
|
||||
sh scripts/build.sh # .app, .dmg and the signed update archive
|
||||
```
|
||||
|
||||
During development the app signs in automatically from an ignored `.env` in the
|
||||
repository root (`PLEX_SERVER_URL`, `PLEX_TOKEN`). Release builds never read it.
|
||||
`npm run dev` serves the interface alone in a browser for UI work (no playback or
|
||||
|
|
|
|||
|
|
@ -35,21 +35,34 @@ updates/latest.json Signed update feed for every platform
|
|||
`src-tauri/src/platform/mod.rs` selects one of `windows.rs`, `macos.rs` or `linux.rs`.
|
||||
Each exposes the same items:
|
||||
|
||||
| Item | Windows implementation |
|
||||
| --- | --- |
|
||||
| `VideoSurface` | mpv renders with `d3d11-output-mode=composition`; its swapchain (`display-swapchain`) is set as the content of a DirectComposition visual targeted at the window with `topmost = false`, i.e. behind the web view's child windows. For the miniplayer the visual is offset and mpv's composition size shrunk to a corner rectangle (`player_rect`). |
|
||||
| `MPV_LIBRARIES` | `libmpv-2.dll` |
|
||||
| `hold_awake` | `SetThreadExecutionState` while video plays |
|
||||
| Item | Windows | macOS |
|
||||
| --- | --- | --- |
|
||||
| `VideoSurface` | mpv renders with `d3d11-output-mode=composition`; its swapchain (`display-swapchain`) is set as the content of a DirectComposition visual targeted at the window with `topmost = false`, i.e. behind the web view's child windows. For the miniplayer the visual is offset and mpv's composition size shrunk to a corner rectangle (`player_rect`). | mpv's render API (`vo=libmpv`, OpenGL) draws into a `CAOpenGLLayer` hosted by a view inserted beneath the WKWebView, whose background is turned off (`drawsBackground`). `start` creates the render context once mpv is initialized; a render thread redraws the layer whenever mpv reports a new frame. For the miniplayer the view is moved to the corner rectangle. |
|
||||
| `MPV_LIBRARIES` | `libmpv-2.dll` | `libmpv.2.dylib` (in `Contents/Frameworks` with the libraries it links) |
|
||||
| `hold_awake` | `SetThreadExecutionState` | an IOKit `PreventUserIdleDisplaySleep` assertion |
|
||||
| Window buttons | drawn by the page (`WindowControls`) | the native traffic lights (`titleBarStyle: Overlay`, placed on the top bar's centre line); `set_window_buttons` hides them with the player's controls |
|
||||
| `device_name` | `COMPUTERNAME` | the computer name from Sharing settings |
|
||||
|
||||
macOS and Linux currently provide stubs for `VideoSurface` (browsing, downloads,
|
||||
settings and updates work; playback reports that it is unavailable). To add playback
|
||||
there, render through mpv's render API into a layer beneath the web view and implement
|
||||
the same methods (`set_rect` places the video in part of the window for the miniplayer). Per-OS bundling (libmpv, targets, dependencies) lives in
|
||||
`tauri.macos.conf.json` and `tauri.linux.conf.json`. Credentials use the platform's
|
||||
keychain through the `keyring` crate with per-OS features in `Cargo.toml`.
|
||||
Linux provides stubs for `VideoSurface` (browsing, downloads, settings and updates
|
||||
work; playback reports that it is unavailable); the macOS approach (render API beneath
|
||||
the web view) applies there with an OpenGL surface under WebKitGTK. Per-OS bundling
|
||||
(libmpv, targets, window style) lives in `tauri.<os>.conf.json`. Credentials use the
|
||||
platform's keychain through the `keyring` crate with per-OS features in `Cargo.toml`;
|
||||
macOS debug builds keep them in a private file instead, because each unsigned rebuild
|
||||
would make the Keychain ask again.
|
||||
|
||||
On Windows the main window is created transparent and the page background turns
|
||||
transparent only while video is visible (`html.video-active`), so browsing is opaque.
|
||||
The page background turns transparent only while video is visible
|
||||
(`html.video-active`), so browsing is opaque. The page knows its OS synchronously
|
||||
(`hostOS` in `platform/native.ts`, from the web view's user agent) and tags the root
|
||||
element (`html.os-macos`) for the few styles that differ, such as room for the traffic
|
||||
lights.
|
||||
|
||||
HDR passthrough (`target-colorspace-hint`) works differently on each OS. On Windows mpv
|
||||
switches its swapchain's colour space itself. On macOS the surface watches
|
||||
`video-params/gamma`: for PQ or HLG video it has mpv output PQ in BT.2020
|
||||
(`target-trc`, `target-prim`) into the 16-bit float framebuffer and turns on the layer's
|
||||
extended dynamic range with the BT.2100 PQ colour space, so macOS maps the picture
|
||||
into the display's HDR headroom; SDR video returns both to their defaults.
|
||||
|
||||
## Interface
|
||||
|
||||
|
|
@ -85,4 +98,5 @@ transparent only while video is visible (`html.video-active`), so browsing is op
|
|||
cached in the app cache folder (`gpu-shader-cache-dir`), so a slow first Direct3D
|
||||
compile happens once per shader set, mpv version and GPU driver.
|
||||
- **Updates**: `app/updater.ts` checks the signed feed on start; installs need the
|
||||
user's confirmation and then relaunch.
|
||||
user's confirmation and then relaunch. One release carries every platform's build and
|
||||
the feed lists each of them (`windows-x86_64`, `darwin-aarch64`).
|
||||
|
|
|
|||
|
|
@ -11,6 +11,22 @@
|
|||
debug builds and the Vite dev server. Never commit or print it.
|
||||
5. `npm run tauri dev`
|
||||
|
||||
## Setup (macOS)
|
||||
|
||||
1. Node 22+, Rust stable (`brew install rustup && rustup default stable`), the Xcode
|
||||
command line tools and Homebrew.
|
||||
2. `npm ci`
|
||||
3. `sh scripts/fetch-libmpv.sh` installs Homebrew's `mpv` and copies libmpv with every
|
||||
library it links into `vendor/mpv/macos`, rewritten to find each other there
|
||||
(`@loader_path`) and signed, so the bundle doesn't depend on Homebrew. Homebrew
|
||||
builds for the macOS it runs on, so the app's minimum macOS is that of the build
|
||||
machine (`scripts/build.sh` sets it from the libraries).
|
||||
4. `.env` as on Windows, then `npm run tauri dev`.
|
||||
|
||||
Debug builds on macOS keep the Plex token in `dev-secrets.json` in the app data folder
|
||||
rather than the Keychain: every rebuild is a new unsigned binary, which the Keychain
|
||||
would ask about again. Release builds always use the Keychain.
|
||||
|
||||
The interface alone runs in a browser with `npm run dev` (port 1420), which is handy for
|
||||
layout work; playback, downloads and native dialogs need the desktop app. In development
|
||||
builds the stores are available as `window.__kaleido` for debugging.
|
||||
|
|
@ -39,43 +55,67 @@ and copy back only the files already in `src-tauri/icons` (the Android and iOS s
|
|||
|
||||
## Releases
|
||||
|
||||
Releases are built and published from this Windows machine. CI only validates; it never
|
||||
builds installers on push (there are no Windows/macOS runners). Versions follow SemVer;
|
||||
betas use a prerelease suffix (`0.1.0-beta.1`) and are published as pre-releases.
|
||||
Releases are built and published locally: Windows on the Windows machine, macOS on the
|
||||
Mac. CI only validates; it never builds installers on push (there are no Windows/macOS
|
||||
runners). Versions follow SemVer; betas use a prerelease suffix (`0.1.0-beta.1`) and are
|
||||
published as pre-releases. **Each release carries both platforms**, and the update feed
|
||||
is written only once both are uploaded.
|
||||
|
||||
Checklist for version `X.Y.Z` (run from the repository root):
|
||||
|
||||
1. **Version**: set `X.Y.Z` in `package.json`, `src-tauri/Cargo.toml` and
|
||||
`src-tauri/tauri.conf.json`, then `npm install --package-lock-only` to update
|
||||
1. **Version** (either machine): set `X.Y.Z` in `package.json`, `src-tauri/Cargo.toml`
|
||||
and `src-tauri/tauri.conf.json`, then `npm install --package-lock-only` to update
|
||||
`package-lock.json`.
|
||||
2. **Changelog**: add a `## X.Y.Z` section at the top of `CHANGELOG.md`. It becomes the
|
||||
release notes and the in-app update notes.
|
||||
3. **Check**: `npm run typecheck`, `npm test`, `cargo check --manifest-path src-tauri/Cargo.toml`.
|
||||
4. **Build**: `.\scripts\build.ps1` → `src-tauri/target/release/bundle/nsis/Kaleido_X.Y.Z_x64-setup.exe`
|
||||
and its `.sig`. The updater key is read from `.tools/updater.key` (ignored; keep it
|
||||
safe — replacing it breaks in-app updates for existing installs) or from
|
||||
`TAURI_SIGNING_PRIVATE_KEY`.
|
||||
5. **Commit and tag**: commit as `Release Kaleido Desktop X.Y.Z`, then
|
||||
4. **Commit and tag**: commit as `Release Kaleido Desktop X.Y.Z`, then
|
||||
`git tag -a vX.Y.Z -m "Kaleido Desktop X.Y.Z"` and `git push origin main vX.Y.Z`
|
||||
(SSH remote `origin`, already configured).
|
||||
6. **Publish**: `node scripts/publish-release.mjs X.Y.Z` (add `--prerelease` for betas)
|
||||
creates the Forgejo release with the notes from `CHANGELOG.md` and uploads the
|
||||
installer and `.sig`. It reads `FORGEJO_TOKEN` (repository read/write) from the
|
||||
environment or the ignored `.env`, and never prints it. Re-running it replaces the
|
||||
assets.
|
||||
7. **Update feed**: `node scripts/update-manifest.mjs X.Y.Z https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/vX.Y.Z`
|
||||
rewrites `updates/latest.json`; commit it (`Publish the X.Y.Z update feed`) and push.
|
||||
Installed copies offer the update on their next start. Publish the feed only after
|
||||
the release assets exist, or clients would be sent to a missing file.
|
||||
8. **Verify**: download the installer from the release URL and compare its SHA-256 with
|
||||
the local file; `https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json`
|
||||
should show the new version; CI on Actions should finish green.
|
||||
(SSH remote `origin`, already configured). Pull it on the other machine.
|
||||
5. **Build and publish on Windows**: `.\scripts\build.ps1` →
|
||||
`src-tauri/target/release/bundle/nsis/Kaleido_X.Y.Z_x64-setup.exe` and its `.sig`;
|
||||
then `node scripts/publish-release.mjs X.Y.Z` (add `--prerelease` for betas) creates
|
||||
the Forgejo release with the notes from `CHANGELOG.md` and uploads them.
|
||||
6. **Build and publish on macOS**: `sh scripts/build.sh` → `bundle/dmg/Kaleido_X.Y.Z_aarch64.dmg`
|
||||
(first installs) and `bundle/macos/Kaleido_X.Y.Z_aarch64.app.tar.gz` with its `.sig`
|
||||
(updates); then `node scripts/publish-release.mjs X.Y.Z [--prerelease]` adds them to
|
||||
the same release. The order of 5 and 6 doesn't matter.
|
||||
7. **Update feed** (either machine): `node scripts/update-manifest.mjs X.Y.Z` reads the
|
||||
release's assets (downloading each `.sig`) and rewrites `updates/latest.json`; commit
|
||||
it (`Publish the X.Y.Z update feed`) and push. Installed copies offer the update on
|
||||
their next start. The script refuses while a platform's build is missing from the
|
||||
release, so neither OS is ever pointed at an older build; `--allow-missing` publishes
|
||||
the feed without it (that OS then sees no update until the feed is regenerated).
|
||||
8. **Verify**: download each artifact from the release and compare its SHA-256 with the
|
||||
local file; `https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json`
|
||||
should list both platforms at the new version; CI on Actions should finish green.
|
||||
|
||||
The installer is per user (`%LOCALAPPDATA%\Kaleido`, no admin) and is not code-signed,
|
||||
so SmartScreen warns on first run. In-app updates run it in passive mode and relaunch.
|
||||
Both publishing scripts read `FORGEJO_TOKEN` (repository read/write) from the
|
||||
environment or the ignored `.env`, and never print it. Re-running `publish-release.mjs`
|
||||
replaces that machine's assets.
|
||||
|
||||
For macOS and Linux, build on those systems (`scripts/fetch-libmpv.sh`, then
|
||||
`npx tauri build`) and merge their bundles into the same feed with `KALEIDO_BUNDLES`.
|
||||
`.forgejo/workflows/release.yml` validates every push and tag;
|
||||
**Update signing**: both build scripts sign update artifacts with the updater key from
|
||||
`.tools/updater.key` (ignored; keep it safe — replacing it breaks in-app updates for
|
||||
existing installs) or `TAURI_SIGNING_PRIVATE_KEY`. Both build machines need the same
|
||||
key in `.tools/`; without it a build has no update archive.
|
||||
|
||||
**Windows** installs per user (`%LOCALAPPDATA%\Kaleido`, no admin) and is not
|
||||
code-signed, so SmartScreen warns on first run. In-app updates run the installer in
|
||||
passive mode and relaunch.
|
||||
|
||||
**macOS** builds are signed with a self-signed certificate, "Kaleido Self-Signed", in
|
||||
the build Mac's login keychain (backed up, with its password, as
|
||||
`.tools/macos-signing.p12` and `.tools/macos-signing.password`). A lasting signature
|
||||
keeps the app's identity across updates, so the Keychain keeps trusting it with the
|
||||
Plex token; ad hoc signatures change with every build and would make macOS ask again
|
||||
after each update. To build on another Mac, import the backup:
|
||||
`security import .tools/macos-signing.p12 -k ~/Library/Keychains/login.keychain-db -P "$(cat .tools/macos-signing.password)" -T /usr/bin/codesign`.
|
||||
The app isn't notarized, so the first launch of a downloaded `.dmg` needs
|
||||
System Settings → Privacy & Security → Open Anyway (or right-click → Open); in-app
|
||||
updates aren't quarantined and install without that. Building runs Finder through
|
||||
AppleScript to lay out the disk image window; set `CI=true` to skip that step.
|
||||
|
||||
Linux can be built with `sh scripts/fetch-libmpv.sh` and `npx tauri build` but isn't
|
||||
published. `.forgejo/workflows/release.yml` validates every push and tag;
|
||||
`.forgejo/workflows/build-installers.yml` can build installers in CI once runners exist
|
||||
for each platform, and only runs when started by hand.
|
||||
|
|
|
|||
54
scripts/build.sh
Normal file
54
scripts/build.sh
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
#!/usr/bin/env sh
|
||||
# Builds Kaleido for macOS: the .app, a .dmg for first installs and the signed updater
|
||||
# archive, renamed Kaleido_<version>_<arch>.app.tar.gz for the release.
|
||||
# sh scripts/build.sh # release build
|
||||
# sh scripts/build.sh --debug # faster unoptimized build
|
||||
set -eu
|
||||
root=$(cd "$(dirname "$0")/.." && pwd)
|
||||
cd "$root"
|
||||
profile=release
|
||||
[ "${1:-}" = "--debug" ] && profile=debug
|
||||
|
||||
sh scripts/fetch-libmpv.sh
|
||||
|
||||
# The bundled libraries decide the oldest macOS Kaleido runs on (Homebrew builds them
|
||||
# for the macOS of the machine that installed them).
|
||||
minos=$(for f in vendor/mpv/macos/*.dylib; do otool -l "$f" | awk '/LC_BUILD_VERSION/{b=1} b&&/minos/{print $2; b=0}'; done | sort -V | tail -1)
|
||||
|
||||
# Signing with one lasting certificate keeps the app's identity across updates, so the
|
||||
# Keychain keeps trusting it with the Plex token (ad hoc signatures change every build).
|
||||
# "Kaleido Self-Signed" lives in the login keychain; .tools/macos-signing.p12 backs it up.
|
||||
identity=${KALEIDO_SIGNING_IDENTITY:-Kaleido Self-Signed}
|
||||
if security find-identity -p codesigning | grep -q "\"$identity\""; then
|
||||
codesign --force --sign "$identity" vendor/mpv/macos/*.dylib 2>/dev/null
|
||||
else
|
||||
echo "warning: no \"$identity\" signing certificate; signing ad hoc (the Keychain will ask again after updates)." >&2
|
||||
identity=-
|
||||
fi
|
||||
|
||||
# The updater signing key stays outside git (.tools/), as on Windows.
|
||||
updater=true
|
||||
if [ -z "${TAURI_SIGNING_PRIVATE_KEY:-}" ]; then
|
||||
if [ -f .tools/updater.key ]; then
|
||||
TAURI_SIGNING_PRIVATE_KEY=$(cat .tools/updater.key)
|
||||
TAURI_SIGNING_PRIVATE_KEY_PASSWORD=${TAURI_SIGNING_PRIVATE_KEY_PASSWORD:-}
|
||||
export TAURI_SIGNING_PRIVATE_KEY TAURI_SIGNING_PRIVATE_KEY_PASSWORD
|
||||
else
|
||||
echo "warning: no updater signing key (.tools/updater.key); building without update artifacts." >&2
|
||||
updater=false
|
||||
fi
|
||||
fi
|
||||
config="{\"bundle\":{\"createUpdaterArtifacts\":$updater,\"macOS\":{\"minimumSystemVersion\":\"$minos\",\"signingIdentity\":\"$identity\"}}}"
|
||||
|
||||
[ -d node_modules ] || npm ci
|
||||
if [ "$profile" = debug ]; then npx tauri build --debug --config "$config"; else npx tauri build --config "$config"; fi
|
||||
|
||||
version=$(node -p "require('./package.json').version")
|
||||
arch=$(uname -m | sed 's/arm64/aarch64/; s/x86_64/x64/')
|
||||
bundle="src-tauri/target/$profile/bundle"
|
||||
if [ -f "$bundle/macos/Kaleido.app.tar.gz" ]; then
|
||||
cp "$bundle/macos/Kaleido.app.tar.gz" "$bundle/macos/Kaleido_${version}_${arch}.app.tar.gz"
|
||||
cp "$bundle/macos/Kaleido.app.tar.gz.sig" "$bundle/macos/Kaleido_${version}_${arch}.app.tar.gz.sig"
|
||||
fi
|
||||
echo "Built for macOS $minos or later:"
|
||||
ls -l "$bundle/dmg" "$bundle/macos"
|
||||
|
|
@ -1,14 +1,39 @@
|
|||
#!/usr/bin/env sh
|
||||
# macOS: copies Homebrew's libmpv into vendor/mpv/macos for bundling.
|
||||
# macOS: copies Homebrew's libmpv and every library it links (ffmpeg, libplacebo, ...)
|
||||
# into vendor/mpv/macos, pointing them at each other with @loader_path so the folder is
|
||||
# self-contained; the bundle ships it as Contents/Frameworks.
|
||||
# Linux: libmpv comes from the system package (libmpv2); nothing to copy.
|
||||
set -eu
|
||||
root=$(cd "$(dirname "$0")/.." && pwd)
|
||||
case "$(uname -s)" in
|
||||
Darwin)
|
||||
out="$root/vendor/mpv/macos"
|
||||
if [ -f "$out/libmpv.2.dylib" ] && [ "${1:-}" != "--force" ]; then
|
||||
echo "libmpv already in vendor/mpv/macos (pass --force to refresh)"
|
||||
exit 0
|
||||
fi
|
||||
brew list mpv >/dev/null 2>&1 || brew install mpv
|
||||
mkdir -p "$root/vendor/mpv/macos"
|
||||
cp "$(brew --prefix mpv)/lib/libmpv.2.dylib" "$root/vendor/mpv/macos/"
|
||||
echo "libmpv copied to vendor/mpv/macos" ;;
|
||||
command -v dylibbundler >/dev/null 2>&1 || brew install dylibbundler
|
||||
rm -rf "$out" && mkdir -p "$out"
|
||||
cp "$(brew --prefix mpv)/lib/libmpv.2.dylib" "$out/"
|
||||
chmod u+w "$out/libmpv.2.dylib"
|
||||
install_name_tool -id @loader_path/libmpv.2.dylib "$out/libmpv.2.dylib"
|
||||
# -of: overwrite, -b: bundle dependencies, -x: fix this file, -d: where they go,
|
||||
# -p: how they're referenced, -s: also search Homebrew's lib folder for @rpath names.
|
||||
dylibbundler -of -b -x "$out/libmpv.2.dylib" -d "$out" -p @loader_path/ -s "$(brew --prefix)/lib" >/dev/null
|
||||
for f in "$out"/*.dylib; do
|
||||
# dylibbundler can repeat an rpath, which dyld refuses to load; keep one of each.
|
||||
for rpath in $(otool -l "$f" | awk '/cmd LC_RPATH/{getline; getline; print $2}' | sort | uniq -d); do
|
||||
while [ "$(otool -l "$f" | awk '/cmd LC_RPATH/{getline; getline; print $2}' | grep -cx "$rpath")" -gt 1 ]; do
|
||||
install_name_tool -delete_rpath "$rpath" "$f" 2>/dev/null
|
||||
done
|
||||
done
|
||||
# Rewriting load commands invalidates signatures; Apple silicon refuses unsigned code.
|
||||
codesign --force --sign - "$f" 2>/dev/null
|
||||
done
|
||||
# Homebrew builds for the macOS it runs on: the oldest macOS these libraries load on.
|
||||
minos=$(for f in "$out"/*.dylib; do otool -l "$f" | awk '/LC_BUILD_VERSION/{b=1} b&&/minos/{print $2; b=0}'; done | sort -V | tail -1)
|
||||
echo "libmpv and $(($(ls "$out" | wc -l) - 1)) libraries copied to vendor/mpv/macos (need macOS $minos or later)" ;;
|
||||
Linux)
|
||||
echo "Install libmpv from your distribution (e.g. apt install libmpv2 libmpv-dev)." ;;
|
||||
*) echo "Use scripts/fetch-libmpv.ps1 on Windows." ;;
|
||||
|
|
|
|||
|
|
@ -1,11 +1,12 @@
|
|||
// Creates (or reuses) a Forgejo release for a tag and uploads the Windows installer and
|
||||
// its updater signature. Reads FORGEJO_TOKEN from the environment or the ignored .env.
|
||||
// Creates (or reuses) a Forgejo release for a tag and uploads this machine's build of it:
|
||||
// the Windows installer, or the macOS disk image and updater archive, each with its
|
||||
// updater signature. Run it on each OS after building; both land in the same release.
|
||||
// Reads FORGEJO_TOKEN from the environment or the ignored .env.
|
||||
// Usage: node scripts/publish-release.mjs <version> [--prerelease]
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { api, bundleDir, releaseNotes, token } from './release-common.mjs';
|
||||
|
||||
const API = 'https://git.elijahkuntz.com/api/v1/repos/Elijah/Kaleido-Desktop';
|
||||
const root = path.resolve(import.meta.dirname, '..');
|
||||
const version = process.argv[2];
|
||||
const prerelease = process.argv.includes('--prerelease');
|
||||
if (!version) {
|
||||
|
|
@ -13,43 +14,38 @@ if (!version) {
|
|||
process.exit(1);
|
||||
}
|
||||
|
||||
let token = process.env.FORGEJO_TOKEN;
|
||||
if (!token && fs.existsSync(path.join(root, '.env'))) {
|
||||
token = fs.readFileSync(path.join(root, '.env'), 'utf8').match(/^FORGEJO_TOKEN=(.*)$/m)?.[1]?.trim().replace(/^"|"$/g, '');
|
||||
/** This version's release files as built on this OS (scripts/build.ps1 or scripts/build.sh). */
|
||||
function builtFiles() {
|
||||
if (process.platform === 'win32') {
|
||||
const dir = path.join(bundleDir, 'nsis');
|
||||
return [`Kaleido_${version}_x64-setup.exe`, `Kaleido_${version}_x64-setup.exe.sig`].map((n) => path.join(dir, n));
|
||||
}
|
||||
if (process.platform === 'darwin') {
|
||||
const arch = process.arch === 'arm64' ? 'aarch64' : 'x64';
|
||||
return [
|
||||
path.join(bundleDir, 'dmg', `Kaleido_${version}_${arch}.dmg`),
|
||||
path.join(bundleDir, 'macos', `Kaleido_${version}_${arch}.app.tar.gz`),
|
||||
path.join(bundleDir, 'macos', `Kaleido_${version}_${arch}.app.tar.gz.sig`),
|
||||
];
|
||||
}
|
||||
throw new Error('Publish releases from Windows or macOS.');
|
||||
}
|
||||
if (!token) {
|
||||
console.error('FORGEJO_TOKEN is not set.');
|
||||
process.exit(1);
|
||||
}
|
||||
const headers = { Authorization: `token ${token}`, Accept: 'application/json' };
|
||||
|
||||
async function api(method, url, body) {
|
||||
const r = await fetch(url.startsWith('http') ? url : API + url, {
|
||||
method,
|
||||
headers: body instanceof FormData ? headers : { ...headers, 'Content-Type': 'application/json' },
|
||||
body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
|
||||
});
|
||||
const text = await r.text();
|
||||
if (!r.ok) throw new Error(`${method} ${url} → ${r.status} ${text.slice(0, 300)}`);
|
||||
return text ? JSON.parse(text) : null;
|
||||
token(true);
|
||||
const files = builtFiles();
|
||||
for (const file of files) {
|
||||
if (!fs.existsSync(file)) throw new Error(`Missing ${file}; build this version first.`);
|
||||
}
|
||||
|
||||
const tag = `v${version}`;
|
||||
const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
|
||||
const section = changelog.split(/^## /m).find((s) => s.startsWith(version));
|
||||
const notes = section ? section.slice(version.length).trim() : '';
|
||||
|
||||
let release = await api('GET', `/releases/tags/${tag}`).catch(() => null);
|
||||
if (!release) {
|
||||
release = await api('POST', '/releases', { tag_name: tag, name: `Kaleido Desktop ${version}`, body: notes, prerelease, draft: false });
|
||||
release = await api('POST', '/releases', { tag_name: tag, name: `Kaleido Desktop ${version}`, body: releaseNotes(version), prerelease, draft: false });
|
||||
console.log(`Created release ${release.name}`);
|
||||
} else console.log(`Using existing release ${release.name}`);
|
||||
|
||||
const dir = path.join(root, 'src-tauri/target/release/bundle/nsis');
|
||||
const files = [`Kaleido_${version}_x64-setup.exe`, `Kaleido_${version}_x64-setup.exe.sig`];
|
||||
for (const name of files) {
|
||||
const file = path.join(dir, name);
|
||||
if (!fs.existsSync(file)) throw new Error(`Missing ${file}; run scripts/build.ps1 first.`);
|
||||
for (const file of files) {
|
||||
const name = path.basename(file);
|
||||
const existing = release.assets?.find((a) => a.name === name);
|
||||
if (existing) await api('DELETE', `/releases/${release.id}/assets/${existing.id}`);
|
||||
const form = new FormData();
|
||||
|
|
|
|||
49
scripts/release-common.mjs
Normal file
49
scripts/release-common.mjs
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
// Shared by the release scripts: the Forgejo API (FORGEJO_TOKEN from the environment or
|
||||
// the ignored .env, never printed), release notes and the bundle folder.
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
export const API = 'https://git.elijahkuntz.com/api/v1/repos/Elijah/Kaleido-Desktop';
|
||||
export const root = path.resolve(import.meta.dirname, '..');
|
||||
export const bundleDir = path.join(root, 'src-tauri/target/release/bundle');
|
||||
|
||||
/** FORGEJO_TOKEN; reads of a public repository work without it, uploads don't. */
|
||||
export function token(required = false) {
|
||||
let t = process.env.FORGEJO_TOKEN;
|
||||
if (!t && fs.existsSync(path.join(root, '.env'))) {
|
||||
t = fs.readFileSync(path.join(root, '.env'), 'utf8').match(/^FORGEJO_TOKEN=(.*)$/m)?.[1]?.trim().replace(/^"|"$/g, '');
|
||||
}
|
||||
if (!t && required) {
|
||||
console.error('FORGEJO_TOKEN is not set.');
|
||||
process.exit(1);
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
const auth = () => (token() ? { Authorization: `token ${token()}` } : {});
|
||||
|
||||
export async function api(method, url, body) {
|
||||
const headers = { ...auth(), Accept: 'application/json' };
|
||||
const r = await fetch(url.startsWith('http') ? url : API + url, {
|
||||
method,
|
||||
headers: body instanceof FormData ? headers : { ...headers, 'Content-Type': 'application/json' },
|
||||
body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
|
||||
});
|
||||
const text = await r.text();
|
||||
if (!r.ok) throw new Error(`${method} ${url} → ${r.status} ${text.slice(0, 300)}`);
|
||||
return text ? JSON.parse(text) : null;
|
||||
}
|
||||
|
||||
/** Downloads a release asset's text (an updater signature). */
|
||||
export async function download(url) {
|
||||
const r = await fetch(url, { headers: auth() });
|
||||
if (!r.ok) throw new Error(`GET ${url} → ${r.status}`);
|
||||
return r.text();
|
||||
}
|
||||
|
||||
/** The version's section of CHANGELOG.md. */
|
||||
export function releaseNotes(version) {
|
||||
const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
|
||||
const section = changelog.split(/^## /m).find((s) => s.startsWith(version));
|
||||
return section ? section.slice(version.length).trim() : '';
|
||||
}
|
||||
|
|
@ -1,53 +1,56 @@
|
|||
// Writes updates/latest.json, the feed Kaleido's updater reads, from built bundles.
|
||||
// Usage: node scripts/update-manifest.mjs <version> <baseDownloadUrl> [notesFile]
|
||||
// Notes come from the version's CHANGELOG.md section unless a notes file is given.
|
||||
// Each platform's signed artifact (and its .sig) must be in src-tauri/target/release/bundle,
|
||||
// or pass several bundle folders via KALEIDO_BUNDLES (path;path) when collecting CI outputs.
|
||||
// Writes updates/latest.json, the feed Kaleido's updater reads, from a published release:
|
||||
// each platform's updater artifact and signature are taken from the release's assets, so
|
||||
// the feed only ever points at this version's files, whichever machine runs it.
|
||||
// Usage: node scripts/update-manifest.mjs <version> [--allow-missing] [notesFile]
|
||||
// Every platform in PLATFORMS must be in the release (publish from each OS first);
|
||||
// --allow-missing writes the feed anyway, leaving the missing platforms out of it, so
|
||||
// their installs simply see no update until the feed is regenerated.
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { api, download, releaseNotes, root } from './release-common.mjs';
|
||||
|
||||
const [version, baseUrl, notesFile] = process.argv.slice(2);
|
||||
if (!version || !baseUrl) {
|
||||
console.error('usage: node scripts/update-manifest.mjs <version> <baseDownloadUrl> [notesFile]');
|
||||
const args = process.argv.slice(2);
|
||||
const allowMissing = args.includes('--allow-missing');
|
||||
const [version, notesFile] = args.filter((a) => !a.startsWith('--'));
|
||||
if (!version) {
|
||||
console.error('usage: node scripts/update-manifest.mjs <version> [--allow-missing] [notesFile]');
|
||||
process.exit(1);
|
||||
}
|
||||
const root = path.resolve(import.meta.dirname, '..');
|
||||
const bundles = (process.env.KALEIDO_BUNDLES ?? path.join(root, 'src-tauri/target/release/bundle')).split(';');
|
||||
|
||||
/** Tauri updater platform keys and the artifact each one installs. */
|
||||
/** Tauri updater platform keys and the release asset each one installs. */
|
||||
const PLATFORMS = [
|
||||
{ key: 'windows-x86_64', dir: 'nsis', match: /-setup\.exe$/ },
|
||||
{ key: 'darwin-aarch64', dir: 'macos', match: /aarch64.*\.app\.tar\.gz$/ },
|
||||
{ key: 'darwin-x86_64', dir: 'macos', match: /x64.*\.app\.tar\.gz$/ },
|
||||
{ key: 'linux-x86_64', dir: 'appimage', match: /\.AppImage$/ },
|
||||
{ key: 'windows-x86_64', match: (f) => f === `Kaleido_${version}_x64-setup.exe` },
|
||||
{ key: 'darwin-aarch64', match: (f) => f === `Kaleido_${version}_aarch64.app.tar.gz` },
|
||||
];
|
||||
|
||||
const manifestPath = path.join(root, 'updates/latest.json');
|
||||
const manifest = fs.existsSync(manifestPath) ? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : { platforms: {} };
|
||||
manifest.version = version;
|
||||
// Notes default to this version's section of CHANGELOG.md.
|
||||
const changelogNotes = () => {
|
||||
const section = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8').split(/^## /m).find((x) => x.startsWith(version));
|
||||
return section ? section.slice(version.length).trim() : '';
|
||||
};
|
||||
manifest.notes = notesFile ? fs.readFileSync(notesFile, 'utf8').trim() : changelogNotes();
|
||||
manifest.pub_date = new Date().toISOString();
|
||||
manifest.platforms ??= {};
|
||||
const release = await api('GET', `/releases/tags/v${version}`).catch(() => null);
|
||||
if (!release) throw new Error(`No release v${version}; publish it with scripts/publish-release.mjs first.`);
|
||||
const assets = release.assets ?? [];
|
||||
|
||||
for (const bundle of bundles) {
|
||||
for (const p of PLATFORMS) {
|
||||
const dir = path.join(bundle, p.dir);
|
||||
if (!fs.existsSync(dir)) continue;
|
||||
const file = fs.readdirSync(dir).find((f) => p.match.test(f) && f.includes(version));
|
||||
if (!file || !fs.existsSync(path.join(dir, `${file}.sig`))) continue;
|
||||
manifest.platforms[p.key] = {
|
||||
signature: fs.readFileSync(path.join(dir, `${file}.sig`), 'utf8').trim(),
|
||||
url: `${baseUrl.replace(/\/$/, '')}/${encodeURIComponent(file)}`,
|
||||
};
|
||||
console.log(`${p.key}: ${file}`);
|
||||
const platforms = {};
|
||||
const missing = [];
|
||||
for (const p of PLATFORMS) {
|
||||
const artifact = assets.find((a) => p.match(a.name));
|
||||
const sig = artifact && assets.find((a) => a.name === `${artifact.name}.sig`);
|
||||
if (!artifact || !sig) {
|
||||
missing.push(p.key);
|
||||
continue;
|
||||
}
|
||||
platforms[p.key] = { signature: (await download(sig.browser_download_url)).trim(), url: artifact.browser_download_url };
|
||||
console.log(`${p.key}: ${artifact.name}`);
|
||||
}
|
||||
if (missing.length && !allowMissing) {
|
||||
console.error(`v${version} has no build for ${missing.join(', ')}. Publish it from that OS, or pass --allow-missing.`);
|
||||
process.exit(1);
|
||||
}
|
||||
if (!Object.keys(platforms).length) throw new Error(`v${version} has no updater artifacts.`);
|
||||
|
||||
fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
|
||||
const manifest = {
|
||||
version,
|
||||
notes: notesFile ? fs.readFileSync(notesFile, 'utf8').trim() : releaseNotes(version),
|
||||
pub_date: new Date().toISOString(),
|
||||
platforms,
|
||||
};
|
||||
const manifestPath = path.join(root, 'updates/latest.json');
|
||||
fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
|
||||
console.log(`Wrote ${path.relative(root, manifestPath)}`);
|
||||
console.log(`Wrote ${path.relative(root, manifestPath)}${missing.length ? ` (without ${missing.join(', ')})` : ''}`);
|
||||
|
|
|
|||
55
src-tauri/Cargo.lock
generated
55
src-tauri/Cargo.lock
generated
|
|
@ -2180,6 +2180,14 @@ dependencies = [
|
|||
"keyring",
|
||||
"libloading 0.8.9",
|
||||
"log",
|
||||
"objc2",
|
||||
"objc2-app-kit",
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-graphics",
|
||||
"objc2-core-video",
|
||||
"objc2-foundation",
|
||||
"objc2-open-gl",
|
||||
"objc2-quartz-core",
|
||||
"once_cell",
|
||||
"parking_lot",
|
||||
"reqwest 0.12.28",
|
||||
|
|
@ -2605,8 +2613,15 @@ checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
|
|||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"block2",
|
||||
"libc",
|
||||
"objc2",
|
||||
"objc2-cloud-kit",
|
||||
"objc2-core-data",
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-graphics",
|
||||
"objc2-core-image",
|
||||
"objc2-core-text",
|
||||
"objc2-core-video",
|
||||
"objc2-foundation",
|
||||
"objc2-quartz-core",
|
||||
]
|
||||
|
|
@ -2628,6 +2643,7 @@ version = "0.3.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"objc2",
|
||||
"objc2-foundation",
|
||||
]
|
||||
|
|
@ -2688,6 +2704,19 @@ dependencies = [
|
|||
"objc2-core-graphics",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "objc2-core-video"
|
||||
version = "0.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"objc2",
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-graphics",
|
||||
"objc2-io-surface",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "objc2-encode"
|
||||
version = "4.1.0"
|
||||
|
|
@ -2727,6 +2756,26 @@ dependencies = [
|
|||
"objc2-core-foundation",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "objc2-metal"
|
||||
version = "0.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"objc2",
|
||||
"objc2-foundation",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "objc2-open-gl"
|
||||
version = "0.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ecc7fd7519a189d9ba9ed9de51af81e41d096aea1d08cca59fd9d8c65d8f585"
|
||||
dependencies = [
|
||||
"objc2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "objc2-osa-kit"
|
||||
version = "0.3.2"
|
||||
|
|
@ -2746,9 +2795,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"block2",
|
||||
"libc",
|
||||
"objc2",
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-graphics",
|
||||
"objc2-core-video",
|
||||
"objc2-foundation",
|
||||
"objc2-metal",
|
||||
"objc2-open-gl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
|
|||
|
|
@ -34,6 +34,14 @@ log = "0.4"
|
|||
# Credentials use each OS's native store: Credential Manager, Keychain, Secret Service.
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
keyring = { version = "3", features = ["apple-native"] }
|
||||
objc2 = "0.6"
|
||||
objc2-foundation = { version = "0.3", features = ["NSGeometry", "NSString", "NSValue", "NSHost", "NSProcessInfo", "NSKeyValueCoding"] }
|
||||
objc2-core-foundation = { version = "0.3", default-features = false, features = ["std", "CFDate", "CFString"] }
|
||||
objc2-app-kit = { version = "0.3", features = ["NSView", "NSWindow", "NSResponder", "NSButton", "NSControl", "NSGraphics"] }
|
||||
objc2-quartz-core = { version = "0.3", features = ["CALayer", "CAOpenGLLayer", "CATransaction", "CAMediaTiming", "objc2-open-gl", "objc2-core-video", "objc2-core-graphics"] }
|
||||
objc2-core-graphics = { version = "0.3", default-features = false, features = ["std", "CGColorSpace"] }
|
||||
objc2-open-gl = { version = "0.3", default-features = false, features = ["std", "CGLTypes", "CGLCurrent"] }
|
||||
objc2-core-video = { version = "0.3", default-features = false, features = ["std", "CVBase"] }
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
keyring = { version = "3", features = ["sync-secret-service", "crypto-rust"] }
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ pub fn run() {
|
|||
player::player_command,
|
||||
player::player_set,
|
||||
player::player_get,
|
||||
player::window_buttons,
|
||||
system::secret_get,
|
||||
system::secret_set,
|
||||
system::secret_delete,
|
||||
|
|
|
|||
|
|
@ -192,6 +192,21 @@ impl Mpv {
|
|||
}
|
||||
}
|
||||
|
||||
/// The raw client handle, for platform code using parts of libmpv this
|
||||
/// binding doesn't wrap (the render API).
|
||||
pub fn raw_handle(&self) -> *mut c_void {
|
||||
self.handle
|
||||
}
|
||||
|
||||
/// Looks up another libmpv function by name.
|
||||
///
|
||||
/// # Safety
|
||||
/// `T` must be the function's exact pointer type.
|
||||
pub unsafe fn symbol<T: Copy>(&self, name: &str) -> Option<T> {
|
||||
let name = CString::new(name).ok()?;
|
||||
self.api._lib.get::<T>(name.as_bytes_with_nul()).ok().map(|s| *s)
|
||||
}
|
||||
|
||||
fn error(&self, code: c_int) -> String {
|
||||
unsafe { CStr::from_ptr((self.api.error_string)(code)).to_string_lossy().into_owned() }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
//! Linux: render mpv through its render API (OpenGL) beneath the WebKitGTK
|
||||
//! view, then implement `VideoSurface` here.
|
||||
//! view, then implement `VideoSurface` here (see macos.rs for the same idea).
|
||||
//!
|
||||
//! Browsing, downloads, settings and updates already work here; only native
|
||||
//! video composition remains to be written.
|
||||
|
|
@ -20,8 +20,11 @@ impl VideoSurface {
|
|||
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
|
||||
Vec::new()
|
||||
}
|
||||
pub fn start(&mut self, _: &std::sync::Arc<Mpv>) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
pub fn on_property(&mut self, _: &str, _: &serde_json::Value) {}
|
||||
pub fn show(&mut self, _: bool) {}
|
||||
pub fn show<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: bool) {}
|
||||
pub fn fit<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>) {}
|
||||
pub fn set_rect<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>, _: Option<(i32, i32, i32, i32)>) {}
|
||||
}
|
||||
|
|
@ -31,6 +34,16 @@ pub fn gpu_names() -> Vec<String> {
|
|||
Vec::new()
|
||||
}
|
||||
|
||||
pub fn device_name() -> String {
|
||||
std::fs::read_to_string("/etc/hostname").map(|h| h.trim().to_string()).ok().filter(|h| !h.is_empty()).unwrap_or_else(|| "Linux PC".into())
|
||||
}
|
||||
|
||||
pub fn os_version() -> String {
|
||||
String::new()
|
||||
}
|
||||
|
||||
pub fn set_window_buttons<R: Runtime>(_: &WebviewWindow<R>, _: bool) {}
|
||||
|
||||
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
|
||||
// TODO(Linux): org.freedesktop.ScreenSaver.Inhibit over D-Bus.
|
||||
let _ = rx.recv();
|
||||
|
|
|
|||
|
|
@ -1,37 +1,531 @@
|
|||
//! macOS: render mpv through its render API (libplacebo) into a CAMetalLayer
|
||||
//! placed beneath the WKWebView, then implement `VideoSurface` here.
|
||||
//! macOS: libmpv's render API (OpenGL) draws into a CAOpenGLLayer hosted by a
|
||||
//! view placed beneath the WKWebView; libmpv names, power assertions, window
|
||||
//! buttons and host details.
|
||||
//!
|
||||
//! Browsing, downloads, settings and updates already work here; only native
|
||||
//! video composition remains to be written.
|
||||
//! OpenGL is deprecated on macOS but still supported (on Metal); it is the
|
||||
//! render API libmpv offers, and what IINA and other mpv front ends use.
|
||||
#![allow(deprecated)]
|
||||
|
||||
use std::ffi::{c_char, c_int, c_void, CStr};
|
||||
use std::ptr::{self, NonNull};
|
||||
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
|
||||
use std::sync::Arc;
|
||||
|
||||
use objc2::rc::Retained;
|
||||
use objc2::{define_class, msg_send, AllocAnyThread, DefinedClass, MainThreadMarker};
|
||||
use objc2_app_kit::{NSAutoresizingMaskOptions, NSView, NSWindow, NSWindowButton, NSWindowOrderingMode};
|
||||
use objc2_core_foundation::CFTimeInterval;
|
||||
use objc2_core_graphics::{kCGColorSpaceITUR_2100_PQ, CGColorSpace};
|
||||
use objc2_core_video::CVTimeStamp;
|
||||
use objc2_foundation::{NSNumber, NSPoint, NSRect, NSSize, NSString};
|
||||
use objc2_open_gl::*;
|
||||
use objc2_quartz_core::{CALayer, CAOpenGLLayer, CATransaction};
|
||||
use parking_lot::Mutex;
|
||||
use tauri::{Runtime, WebviewWindow};
|
||||
|
||||
use crate::mpv::Mpv;
|
||||
|
||||
pub const SURFACE_PROPERTIES: &[&str] = &[];
|
||||
pub const MPV_LIBRARIES: &[&str] = &["libmpv.2.dylib", "libmpv.dylib"];
|
||||
// —— OpenGL ————————————————————————————————————————————————————————————
|
||||
|
||||
pub struct VideoSurface;
|
||||
const GL_COLOR_BUFFER_BIT: u32 = 0x4000;
|
||||
const GL_VIEWPORT: u32 = 0x0BA2;
|
||||
const GL_DRAW_FRAMEBUFFER_BINDING: u32 = 0x8CA6;
|
||||
const GL_RGBA16F: c_int = 0x881A;
|
||||
const RTLD_LAZY: c_int = 0x1;
|
||||
|
||||
impl VideoSurface {
|
||||
pub fn create<R: Runtime>(_: &WebviewWindow<R>) -> Result<VideoSurface, String> {
|
||||
Err("Video playback is not available on this platform yet.".into())
|
||||
}
|
||||
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
|
||||
Vec::new()
|
||||
}
|
||||
pub fn on_property(&mut self, _: &str, _: &serde_json::Value) {}
|
||||
pub fn show(&mut self, _: bool) {}
|
||||
pub fn fit<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>) {}
|
||||
pub fn set_rect<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>, _: Option<(i32, i32, i32, i32)>) {}
|
||||
#[link(name = "OpenGL", kind = "framework")]
|
||||
extern "C" {
|
||||
fn glGetIntegerv(pname: u32, data: *mut i32);
|
||||
fn glClearColor(r: f32, g: f32, b: f32, a: f32);
|
||||
fn glClear(mask: u32);
|
||||
fn glFlush();
|
||||
}
|
||||
|
||||
/// Not needed yet: the only GPU-specific tier (RTX Video) is Windows-only.
|
||||
extern "C" {
|
||||
fn dlopen(path: *const c_char, mode: c_int) -> *mut c_void;
|
||||
fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void;
|
||||
}
|
||||
|
||||
/// mpv resolves OpenGL functions through this (`ctx` is OpenGL.framework's handle).
|
||||
extern "C" fn get_proc_address(ctx: *mut c_void, name: *const c_char) -> *mut c_void {
|
||||
unsafe { dlsym(ctx, name) }
|
||||
}
|
||||
|
||||
/// A 3.2 core context; 16-bit float colour (needed for HDR) when the renderer
|
||||
/// offers it. Returns whether it got float colour.
|
||||
unsafe fn create_gl_context() -> Result<(CGLContextObj, CGLPixelFormatObj, bool), String> {
|
||||
let base = [
|
||||
CGLPixelFormatAttribute::CGLPFAOpenGLProfile.0,
|
||||
CGLOpenGLProfile::CGLOGLPVersion_3_2_Core.0,
|
||||
CGLPixelFormatAttribute::CGLPFAAccelerated.0,
|
||||
CGLPixelFormatAttribute::CGLPFADoubleBuffer.0,
|
||||
CGLPixelFormatAttribute::CGLPFAAllowOfflineRenderers.0,
|
||||
CGLPixelFormatAttribute::CGLPFASupportsAutomaticGraphicsSwitching.0,
|
||||
];
|
||||
let deep = [CGLPixelFormatAttribute::CGLPFAColorSize.0, 64, CGLPixelFormatAttribute::CGLPFAColorFloat.0];
|
||||
for extra in [&deep[..], &[]] {
|
||||
let mut attrs: Vec<CGLPixelFormatAttribute> = base.iter().chain(extra).map(|&a| CGLPixelFormatAttribute(a)).collect();
|
||||
attrs.push(CGLPixelFormatAttribute(0));
|
||||
let mut pf: CGLPixelFormatObj = ptr::null_mut();
|
||||
let mut count = 0;
|
||||
CGLChoosePixelFormat(NonNull::new_unchecked(attrs.as_mut_ptr()), NonNull::from(&mut pf), NonNull::from(&mut count));
|
||||
if pf.is_null() {
|
||||
continue;
|
||||
}
|
||||
let mut ctx: CGLContextObj = ptr::null_mut();
|
||||
CGLCreateContext(pf, ptr::null_mut(), NonNull::from(&mut ctx));
|
||||
if !ctx.is_null() {
|
||||
return Ok((ctx, pf, !extra.is_empty()));
|
||||
}
|
||||
CGLReleasePixelFormat(pf);
|
||||
}
|
||||
Err("OpenGL is unavailable, so video can't be shown.".into())
|
||||
}
|
||||
|
||||
// —— mpv render API ————————————————————————————————————————————————————
|
||||
|
||||
const RENDER_PARAM_API_TYPE: c_int = 1;
|
||||
const RENDER_PARAM_OPENGL_INIT_PARAMS: c_int = 2;
|
||||
const RENDER_PARAM_OPENGL_FBO: c_int = 3;
|
||||
const RENDER_PARAM_FLIP_Y: c_int = 4;
|
||||
const RENDER_UPDATE_FRAME: u64 = 1;
|
||||
|
||||
#[repr(C)]
|
||||
struct RenderParam {
|
||||
kind: c_int,
|
||||
data: *mut c_void,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct OpenGlInitParams {
|
||||
get_proc_address: extern "C" fn(*mut c_void, *const c_char) -> *mut c_void,
|
||||
get_proc_address_ctx: *mut c_void,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct OpenGlFbo {
|
||||
fbo: c_int,
|
||||
w: c_int,
|
||||
h: c_int,
|
||||
internal_format: c_int,
|
||||
}
|
||||
|
||||
type RenderCtx = *mut c_void;
|
||||
|
||||
/// An mpv render context and the functions that drive it. Every call happens
|
||||
/// with the layer's OpenGL context locked and current, as libmpv requires.
|
||||
struct Render {
|
||||
ctx: RenderCtx,
|
||||
render: unsafe extern "C" fn(RenderCtx, *mut RenderParam) -> c_int,
|
||||
update: unsafe extern "C" fn(RenderCtx) -> u64,
|
||||
report_swap: unsafe extern "C" fn(RenderCtx),
|
||||
}
|
||||
|
||||
unsafe impl Send for Render {}
|
||||
unsafe impl Sync for Render {}
|
||||
|
||||
/// libmpv calls this from its own threads when a frame is ready; it may not
|
||||
/// call back into libmpv, so it only wakes the render thread.
|
||||
extern "C" fn on_update(wake: *mut c_void) {
|
||||
let wake = unsafe { &*(wake as *const SyncSender<()>) };
|
||||
let _ = wake.try_send(());
|
||||
}
|
||||
|
||||
// —— The video layer ———————————————————————————————————————————————————
|
||||
|
||||
struct LayerIvars {
|
||||
cgl: CGLContextObj,
|
||||
pixel_format: CGLPixelFormatObj,
|
||||
/// The framebuffer holds 16-bit floats (so mpv needn't dither to 8 bits).
|
||||
float: bool,
|
||||
render: Mutex<Option<Arc<Render>>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(CAOpenGLLayer, CALayer))]
|
||||
#[name = "KaleidoVideoLayer"]
|
||||
#[ivars = LayerIvars]
|
||||
struct VideoLayer;
|
||||
|
||||
impl VideoLayer {
|
||||
#[unsafe(method(copyCGLPixelFormatForDisplayMask:))]
|
||||
fn copy_pixel_format(&self, _mask: u32) -> CGLPixelFormatObj {
|
||||
unsafe { CGLRetainPixelFormat(self.ivars().pixel_format) }
|
||||
}
|
||||
|
||||
#[unsafe(method(copyCGLContextForPixelFormat:))]
|
||||
fn copy_context(&self, _pf: CGLPixelFormatObj) -> CGLContextObj {
|
||||
unsafe { CGLRetainContext(self.ivars().cgl) }
|
||||
}
|
||||
|
||||
#[unsafe(method(releaseCGLContext:))]
|
||||
fn release_context(&self, ctx: CGLContextObj) {
|
||||
unsafe { CGLReleaseContext(ctx) }
|
||||
}
|
||||
|
||||
#[unsafe(method(canDrawInCGLContext:pixelFormat:forLayerTime:displayTime:))]
|
||||
fn can_draw(&self, _ctx: CGLContextObj, _pf: CGLPixelFormatObj, _t: CFTimeInterval, _ts: *const CVTimeStamp) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[unsafe(method(drawInCGLContext:pixelFormat:forLayerTime:displayTime:))]
|
||||
fn draw(&self, ctx: CGLContextObj, _pf: CGLPixelFormatObj, _t: CFTimeInterval, _ts: *const CVTimeStamp) {
|
||||
let render = self.ivars().render.lock().clone();
|
||||
unsafe {
|
||||
CGLLockContext(ctx);
|
||||
CGLSetCurrentContext(ctx);
|
||||
match render {
|
||||
Some(r) => {
|
||||
let mut fbo = 0;
|
||||
let mut viewport = [0i32; 4];
|
||||
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &mut fbo);
|
||||
glGetIntegerv(GL_VIEWPORT, viewport.as_mut_ptr());
|
||||
let mut target = OpenGlFbo { fbo, w: viewport[2], h: viewport[3], internal_format: if self.ivars().float { GL_RGBA16F } else { 0 } };
|
||||
let mut flip: c_int = 1;
|
||||
let mut params = [
|
||||
RenderParam { kind: RENDER_PARAM_OPENGL_FBO, data: &mut target as *mut _ as *mut c_void },
|
||||
RenderParam { kind: RENDER_PARAM_FLIP_Y, data: &mut flip as *mut _ as *mut c_void },
|
||||
RenderParam { kind: 0, data: ptr::null_mut() },
|
||||
];
|
||||
(r.render)(r.ctx, params.as_mut_ptr());
|
||||
}
|
||||
None => {
|
||||
glClearColor(0.0, 0.0, 0.0, 1.0);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
}
|
||||
}
|
||||
glFlush();
|
||||
CGLUnlockContext(ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// The layer is drawn from the render thread as well as by Core Animation;
|
||||
// its mutable state is behind a mutex and the CGL context lock.
|
||||
unsafe impl Send for VideoLayer {}
|
||||
unsafe impl Sync for VideoLayer {}
|
||||
|
||||
impl VideoLayer {
|
||||
fn new(cgl: CGLContextObj, pixel_format: CGLPixelFormatObj, float: bool) -> Retained<VideoLayer> {
|
||||
let this = VideoLayer::alloc().set_ivars(LayerIvars { cgl, pixel_format, float, render: Mutex::new(None) });
|
||||
let layer: Retained<VideoLayer> = unsafe { msg_send![super(this), init] };
|
||||
layer.setAsynchronous(false);
|
||||
layer.setNeedsDisplayOnBoundsChange(true);
|
||||
layer.setOpaque(true);
|
||||
layer
|
||||
}
|
||||
}
|
||||
|
||||
/// Redraws whenever mpv has a new frame. Drawing off the main thread needs an
|
||||
/// explicit flush for Core Animation to pick the frame up.
|
||||
fn render_loop(layer: Retained<VideoLayer>, wake: Receiver<()>) {
|
||||
let cgl = layer.ivars().cgl;
|
||||
while wake.recv().is_ok() {
|
||||
let Some(render) = layer.ivars().render.lock().clone() else { continue };
|
||||
let flags = unsafe {
|
||||
CGLLockContext(cgl);
|
||||
CGLSetCurrentContext(cgl);
|
||||
let flags = (render.update)(render.ctx);
|
||||
CGLUnlockContext(cgl);
|
||||
flags
|
||||
};
|
||||
if flags & RENDER_UPDATE_FRAME != 0 {
|
||||
layer.display();
|
||||
CATransaction::flush();
|
||||
unsafe {
|
||||
CGLLockContext(cgl);
|
||||
CGLSetCurrentContext(cgl);
|
||||
(render.report_swap)(render.ctx);
|
||||
CGLUnlockContext(cgl);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// —— VideoSurface ——————————————————————————————————————————————————————
|
||||
|
||||
/// The view is only touched on the main thread; the layer is also drawn by the
|
||||
/// render thread and reconfigured for HDR inside explicit transactions.
|
||||
struct Ui {
|
||||
view: Retained<NSView>,
|
||||
layer: Retained<VideoLayer>,
|
||||
}
|
||||
|
||||
unsafe impl Send for Ui {}
|
||||
unsafe impl Sync for Ui {}
|
||||
|
||||
pub struct VideoSurface {
|
||||
ui: Arc<Ui>,
|
||||
wake: &'static SyncSender<()>,
|
||||
wake_rx: Option<Receiver<()>>,
|
||||
/// Where the video is drawn, in physical pixels; `None` fills the window.
|
||||
rect: Option<(i32, i32, i32, i32)>,
|
||||
mpv: Option<Arc<Mpv>>,
|
||||
/// HDR passthrough is on (the `target-colorspace-hint` option, as on Windows).
|
||||
passthrough: bool,
|
||||
/// The layer is showing HDR in extended dynamic range.
|
||||
edr: bool,
|
||||
}
|
||||
|
||||
/// Runs `f` on the main thread with the window's web view and waits for it.
|
||||
fn on_main<R: Runtime, T: Send + 'static>(
|
||||
window: &WebviewWindow<R>,
|
||||
f: impl FnOnce(&NSView, &NSWindow) -> T + Send + 'static,
|
||||
) -> Result<T, String> {
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
window
|
||||
.with_webview(move |webview| unsafe {
|
||||
let view = &*(webview.inner() as *const NSView);
|
||||
let window = &*(webview.ns_window() as *const NSWindow);
|
||||
let _ = tx.send(f(view, window));
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
rx.recv().map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Places the video view: the whole web view, or a rectangle of it given in
|
||||
/// physical pixels from the top left (the web page's coordinates).
|
||||
fn place(ui: &Ui, webview: &NSView, window: &NSWindow, rect: Option<(i32, i32, i32, i32)>) {
|
||||
let bounds = webview.frame();
|
||||
let scale = window.backingScaleFactor();
|
||||
let frame = match rect {
|
||||
None => bounds,
|
||||
Some((x, y, w, h)) => {
|
||||
let (x, y, w, h) = (x as f64 / scale, y as f64 / scale, (w.max(16)) as f64 / scale, (h.max(16)) as f64 / scale);
|
||||
let flipped = unsafe { webview.superview() }.is_some_and(|s| s.isFlipped());
|
||||
let top = if flipped { bounds.origin.y + y } else { bounds.origin.y + bounds.size.height - y - h };
|
||||
NSRect::new(NSPoint::new(bounds.origin.x + x, top), NSSize::new(w, h))
|
||||
}
|
||||
};
|
||||
ui.view.setFrame(frame);
|
||||
ui.view.setAutoresizingMask(if rect.is_none() {
|
||||
NSAutoresizingMaskOptions::ViewWidthSizable | NSAutoresizingMaskOptions::ViewHeightSizable
|
||||
} else {
|
||||
NSAutoresizingMaskOptions::ViewNotSizable
|
||||
});
|
||||
if ui.layer.contentsScale() != scale {
|
||||
ui.layer.setContentsScale(scale);
|
||||
}
|
||||
}
|
||||
|
||||
impl VideoSurface {
|
||||
pub fn create<R: Runtime>(window: &WebviewWindow<R>) -> Result<VideoSurface, String> {
|
||||
let (cgl, pixel_format, float) = unsafe { create_gl_context()? };
|
||||
let layer = VideoLayer::new(cgl, pixel_format, float);
|
||||
let ui = on_main(window, move |webview, window| unsafe {
|
||||
let view = NSView::initWithFrame(MainThreadMarker::new_unchecked().alloc(), webview.frame());
|
||||
// Layer-hosting: set the layer before asking for one.
|
||||
view.setLayer(Some(&layer));
|
||||
view.setWantsLayer(true);
|
||||
view.setHidden(true);
|
||||
// Let the video show through wherever the page is transparent.
|
||||
let no = NSNumber::new_bool(false);
|
||||
let _: () = msg_send![webview, setValue: &*no, forKey: &*NSString::from_str("drawsBackground")];
|
||||
if let Some(parent) = webview.superview() {
|
||||
parent.addSubview_positioned_relativeTo(&view, NSWindowOrderingMode::Below, Some(webview));
|
||||
}
|
||||
let ui = Ui { view, layer };
|
||||
place(&ui, webview, window, None);
|
||||
ui
|
||||
})?;
|
||||
let (wake, wake_rx) = sync_channel::<()>(1);
|
||||
Ok(VideoSurface {
|
||||
ui: Arc::new(ui),
|
||||
wake: Box::leak(Box::new(wake)),
|
||||
wake_rx: Some(wake_rx),
|
||||
rect: None,
|
||||
mpv: None,
|
||||
passthrough: false,
|
||||
edr: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// mpv renders through the render API (`vo=libmpv`). Its window is forced
|
||||
/// open only once the render context exists (`start`).
|
||||
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
|
||||
vec![("vo", "libmpv".into()), ("force-window", "no".into())]
|
||||
}
|
||||
|
||||
/// Creates mpv's render context on the layer's OpenGL context and starts
|
||||
/// the render thread. Runs once, after `mpv_initialize`.
|
||||
pub fn start(&mut self, mpv: &Arc<Mpv>) -> Result<(), String> {
|
||||
let Some(wake_rx) = self.wake_rx.take() else { return Ok(()) };
|
||||
let hint = mpv.get_property("target-colorspace-hint").unwrap_or_default();
|
||||
self.passthrough = (hint == serde_json::Value::Bool(true) || hint == "yes") && self.ui.layer.ivars().float;
|
||||
self.mpv = Some(mpv.clone());
|
||||
type Create = unsafe extern "C" fn(*mut RenderCtx, *mut c_void, *mut RenderParam) -> c_int;
|
||||
type SetCallback = unsafe extern "C" fn(RenderCtx, extern "C" fn(*mut c_void), *mut c_void);
|
||||
unsafe {
|
||||
let missing = |name: &str| format!("libmpv is missing {name}");
|
||||
let create: Create = mpv.symbol("mpv_render_context_create").ok_or_else(|| missing("mpv_render_context_create"))?;
|
||||
let set_callback: SetCallback = mpv.symbol("mpv_render_context_set_update_callback").ok_or_else(|| missing("the render API"))?;
|
||||
let render = mpv.symbol("mpv_render_context_render").ok_or_else(|| missing("the render API"))?;
|
||||
let update = mpv.symbol("mpv_render_context_update").ok_or_else(|| missing("the render API"))?;
|
||||
let report_swap = mpv.symbol("mpv_render_context_report_swap").ok_or_else(|| missing("the render API"))?;
|
||||
|
||||
let gl = dlopen(c"/System/Library/Frameworks/OpenGL.framework/OpenGL".as_ptr(), RTLD_LAZY);
|
||||
let mut init = OpenGlInitParams { get_proc_address, get_proc_address_ctx: gl };
|
||||
let mut params = [
|
||||
RenderParam { kind: RENDER_PARAM_API_TYPE, data: c"opengl".as_ptr() as *mut c_void },
|
||||
RenderParam { kind: RENDER_PARAM_OPENGL_INIT_PARAMS, data: &mut init as *mut _ as *mut c_void },
|
||||
RenderParam { kind: 0, data: ptr::null_mut() },
|
||||
];
|
||||
let cgl = self.ui.layer.ivars().cgl;
|
||||
let mut ctx: RenderCtx = ptr::null_mut();
|
||||
CGLLockContext(cgl);
|
||||
CGLSetCurrentContext(cgl);
|
||||
let code = create(&mut ctx, mpv.raw_handle(), params.as_mut_ptr());
|
||||
CGLUnlockContext(cgl);
|
||||
if code < 0 || ctx.is_null() {
|
||||
return Err(format!("The video renderer couldn't start ({code})."));
|
||||
}
|
||||
set_callback(ctx, on_update, self.wake as *const SyncSender<()> as *mut c_void);
|
||||
*self.ui.layer.ivars().render.lock() = Some(Arc::new(Render { ctx, render, update, report_swap }));
|
||||
}
|
||||
let layer = self.ui.layer.clone();
|
||||
std::thread::Builder::new()
|
||||
.name("mpv-render".into())
|
||||
.spawn(move || render_loop(layer, wake_rx))
|
||||
.map_err(|e| e.to_string())?;
|
||||
mpv.set_property("force-window", &serde_json::Value::Bool(true))
|
||||
}
|
||||
|
||||
/// HDR passthrough: for PQ or HLG video, mpv outputs PQ (BT.2020) instead of
|
||||
/// tone-mapping to SDR, and the layer shows it in extended dynamic range, so
|
||||
/// macOS maps it to the display's HDR headroom. SDR video uses the defaults.
|
||||
pub fn on_property(&mut self, name: &str, value: &serde_json::Value) {
|
||||
if name != "video-params/gamma" {
|
||||
return;
|
||||
}
|
||||
let edr = self.passthrough && matches!(value.as_str(), Some("pq" | "hlg"));
|
||||
if edr == self.edr {
|
||||
return;
|
||||
}
|
||||
self.edr = edr;
|
||||
if let Some(mpv) = &self.mpv {
|
||||
let target = |v: &str| serde_json::Value::String(v.into());
|
||||
let (trc, prim) = if edr { ("pq", "bt.2020") } else { ("auto", "auto") };
|
||||
let _ = mpv.set_property("target-trc", &target(trc));
|
||||
let _ = mpv.set_property("target-prim", &target(prim));
|
||||
}
|
||||
// Layer properties may change off the main thread inside a transaction.
|
||||
let layer = &self.ui.layer;
|
||||
CATransaction::begin();
|
||||
layer.setWantsExtendedDynamicRangeContent(edr);
|
||||
let pq = if edr { CGColorSpace::with_name(Some(unsafe { kCGColorSpaceITUR_2100_PQ })) } else { None };
|
||||
layer.setColorspace(pq.as_deref());
|
||||
CATransaction::commit();
|
||||
}
|
||||
|
||||
pub fn show<R: Runtime>(&mut self, window: &WebviewWindow<R>, visible: bool) {
|
||||
let ui = self.ui.clone();
|
||||
let _ = window.run_on_main_thread(move || {
|
||||
ui.view.setHidden(!visible);
|
||||
if visible {
|
||||
ui.layer.setNeedsDisplay();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Keeps the video view matched to the web view, or to the miniplayer
|
||||
/// rectangle when one is set.
|
||||
pub fn fit<R: Runtime>(&mut self, window: &WebviewWindow<R>, _: Option<&Mpv>) {
|
||||
let ui = self.ui.clone();
|
||||
let rect = self.rect;
|
||||
let _ = window.with_webview(move |webview| unsafe {
|
||||
let view = &*(webview.inner() as *const NSView);
|
||||
let window = &*(webview.ns_window() as *const NSWindow);
|
||||
place(&ui, view, window, rect);
|
||||
});
|
||||
}
|
||||
|
||||
pub fn set_rect<R: Runtime>(&mut self, window: &WebviewWindow<R>, mpv: Option<&Mpv>, rect: Option<(i32, i32, i32, i32)>) {
|
||||
self.rect = rect;
|
||||
self.fit(window, mpv);
|
||||
}
|
||||
}
|
||||
|
||||
/// mpv properties the surface needs to observe.
|
||||
pub const SURFACE_PROPERTIES: &[&str] = &["video-params/gamma"];
|
||||
|
||||
/// File names libmpv may have on this platform.
|
||||
pub const MPV_LIBRARIES: &[&str] = &["libmpv.2.dylib", "libmpv.dylib"];
|
||||
|
||||
/// Not needed: the only GPU-specific tier (RTX Video) is Windows-only.
|
||||
pub fn gpu_names() -> Vec<String> {
|
||||
Vec::new()
|
||||
}
|
||||
|
||||
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
|
||||
// TODO(macOS): IOPMAssertionCreateWithName(PreventUserIdleDisplaySleep).
|
||||
let _ = rx.recv();
|
||||
/// The Mac's name as set in System Settings → General → Sharing.
|
||||
pub fn device_name() -> String {
|
||||
objc2_foundation::NSHost::currentHost()
|
||||
.localizedName()
|
||||
.map(|n| n.to_string())
|
||||
.filter(|n| !n.is_empty())
|
||||
.unwrap_or_else(|| "Mac".into())
|
||||
}
|
||||
|
||||
/// macOS version, e.g. "15.4".
|
||||
pub fn os_version() -> String {
|
||||
let v = objc2_foundation::NSProcessInfo::processInfo().operatingSystemVersion();
|
||||
if v.patchVersion > 0 {
|
||||
format!("{}.{}.{}", v.majorVersion, v.minorVersion, v.patchVersion)
|
||||
} else {
|
||||
format!("{}.{}", v.majorVersion, v.minorVersion)
|
||||
}
|
||||
}
|
||||
|
||||
/// Shows or hides the traffic lights (they fade with the player's controls).
|
||||
pub fn set_window_buttons<R: Runtime>(window: &WebviewWindow<R>, visible: bool) {
|
||||
let Ok(ns_window) = window.ns_window() else { return };
|
||||
let ns_window = ns_window as usize;
|
||||
let _ = window.run_on_main_thread(move || unsafe {
|
||||
let window = &*(ns_window as *const NSWindow);
|
||||
for kind in [NSWindowButton::CloseButton, NSWindowButton::MiniaturizeButton, NSWindowButton::ZoomButton] {
|
||||
if let Some(button) = window.standardWindowButton(kind) {
|
||||
button.setHidden(!visible);
|
||||
}
|
||||
}
|
||||
// AppKit lays the buttons out again at their default place; the window's
|
||||
// view restores the configured position (trafficLightPosition) when drawn.
|
||||
if let Some(view) = window.contentView() {
|
||||
view.setNeedsDisplay(true);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// —— Power —————————————————————————————————————————————————————————————
|
||||
|
||||
type CFStringRef = *const c_void;
|
||||
const CF_STRING_ENCODING_UTF8: u32 = 0x0800_0100;
|
||||
const IOPM_ASSERTION_LEVEL_ON: u32 = 255;
|
||||
|
||||
#[link(name = "CoreFoundation", kind = "framework")]
|
||||
extern "C" {
|
||||
fn CFStringCreateWithCString(alloc: *const c_void, s: *const c_char, encoding: u32) -> CFStringRef;
|
||||
fn CFRelease(cf: *const c_void);
|
||||
}
|
||||
|
||||
#[link(name = "IOKit", kind = "framework")]
|
||||
extern "C" {
|
||||
fn IOPMAssertionCreateWithName(kind: CFStringRef, level: u32, name: CFStringRef, id: *mut u32) -> i32;
|
||||
fn IOPMAssertionRelease(id: u32) -> i32;
|
||||
}
|
||||
|
||||
/// Keeps the display awake until `rx` closes or receives.
|
||||
pub fn hold_awake(rx: Receiver<()>) {
|
||||
let cf = |s: &CStr| unsafe { CFStringCreateWithCString(ptr::null(), s.as_ptr(), CF_STRING_ENCODING_UTF8) };
|
||||
let kind = cf(c"PreventUserIdleDisplaySleep");
|
||||
let name = cf(c"Kaleido is playing video");
|
||||
let mut id = 0u32;
|
||||
let held = unsafe { IOPMAssertionCreateWithName(kind, IOPM_ASSERTION_LEVEL_ON, name, &mut id) } == 0;
|
||||
let _ = rx.recv();
|
||||
unsafe {
|
||||
if held {
|
||||
IOPMAssertionRelease(id);
|
||||
}
|
||||
CFRelease(kind);
|
||||
CFRelease(name);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,11 +2,13 @@
|
|||
//! Each platform file exposes the same items:
|
||||
//!
|
||||
//! - `VideoSurface`: composes mpv's output beneath the web view
|
||||
//! (`create`, `mpv_options`, `on_property`, `show`, `fit`, `set_rect`).
|
||||
//! (`create`, `mpv_options`, `start`, `on_property`, `show`, `fit`, `set_rect`).
|
||||
//! - `SURFACE_PROPERTIES`: mpv properties the surface observes.
|
||||
//! - `MPV_LIBRARIES`: libmpv file names to look for.
|
||||
//! - `hold_awake`: prevents display sleep until the receiver closes.
|
||||
//! - `gpu_names`: the graphics adapters, by name.
|
||||
//! - `device_name`, `os_version`: how the computer identifies itself to Plex.
|
||||
//! - `set_window_buttons`: shows or hides native window buttons (macOS).
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
mod windows;
|
||||
|
|
|
|||
|
|
@ -69,6 +69,11 @@ impl VideoSurface {
|
|||
]
|
||||
}
|
||||
|
||||
/// Nothing to set up once mpv is initialized: it creates its swapchain itself.
|
||||
pub fn start(&mut self, _: &std::sync::Arc<Mpv>) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn on_property(&mut self, name: &str, value: &serde_json::Value) {
|
||||
if name == "display-swapchain" {
|
||||
self.attach(value.as_i64().unwrap_or(0) as usize);
|
||||
|
|
@ -94,7 +99,7 @@ impl VideoSurface {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn show(&mut self, visible: bool) {
|
||||
pub fn show<R: Runtime>(&mut self, _: &WebviewWindow<R>, visible: bool) {
|
||||
if self.visible == visible {
|
||||
return;
|
||||
}
|
||||
|
|
@ -141,7 +146,6 @@ pub const SURFACE_PROPERTIES: &[&str] = &["display-swapchain"];
|
|||
/// File names libmpv may have on this platform.
|
||||
pub const MPV_LIBRARIES: &[&str] = &["libmpv-2.dll", "mpv-2.dll"];
|
||||
|
||||
/// Keeps the display awake until `rx` closes or receives.
|
||||
/// Hardware graphics adapters as DXGI names them (e.g. "NVIDIA GeForce RTX 4080").
|
||||
pub fn gpu_names() -> Vec<String> {
|
||||
use ::windows::Win32::Graphics::Dxgi::*;
|
||||
|
|
@ -165,6 +169,19 @@ pub fn gpu_names() -> Vec<String> {
|
|||
names
|
||||
}
|
||||
|
||||
/// The computer's name, as Plex shows it.
|
||||
pub fn device_name() -> String {
|
||||
std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Windows PC".into())
|
||||
}
|
||||
|
||||
pub fn os_version() -> String {
|
||||
"11".into()
|
||||
}
|
||||
|
||||
/// Windows draws its own caption buttons in the page.
|
||||
pub fn set_window_buttons<R: Runtime>(_: &WebviewWindow<R>, _: bool) {}
|
||||
|
||||
/// Keeps the display awake until `rx` closes or receives.
|
||||
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
|
||||
use ::windows::Win32::System::Power::*;
|
||||
unsafe {
|
||||
|
|
|
|||
|
|
@ -71,7 +71,9 @@ fn create_player<R: Runtime>(app: &AppHandle<R>, window: &WebviewWindow<R>, opts
|
|||
set("hwdec", opts.hwdec.as_deref().unwrap_or("auto-safe"))?;
|
||||
set("keep-open", "yes")?;
|
||||
set("idle", "yes")?;
|
||||
set("force-window", "yes")?;
|
||||
if !render_options.iter().any(|(k, _)| *k == "force-window") {
|
||||
set("force-window", "yes")?;
|
||||
}
|
||||
set("osc", "no")?;
|
||||
set("osd-level", "0")?;
|
||||
set("input-default-bindings", "no")?;
|
||||
|
|
@ -107,6 +109,9 @@ fn create_player<R: Runtime>(app: &AppHandle<R>, window: &WebviewWindow<R>, opts
|
|||
}
|
||||
mpv.request_log_messages("warn");
|
||||
mpv.initialize()?;
|
||||
if let Some(surface) = app.state::<PlayerState>().surface.lock().as_mut() {
|
||||
surface.start(&mpv)?;
|
||||
}
|
||||
for (i, name) in OBSERVED.iter().chain(crate::platform::SURFACE_PROPERTIES).enumerate() {
|
||||
mpv.observe(i as u64 + 1, name);
|
||||
}
|
||||
|
|
@ -183,7 +188,7 @@ pub async fn player_show<R: Runtime>(app: AppHandle<R>, window: WebviewWindow<R>
|
|||
let mut surface = state.surface.lock();
|
||||
if let Some(surface) = surface.as_mut() {
|
||||
surface.fit(&window, mpv.as_deref());
|
||||
surface.show(visible);
|
||||
surface.show(&window, visible);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -225,6 +230,13 @@ pub async fn player_get<R: Runtime>(app: AppHandle<R>, name: String) -> Result<V
|
|||
player(&app)?.get_property(&name)
|
||||
}
|
||||
|
||||
/// Shows or hides the native window buttons where the OS draws them (the
|
||||
/// macOS traffic lights fade with the player's controls).
|
||||
#[tauri::command]
|
||||
pub fn window_buttons<R: Runtime>(window: WebviewWindow<R>, visible: bool) {
|
||||
crate::platform::set_window_buttons(&window, visible);
|
||||
}
|
||||
|
||||
/// Keeps the video surface matched to the window's client area.
|
||||
pub fn on_resize<R: Runtime>(window: &WebviewWindow<R>) {
|
||||
let app = window.app_handle();
|
||||
|
|
|
|||
|
|
@ -13,9 +13,14 @@ fn entry(key: &str) -> Result<keyring::Entry, String> {
|
|||
keyring::Entry::new(SERVICE, key).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Secrets (Plex tokens) live in Windows Credential Manager, never in plain files.
|
||||
/// Secrets (Plex tokens) live in the OS's credential store (Windows Credential
|
||||
/// Manager, the macOS Keychain), never in plain files; except in macOS debug
|
||||
/// builds, see `dev_secrets`.
|
||||
#[tauri::command]
|
||||
pub fn secret_get(key: String) -> Result<Option<String>, String> {
|
||||
pub fn secret_get<R: Runtime>(app: AppHandle<R>, key: String) -> Result<Option<String>, String> {
|
||||
if let Some(path) = dev_secrets(&app) {
|
||||
return Ok(read_dev_secrets(&path).get(&key).and_then(|v| v.as_str()).map(String::from));
|
||||
}
|
||||
match entry(&key)?.get_password() {
|
||||
Ok(v) => Ok(Some(v)),
|
||||
Err(keyring::Error::NoEntry) => Ok(None),
|
||||
|
|
@ -24,18 +29,66 @@ pub fn secret_get(key: String) -> Result<Option<String>, String> {
|
|||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn secret_set(key: String, value: String) -> Result<(), String> {
|
||||
entry(&key)?.set_password(&value).map_err(|e| e.to_string())
|
||||
pub fn secret_set<R: Runtime>(app: AppHandle<R>, key: String, value: String) -> Result<(), String> {
|
||||
if let Some(path) = dev_secrets(&app) {
|
||||
let mut all = read_dev_secrets(&path);
|
||||
all.insert(key, Value::String(value));
|
||||
return write_dev_secrets(&path, &all);
|
||||
}
|
||||
let entry = entry(&key)?;
|
||||
match entry.set_password(&value) {
|
||||
Ok(()) => Ok(()),
|
||||
// A Keychain item left by a differently signed build can be impossible to
|
||||
// update yet still block adding; replacing it recovers.
|
||||
Err(keyring::Error::PlatformFailure(_)) if cfg!(target_os = "macos") => {
|
||||
let _ = entry.delete_credential();
|
||||
entry.set_password(&value).map_err(|e| e.to_string())
|
||||
}
|
||||
Err(e) => Err(e.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn secret_delete(key: String) -> Result<(), String> {
|
||||
pub fn secret_delete<R: Runtime>(app: AppHandle<R>, key: String) -> Result<(), String> {
|
||||
if let Some(path) = dev_secrets(&app) {
|
||||
let mut all = read_dev_secrets(&path);
|
||||
all.remove(&key);
|
||||
return write_dev_secrets(&path, &all);
|
||||
}
|
||||
match entry(&key)?.delete_credential() {
|
||||
Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
|
||||
Err(e) => Err(e.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// macOS ties Keychain access to the app's code signature, and every debug
|
||||
/// build is a new unsigned binary, so the Keychain would ask for permission
|
||||
/// after each rebuild. Debug builds there keep secrets in a private file in the
|
||||
/// app data folder instead (development only, like the `.env` sign-in).
|
||||
fn dev_secrets<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
|
||||
if !(cfg!(debug_assertions) && cfg!(target_os = "macos")) {
|
||||
return None;
|
||||
}
|
||||
app.path().app_data_dir().ok().map(|d| d.join("dev-secrets.json"))
|
||||
}
|
||||
|
||||
fn read_dev_secrets(path: &std::path::Path) -> serde_json::Map<String, Value> {
|
||||
std::fs::read_to_string(path).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn write_dev_secrets(path: &std::path::Path, all: &serde_json::Map<String, Value>) -> Result<(), String> {
|
||||
use std::io::Write;
|
||||
if let Some(dir) = path.parent() {
|
||||
std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
|
||||
}
|
||||
let mut options = std::fs::OpenOptions::new();
|
||||
options.write(true).create(true).truncate(true);
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
|
||||
let mut file = options.open(path).map_err(|e| e.to_string())?;
|
||||
file.write_all(Value::Object(all.clone()).to_string().as_bytes()).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AppInfo {
|
||||
|
|
@ -43,6 +96,7 @@ pub struct AppInfo {
|
|||
data_dir: String,
|
||||
default_download_dir: String,
|
||||
platform: String,
|
||||
os_version: String,
|
||||
device_name: String,
|
||||
/// Graphics adapters by name (decides which upscaling tiers are offered).
|
||||
gpus: Vec<String>,
|
||||
|
|
@ -63,7 +117,8 @@ pub fn app_info<R: Runtime>(app: AppHandle<R>) -> AppInfo {
|
|||
data_dir: data,
|
||||
default_download_dir: downloads,
|
||||
platform: std::env::consts::OS.to_string(),
|
||||
device_name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Windows PC".into()),
|
||||
os_version: crate::platform::os_version(),
|
||||
device_name: crate::platform::device_name(),
|
||||
gpus: crate::platform::gpu_names(),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@
|
|||
},
|
||||
"plugins": {
|
||||
"updater": {
|
||||
"pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEU0MTA2RjI0OUFFQzU1QzUKUldURlZleWFKRzhRNUlqTTR3U095STFYS3BsUXd2UnZMYlRrQmt3aUk5YU5WSjdqcUxVcHllU1EK",
|
||||
"pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEUxQjk1OTExMzBCRTRENEUKUldST1RiNHdFVm01NFFMQ1EvYm9CYlhhNU9jNTZXb254dVZOQW8relJYRlQ4ZjdLQll3cHR3VE4K",
|
||||
"endpoints": [
|
||||
"https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json"
|
||||
]
|
||||
|
|
|
|||
|
|
@ -1,15 +1,39 @@
|
|||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"app": {
|
||||
"windows": [
|
||||
{
|
||||
"label": "main",
|
||||
"title": "Kaleido",
|
||||
"width": 1480,
|
||||
"height": 900,
|
||||
"minWidth": 900,
|
||||
"minHeight": 580,
|
||||
"center": true,
|
||||
"decorations": true,
|
||||
"titleBarStyle": "Overlay",
|
||||
"hiddenTitle": true,
|
||||
"trafficLightPosition": { "x": 22, "y": 35 },
|
||||
"backgroundColor": "#090a0c",
|
||||
"transparent": false,
|
||||
"shadow": true,
|
||||
"visible": false,
|
||||
"dragDropEnabled": false
|
||||
}
|
||||
]
|
||||
},
|
||||
"bundle": {
|
||||
"targets": [
|
||||
"app",
|
||||
"dmg"
|
||||
],
|
||||
"macOS": {
|
||||
"minimumSystemVersion": "12.0",
|
||||
"frameworks": [
|
||||
"../vendor/mpv/macos/libmpv.2.dylib"
|
||||
]
|
||||
"minimumSystemVersion": "26.0",
|
||||
"signingIdentity": "-",
|
||||
"hardenedRuntime": false,
|
||||
"files": {
|
||||
"Frameworks": "../vendor/mpv/macos"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import { PageLoader } from '../ui/primitives';
|
|||
import { Splash } from '../screens/Splash';
|
||||
import { SignIn } from '../screens/SignIn';
|
||||
import { ServerPicker } from '../screens/ServerPicker';
|
||||
import { win } from '../platform/native';
|
||||
import { isMac, win } from '../platform/native';
|
||||
import { usePlayer } from '../player/store';
|
||||
import { PlayerOverlay } from '../player/PlayerOverlay';
|
||||
import { DialogHost } from '../screens/dialogs/DialogHost';
|
||||
|
|
@ -100,13 +100,13 @@ function useGlobalShortcuts() {
|
|||
if ((e.ctrlKey || e.metaKey) && (e.key === 'k' || e.key === 'f')) {
|
||||
e.preventDefault();
|
||||
navigate({ name: 'search' });
|
||||
} else if (e.altKey && e.key === 'ArrowLeft') {
|
||||
} else if ((e.altKey && e.key === 'ArrowLeft') || (isMac && e.metaKey && e.key === '[')) {
|
||||
e.preventDefault();
|
||||
useRouter.getState().back();
|
||||
} else if (e.altKey && e.key === 'ArrowRight') {
|
||||
} else if ((e.altKey && e.key === 'ArrowRight') || (isMac && e.metaKey && e.key === ']')) {
|
||||
e.preventDefault();
|
||||
useRouter.getState().forward();
|
||||
} else if (e.key === 'F11') {
|
||||
} else if (e.key === 'F11' || (isMac && e.metaKey && e.ctrlKey && e.key.toLowerCase() === 'f')) {
|
||||
e.preventDefault();
|
||||
win.isFullscreen().then((fs) => win.setFullscreen(!fs));
|
||||
} else if ((e.key === 'Escape' || e.key === 'Backspace') && !isTyping(e.target) && !document.querySelector('.menu-layer, .dialog-layer')) {
|
||||
|
|
@ -225,7 +225,16 @@ export function App() {
|
|||
useEffect(() => {
|
||||
useSession.getState().init();
|
||||
// The window appears once the first frame is painted (no white flash).
|
||||
requestAnimationFrame(() => win.show());
|
||||
// WKWebView runs no animation frames until its window is shown, so a
|
||||
// timeout stands in there.
|
||||
let shown = false;
|
||||
const show = () => {
|
||||
if (!shown) win.show();
|
||||
shown = true;
|
||||
};
|
||||
requestAnimationFrame(show);
|
||||
const fallback = setTimeout(show, 150);
|
||||
return () => clearTimeout(fallback);
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ import { useSettings } from './settings';
|
|||
import { Icon } from '../ui/Icon';
|
||||
import { KaleidoMark } from '../ui/primitives';
|
||||
import { openMenu, type MenuItem } from '../ui/overlays';
|
||||
import { isNative, win } from '../platform/native';
|
||||
import { isMac, isNative, shortcut, win } from '../platform/native';
|
||||
import { useDownloads } from '../downloads/store';
|
||||
import { useHomeUsers } from './useHomeUsers';
|
||||
|
||||
|
|
@ -16,17 +16,18 @@ const NAV = [
|
|||
{ id: 'downloads', label: 'Downloads', route: { name: 'downloads' } as const },
|
||||
];
|
||||
|
||||
/** Caption buttons drawn by the page; macOS shows its own traffic lights instead. */
|
||||
export function WindowControls() {
|
||||
const [maximized, setMaximized] = useState(false);
|
||||
useEffect(() => {
|
||||
if (!isNative) return;
|
||||
if (!isNative || isMac) return;
|
||||
let off: (() => void) | undefined;
|
||||
const sync = () => win.isMaximized().then(setMaximized);
|
||||
sync();
|
||||
win.onResized(sync).then((u) => (off = u));
|
||||
return () => off?.();
|
||||
}, []);
|
||||
if (!isNative) return null;
|
||||
if (!isNative || isMac) return null;
|
||||
return (
|
||||
<div className="window-controls">
|
||||
<button aria-label="Minimize" onClick={() => win.minimize()}>
|
||||
|
|
@ -109,7 +110,7 @@ export function TopBar({ solid }: { solid: boolean }) {
|
|||
</nav>
|
||||
</div>
|
||||
<div className="topbar-right" data-tauri-drag-region>
|
||||
<button className={`icon-btn${active === 'search' ? ' on' : ''}`} aria-label="Search" title="Search (Ctrl+K)" onClick={() => navigate({ name: 'search' })}>
|
||||
<button className={`icon-btn${active === 'search' ? ' on' : ''}`} aria-label="Search" title={`Search (${shortcut('K')})`} onClick={() => navigate({ name: 'search' })}>
|
||||
<Icon name="search" size={19} />
|
||||
</button>
|
||||
<button className={`icon-btn${active === 'settings' ? ' on' : ''}`} aria-label="Settings" title="Settings" onClick={() => navigate({ name: 'settings', mode: 'app', tab: 'general' })}>
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ export const useSession = create<SessionState>((set, get) => ({
|
|||
|
||||
async init() {
|
||||
const info = await appInfo();
|
||||
configureClient({ version: info.version, deviceName: info.deviceName });
|
||||
configureClient({ version: info.version, deviceName: info.deviceName, platformVersion: info.osVersion });
|
||||
let token = await secrets.get('account-token');
|
||||
const stored = loadStoredServer();
|
||||
|
||||
|
|
|
|||
10
src/main.tsx
10
src/main.tsx
|
|
@ -13,6 +13,7 @@ import { useRouter } from './app/router';
|
|||
import { usePlayer } from './player/store';
|
||||
import { useSettings } from './app/settings';
|
||||
import { useDownloads } from './downloads/store';
|
||||
import { hostOS, isMac, isNative, win } from './platform/native';
|
||||
|
||||
if (import.meta.env.DEV) (window as any).__kaleido = { useSession, useRouter, usePlayer, useSettings, useDownloads };
|
||||
|
||||
|
|
@ -24,6 +25,15 @@ window.addEventListener('contextmenu', (e) => {
|
|||
|
||||
installKeyboardNav();
|
||||
|
||||
// Platform styling: macOS keeps its traffic lights at the top left, except in
|
||||
// full screen, where the system hides them.
|
||||
document.documentElement.classList.add(`os-${hostOS}`);
|
||||
if (isNative && isMac) {
|
||||
const syncFullscreen = () => win.isFullscreen().then((fs) => document.documentElement.classList.toggle('window-fullscreen', fs));
|
||||
syncFullscreen();
|
||||
win.onResized(syncFullscreen);
|
||||
}
|
||||
|
||||
createRoot(document.getElementById('root')!).render(
|
||||
<StrictMode>
|
||||
<App />
|
||||
|
|
|
|||
|
|
@ -7,6 +7,16 @@ import type { UnlistenFn } from '@tauri-apps/api/event';
|
|||
|
||||
export const isNative = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
|
||||
|
||||
/** The host OS, known synchronously from the web view (WebView2, WKWebView, WebKitGTK). */
|
||||
export const hostOS: 'windows' | 'macos' | 'linux' =
|
||||
typeof navigator !== 'undefined' && /Macintosh|Mac OS X/.test(navigator.userAgent) ? 'macos' : typeof navigator !== 'undefined' && /Linux|X11/.test(navigator.userAgent) ? 'linux' : 'windows';
|
||||
export const isMac = hostOS === 'macos';
|
||||
|
||||
/** A shortcut with the platform's command key: "⌘K" on macOS, "Ctrl + K" elsewhere. */
|
||||
export const shortcut = (key: string) => (isMac ? `⌘${key}` : `Ctrl + ${key}`);
|
||||
/** How the window enters full screen from the keyboard. */
|
||||
export const fullscreenShortcut = isMac ? '⌃⌘F' : 'F11';
|
||||
|
||||
export async function invoke<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
|
||||
if (!isNative) throw new Error(`${cmd} is only available in the desktop app.`);
|
||||
const { invoke } = await import('@tauri-apps/api/core');
|
||||
|
|
@ -47,6 +57,7 @@ export interface AppInfo {
|
|||
dataDir: string;
|
||||
defaultDownloadDir: string;
|
||||
platform: string;
|
||||
osVersion: string;
|
||||
deviceName: string;
|
||||
/** Graphics adapters by name (empty where not reported). */
|
||||
gpus: string[];
|
||||
|
|
@ -57,7 +68,7 @@ export async function appInfo(): Promise<AppInfo> {
|
|||
if (info) return info;
|
||||
info = isNative
|
||||
? await invoke<AppInfo>('app_info')
|
||||
: { version: '0.1.0-dev', dataDir: '', defaultDownloadDir: '', platform: 'browser', deviceName: 'Browser preview', gpus: [] };
|
||||
: { version: '0.1.0-dev', dataDir: '', defaultDownloadDir: '', platform: 'browser', osVersion: '', deviceName: 'Browser preview', gpus: [] };
|
||||
return info;
|
||||
}
|
||||
|
||||
|
|
@ -107,6 +118,10 @@ export const win = {
|
|||
await w.setFocus();
|
||||
}
|
||||
},
|
||||
/** The OS's own window buttons (the macOS traffic lights); elsewhere the page draws them. */
|
||||
async setButtonsVisible(visible: boolean) {
|
||||
if (isNative && isMac) await invoke('window_buttons', { visible }).catch(() => {});
|
||||
},
|
||||
async onResized(cb: () => void): Promise<UnlistenFn> {
|
||||
if (!isNative) {
|
||||
window.addEventListener('resize', cb);
|
||||
|
|
|
|||
|
|
@ -781,6 +781,14 @@ export function PlayerOverlay() {
|
|||
return () => window.removeEventListener('keydown', onKey);
|
||||
}, [st.open, st.mini, seekStep, poke]);
|
||||
|
||||
// The macOS traffic lights fade with the rest of the player's chrome.
|
||||
const chromeHidden = st.open && !st.mini && !visible && st.firstFrame && !st.error;
|
||||
useEffect(() => {
|
||||
if (!chromeHidden) return;
|
||||
win.setButtonsVisible(false);
|
||||
return () => void win.setButtonsVisible(true);
|
||||
}, [chromeHidden]);
|
||||
|
||||
if (!st.open || !st.item) return null;
|
||||
if (st.mini) return <MiniPlayer />;
|
||||
const item = st.item;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
import { arr, bool, num, str } from './parse';
|
||||
import { clientIdentifier, PlexError, plexRequest, PRODUCT } from './client';
|
||||
import { clientIdentifier, DEVICE, PLATFORM, PlexError, plexRequest, PRODUCT } from './client';
|
||||
import type { HomeUser, PlexUser, ServerConnection, ServerResource } from './types';
|
||||
|
||||
const TV = 'https://plex.tv/api/v2';
|
||||
|
|
@ -26,8 +26,8 @@ export function authUrl(pin: Pin): string {
|
|||
clientID: clientIdentifier(),
|
||||
code: pin.code,
|
||||
'context[device][product]': PRODUCT,
|
||||
'context[device][platform]': 'Windows',
|
||||
'context[device][device]': 'Windows',
|
||||
'context[device][platform]': PLATFORM,
|
||||
'context[device][device]': DEVICE,
|
||||
});
|
||||
return `https://app.plex.tv/auth#?${params.toString()}`;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
import { httpFetch } from '../platform/native';
|
||||
import { hostOS, httpFetch } from '../platform/native';
|
||||
|
||||
export const PRODUCT = 'Kaleido';
|
||||
export const PLATFORM = 'Windows';
|
||||
/** How Plex lists this player (Plex's own names for each OS and device). */
|
||||
export const PLATFORM = hostOS === 'macos' ? 'macOS' : hostOS === 'linux' ? 'Linux' : 'Windows';
|
||||
export const DEVICE = hostOS === 'macos' ? 'Mac' : hostOS === 'linux' ? 'Linux' : 'Windows';
|
||||
|
||||
export class PlexError extends Error {
|
||||
constructor(
|
||||
|
|
@ -14,7 +16,8 @@ export class PlexError extends Error {
|
|||
|
||||
let clientId = '';
|
||||
let version = '0.1.0';
|
||||
let deviceName = 'Windows PC';
|
||||
let deviceName = hostOS === 'macos' ? 'Mac' : 'Windows PC';
|
||||
let platformVersion = hostOS === 'windows' ? '11' : '';
|
||||
|
||||
/** A stable, random identifier for this installation (not secret). */
|
||||
export function clientIdentifier(): string {
|
||||
|
|
@ -27,9 +30,24 @@ export function clientIdentifier(): string {
|
|||
return clientId;
|
||||
}
|
||||
|
||||
export function configureClient(opts: { version?: string; deviceName?: string }) {
|
||||
export function configureClient(opts: { version?: string; deviceName?: string; platformVersion?: string }) {
|
||||
if (opts.version) version = opts.version;
|
||||
if (opts.deviceName) deviceName = opts.deviceName;
|
||||
if (opts.platformVersion) platformVersion = opts.platformVersion;
|
||||
}
|
||||
|
||||
/**
|
||||
* HTTP header values must be ASCII; Mac names usually aren't ("Elijah’s MacBook").
|
||||
* Typographic punctuation becomes its plain form and accents are dropped.
|
||||
*/
|
||||
export function headerSafe(value: string): string {
|
||||
return value
|
||||
.replace(/[‘’]/g, "'")
|
||||
.replace(/[“”]/g, '"')
|
||||
.replace(/[–—]/g, '-')
|
||||
.normalize('NFKD')
|
||||
.replace(/[^\x20-\x7e]/g, '')
|
||||
.trim();
|
||||
}
|
||||
|
||||
export function plexHeaders(token?: string | null): Record<string, string> {
|
||||
|
|
@ -39,9 +57,9 @@ export function plexHeaders(token?: string | null): Record<string, string> {
|
|||
'X-Plex-Version': version,
|
||||
'X-Plex-Client-Identifier': clientIdentifier(),
|
||||
'X-Plex-Platform': PLATFORM,
|
||||
'X-Plex-Platform-Version': '11',
|
||||
'X-Plex-Device': 'Windows',
|
||||
'X-Plex-Device-Name': `Kaleido (${deviceName})`,
|
||||
'X-Plex-Platform-Version': platformVersion,
|
||||
'X-Plex-Device': DEVICE,
|
||||
'X-Plex-Device-Name': headerSafe(`Kaleido (${deviceName})`),
|
||||
'X-Plex-Model': 'Desktop',
|
||||
'X-Plex-Provides': 'player',
|
||||
'X-Plex-Language': navigator.language || 'en',
|
||||
|
|
@ -57,7 +75,7 @@ export function plexQuery(token?: string | null): Record<string, string> {
|
|||
'X-Plex-Version': version,
|
||||
'X-Plex-Client-Identifier': clientIdentifier(),
|
||||
'X-Plex-Platform': PLATFORM,
|
||||
'X-Plex-Device': 'Windows',
|
||||
'X-Plex-Device': DEVICE,
|
||||
'X-Plex-Device-Name': `Kaleido (${deviceName})`,
|
||||
};
|
||||
if (token) q['X-Plex-Token'] = token;
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
|
|||
import { parseItem, parseScores } from './parse';
|
||||
import { isLocalAddress } from './account';
|
||||
import { partAt } from './playback';
|
||||
import { headerSafe } from './client';
|
||||
import { duration, formatBadges, isWatched, remaining, washGradient } from '../app/format';
|
||||
import { buildFeatures } from '../screens/discover';
|
||||
import type { Hub } from './types';
|
||||
|
|
@ -112,3 +113,10 @@ describe('features', () => {
|
|||
expect(washGradient(movie().ultraBlur)).toContain('rgba(48, 97, 143');
|
||||
});
|
||||
});
|
||||
|
||||
describe('headerSafe', () => {
|
||||
it('turns Mac computer names into ASCII header values', () => {
|
||||
expect(headerSafe('Elijah’s MacBook Pro')).toBe("Elijah's MacBook Pro");
|
||||
expect(headerSafe('Zoë’s iMac — Studio')).toBe("Zoe's iMac - Studio");
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ export default function Downloads({ offline }: { offline?: boolean }) {
|
|||
{!isNative && (
|
||||
<div className="downloads-empty">
|
||||
<EmptyState icon="download" title="Downloads need the desktop app">
|
||||
Install Kaleido for Windows to save movies and episodes for offline viewing.
|
||||
Install the Kaleido desktop app to save movies and episodes for offline viewing.
|
||||
</EmptyState>
|
||||
</div>
|
||||
)}
|
||||
|
|
|
|||
|
|
@ -1,22 +1,12 @@
|
|||
import { isNative, win } from '../platform/native';
|
||||
import { Icon } from '../ui/Icon';
|
||||
import { isNative } from '../platform/native';
|
||||
import { WindowControls } from '../app/TopBar';
|
||||
|
||||
/** A draggable strip with window controls for full-screen states without the top bar. */
|
||||
export function WindowDrag() {
|
||||
if (!isNative) return null;
|
||||
return (
|
||||
<div className="window-drag" data-tauri-drag-region>
|
||||
<div className="window-controls">
|
||||
<button aria-label="Minimize" onClick={() => win.minimize()}>
|
||||
<Icon name="minimize" size={15} strokeWidth={1.4} />
|
||||
</button>
|
||||
<button aria-label="Maximize" onClick={() => win.toggleMaximize()}>
|
||||
<Icon name="maximize" size={13} strokeWidth={1.4} />
|
||||
</button>
|
||||
<button aria-label="Close" className="close" onClick={() => win.close()}>
|
||||
<Icon name="x" size={15} strokeWidth={1.4} />
|
||||
</button>
|
||||
</div>
|
||||
<WindowControls />
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ import { useSections, useServerQuery } from '../../app/queries';
|
|||
import * as api from '../../plex/api';
|
||||
import { art } from '../../app/format';
|
||||
import { useDownloads } from '../../downloads/store';
|
||||
import { appInfo, isNative, openExternal, pickFolder, revealPath, type AppInfo } from '../../platform/native';
|
||||
import { appInfo, fullscreenShortcut, isMac, isNative, openExternal, pickFolder, revealPath, shortcut, type AppInfo } from '../../platform/native';
|
||||
import { checkForUpdate, installUpdate, useUpdater } from '../../app/updater';
|
||||
import { Button, Segmented, Select, Switch } from '../../ui/primitives';
|
||||
import { confirmDialog } from '../../ui/overlays';
|
||||
|
|
@ -42,14 +42,16 @@ const skipOptions: { value: SkipMode; label: string }[] = [
|
|||
{ value: 'off', label: 'Off' },
|
||||
];
|
||||
|
||||
const OS_NAMES: Record<string, string> = { windows: 'Windows', macos: 'macOS', linux: 'Linux' };
|
||||
|
||||
const SHORTCUTS: [string, string][][] = [
|
||||
[
|
||||
['Ctrl + K', 'Search'],
|
||||
['Alt + ← / Mouse back', 'Go back'],
|
||||
['Alt + → / Mouse forward', 'Go forward'],
|
||||
[shortcut('K'), 'Search'],
|
||||
[isMac ? '⌘[ / Mouse back' : 'Alt + ← / Mouse back', 'Go back'],
|
||||
[isMac ? '⌘] / Mouse forward' : 'Alt + → / Mouse forward', 'Go forward'],
|
||||
['Esc', 'Go back or close a dialog'],
|
||||
['F11', 'Full screen'],
|
||||
['Ctrl + ,', 'Settings'],
|
||||
[fullscreenShortcut, 'Full screen'],
|
||||
[shortcut(','), 'Settings'],
|
||||
['Right-click a title', 'Title actions'],
|
||||
],
|
||||
[
|
||||
|
|
@ -182,7 +184,7 @@ export function AppSettings({ tab }: { tab: string }) {
|
|||
<Pref label="Hardware decoding" description="Uses your graphics card to decode video. Turn off only if you see artifacts. Applies after restarting Kaleido.">
|
||||
<Switch checked={s.hwdec} onChange={(v) => set('hwdec', v)} />
|
||||
</Pref>
|
||||
<Pref label="HDR passthrough" description="Sends HDR video to HDR-capable displays when Windows HDR is on. Applies after restarting Kaleido.">
|
||||
<Pref label="HDR passthrough" description={`Sends HDR video to HDR-capable displays${isMac ? '' : ' when Windows HDR is on'}. Applies after restarting Kaleido.`}>
|
||||
<Switch checked={s.hdrPassthrough} onChange={(v) => set('hdrPassthrough', v)} />
|
||||
</Pref>
|
||||
</SettingsSection>
|
||||
|
|
@ -374,7 +376,7 @@ export function AppSettings({ tab }: { tab: string }) {
|
|||
<div>
|
||||
<h2>Kaleido</h2>
|
||||
<p className="muted">
|
||||
Version {info?.version ?? '—'} · {info?.platform === 'windows' ? 'Windows' : info?.platform}
|
||||
Version {info?.version ?? '—'} · {OS_NAMES[info?.platform ?? ''] ?? info?.platform}
|
||||
</p>
|
||||
</div>
|
||||
</div>
|
||||
|
|
|
|||
|
|
@ -248,6 +248,14 @@
|
|||
display: flex;
|
||||
justify-content: flex-end;
|
||||
}
|
||||
/* macOS draws its traffic lights at the top left (tauri.macos.conf.json places
|
||||
them in the bar's centre line); keep the bar's content clear of them. */
|
||||
html.os-macos:not(.window-fullscreen) {
|
||||
--traffic-lights: 92px;
|
||||
}
|
||||
html.os-macos:not(.window-fullscreen) .topbar {
|
||||
padding-left: max(calc(var(--gutter) - 10px), var(--traffic-lights));
|
||||
}
|
||||
|
||||
/* —— Splash ————————————————————————————————————————————————— */
|
||||
.splash {
|
||||
|
|
|
|||
|
|
@ -69,6 +69,9 @@
|
|||
transition: opacity 400ms var(--ease);
|
||||
}
|
||||
/* The window's own buttons, top right, fading with the rest of the chrome. */
|
||||
html.os-macos:not(.window-fullscreen) .player-top {
|
||||
padding-left: var(--traffic-lights);
|
||||
}
|
||||
.player-top .window-controls {
|
||||
position: absolute;
|
||||
top: 0;
|
||||
|
|
|
|||
|
|
@ -2,14 +2,11 @@
|
|||
|
||||
`latest.json` is the feed the in-app updater reads (see `plugins.updater.endpoints` in
|
||||
`src-tauri/tauri.conf.json`). It lists one signed build per platform:
|
||||
`windows-x86_64`, `darwin-aarch64`, `darwin-x86_64` and `linux-x86_64`.
|
||||
`windows-x86_64` and `darwin-aarch64`.
|
||||
|
||||
Regenerate it after building a release, pointing at the release's download folder:
|
||||
Regenerate it once a release has every platform's build uploaded (see
|
||||
`docs/development.md` → Releases); it reads the release's assets on Forgejo:
|
||||
|
||||
```bash
|
||||
node scripts/update-manifest.mjs 0.2.0 https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/v0.2.0
|
||||
node scripts/update-manifest.mjs 0.2.0
|
||||
```
|
||||
|
||||
Platforms built elsewhere can be merged in by listing their bundle folders in
|
||||
`KALEIDO_BUNDLES` (separated by `;`). Existing platform entries are kept, so each OS
|
||||
can publish independently.
|
||||
|
|
|
|||
2
vendor/mpv/README.md
vendored
2
vendor/mpv/README.md
vendored
|
|
@ -6,7 +6,7 @@ folder, which is ignored by git and fetched by a script:
|
|||
| OS | Folder | How to fetch |
|
||||
| --- | --- | --- |
|
||||
| Windows | `windows/libmpv-2.dll` | `scripts/fetch-libmpv.ps1` (shinchiro `mpv-dev-x86_64` build) |
|
||||
| macOS | `macos/libmpv.2.dylib` | `scripts/fetch-libmpv.sh` (Homebrew `mpv`) |
|
||||
| macOS | `macos/libmpv.2.dylib` and the libraries it links | `scripts/fetch-libmpv.sh` (Homebrew `mpv`, made self-contained) |
|
||||
| Linux | system `libmpv.so.2` | Install your distribution's `libmpv2` package |
|
||||
|
||||
At runtime Kaleido looks in the app's resources, beside the executable, here, and
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue