Untidy

Untidy is an unofficial Wear OS companion/player for TIDAL. It is built for using TIDAL directly from a watch: search, browse, start playback, control the queue, and keep listening without a paired-phone UI doing the work.

Current snapshot

The current baseline is a physical-watch validated prerelease snapshot:

• Tag/release: v0.6.0-beta.6
• Device: Samsung Galaxy Watch6 LTE (SM-R955U)
• Evidence: navigation, mixed search, output routing, online/offline playback, favorites, and screen-off AAC/FLAC behavior were exercised on hardware.

Treat this as a prerelease / validation build, not a production app-store release. It is the baseline for regression checks while release validation continues.

Why this exists

TIDAL documents official support for Apple Watch, Android TV, TIDAL Connect devices, and Android/iOS phones and tablets. In the current public TIDAL support docs I could verify, I did not find an equivalent official Wear OS watch app/support page.

Untidy is aimed at that gap: a Wear OS-first, unofficial TIDAL player that treats the watch as the primary interface instead of a tiny remote for a phone.

What works today

Untidy currently supports the core standalone-watch listening loop:

• TIDAL sign-in using device-code OAuth.
• Home shortcuts for Search, Recent, Downloads, Library, Discover, and Settings.
• Search for TIDAL content, with a watch-friendly first-entry prompt before opening the keyboard.
• Library browsing for saved albums, artists, tracks, and playlists.
• Album, artist, and playlist pages with playable track lists.
• Playback from the watch through a Media3-backed playback service.
• Queue playback for albums/playlists and a Queue surface from Now Playing actions.
• Now Playing with large transport controls, album art, progress, action sheet, and AOD/ambient-safe behavior.
• Background/screen-off listening baseline from the known-good physical-watch snapshot.
• Recent shelf for watch-local explicit play history: tracks, albums, and playlists the user chose to play.
• Track context from Recent, with actions such as Play, View album, View artist, Add to playlist, and Download where eligible.
• Add current track to playlist flow, subject to TIDAL account/API permissions.
• View album / View artist from Now Playing when route metadata is available.
• Output labeling tuned for the watch; the built-in speaker appears as Watch speaker.
• Streaming quality presets in Settings: Battery Saver, Balanced, High, and opt-in Full fidelity, so users can choose between watch-friendly battery use and lossless/HiRes source streams where TIDAL makes them available.
• Settings for account, playback quality/preferences, downloads management, and app/legal information.

Recent UX polish in the known-good line includes:

• Playback loading no longer flashes an empty default / tap-to-play state.
• Search entry now explains the transition before opening keyboard input.
• Built-in output copy is simplified to Watch speaker.

Known limitations

Untidy is useful now, but it is still under active validation:

• Not production-ready. This repository is tracking prerelease/watch-validation builds, not a store-distributed release.
• Real-watch QA is still open. A known-good overnight use snapshot exists, but final release validation still needs structured coverage across watch models, Wear OS versions, input methods, Bluetooth routing, media controls, recents/back-stack behavior, and power/network edge cases.
• Offline/downloads are narrow. The app contains a Downloads shelf, local cleanup surfaces, and sanctioned usage=DOWNLOAD proof/MVP work, but release builds do not yet promise broad user-facing album/playlist offline downloads. Do not implement offline by caching PLAYBACK / STREAM manifests.
• TIDAL API behavior varies by account/scopes. Library, recommendations, playlist writes, quality tiers, and playback/download eligibility can depend on account region, subscription, scopes, catalog asset, and API availability.
• Full fidelity is intentionally opt-in. It requests HiRes FLAC, then FLAC, with AAC fallback when the account or track cannot provide lossless audio. The player reports the format actually delivered; lossless decoding can consume substantially more data and battery on a watch.
• Unofficial client. Untidy is independent from TIDAL, Google, and Samsung; users are responsible for complying with applicable terms.

Install the prerelease APK

The lowest-friction path is to install the current known-good APK directly on a Wear OS watch. You do not install this on your phone. A GitHub APK download will not automatically sync from the phone to the watch; that only becomes a normal user flow once Untidy is distributed through a proper Wear OS/Google Play channel or a companion-app packaging path.

1. Download the current beta APK to your computer:
   • Untidy-orchestrated-0.6.0-beta.6-recovery.apk
   • Release notes and validation limits: v0.6.0-beta.6
2. Install Android platform tools on your computer so the adb command is available.
   • Android Studio includes it, or install the standalone SDK Platform Tools from Google.
3. On the watch, enable Developer options.
   • Usually: Settings → About watch → Software info → tap Build number several times.
4. On the watch, enable Wireless debugging.
   • Keep the watch on Wi-Fi and on the same network as your computer.
5. Pair and connect from your computer:

adb pair WATCH_IP:PAIRING_PORT
adb connect WATCH_IP:ADB_PORT

6. Install the APK:

adb -s WATCH_IP:ADB_PORT install -r Untidy-orchestrated-0.6.0-beta.6-recovery.apk

If adb devices shows the watch as unauthorized, accept the debugging prompt on the watch. If pairing expires, turn Wireless debugging off/on and try again with the new ports.

Why not install it on the phone?

This prerelease is a Wear OS app APK published from GitHub, not a Play Store listing. Installing or downloading it on a phone does not push it to the watch. For now, install it directly to the watch with ADB. A future Play Store/internal-testing release would make watch installation much easier from the normal Google Play device picker.

Untidy targets Wear OS 4+ / API 33+ and declares itself as a standalone Wear app.

Development setup

Requirements

• Android Studio Ladybug or newer recommended.
• JDK 17.
• Android SDK platform API 35.
• Wear OS 4+ emulator image or a physical Wear OS watch.
• TIDAL credentials/scopes appropriate for the flows you are testing.

TIDAL credentials

The app reads local credentials from .dev-secrets\tidal-app.properties at the repo root. This file is ignored and must not be committed.

# .dev-secrets\tidal-app.properties
tidal.clientid=YOUR_TIDAL_CLIENT_ID
tidal.clientsecret=YOUR_TIDAL_CLIENT_SECRET
tidal.redirecturi=YOUR_TIDAL_REDIRECT_URI
# Optional: override scopes when testing specific API surfaces
# tidal.scopes=user.read collection.read collection.write playlists.read playlists.write search.read search.write recommendations.read entitlements.read playback

If credentials are missing or invalid, the project may still compile, but sign-in/playback paths will fail at runtime.

Build

# From the repo root
source scripts/env-android.sh
bash ./gradlew :app:assembleDebug --no-daemon

Debug APK:

app/build/outputs/apk/debug/app-debug.apk

Release APK:

source scripts/env-android.sh
bash ./gradlew assembleRelease --no-daemon

app/build/outputs/apk/release/app-release.apk

Run on emulator

source scripts/env-android.sh
UNTIDY_EMULATOR_INSTALL_LAUNCH=1 scripts/ensure-wear-emulator.sh

Or open the project in Android Studio, select a Wear OS AVD, and run the app configuration.

Run on a physical watch

1. Enable Developer Options and ADB debugging on the watch.
2. Pair the watch over Wi-Fi/ADB or USB where supported.
3. Build the desired variant.
4. Install with adb install -r ... or Android Studio device targeting.

Record the watch model, Wear OS version, APK variant, commit/tag, and any media/input/Bluetooth observations when reporting results.

Validation commands

Useful lightweight gates before sharing a build:

source scripts/env-android.sh
bash ./gradlew lintDebug assembleDebug testDebugUnitTest --no-daemon
git diff --check

Narrower compile/test checks while iterating:

source scripts/env-android.sh
bash ./gradlew :app:compileDebugKotlin :core:playback:testDebugUnitTest --no-daemon
git diff --check

Release snapshot gate:

source scripts/env-android.sh
bash ./gradlew assembleRelease --no-daemon
sha256sum app/build/outputs/apk/release/app-release.apk

Project layout

Untidy/
├─ app/                  # Wear OS app, Compose UI, navigation, settings
│  └─ src/main/java/com/tidal/wear
│     ├─ ui/             # Home, search, library, album, artist, playlist, player, recent, downloads
│     ├─ playback/       # Now Playing state bridge
│     └─ recent/         # Watch-local Recent history
├─ core/
│  ├─ model/             # Shared domain models
│  ├─ auth/              # TIDAL auth wrapper
│  ├─ tidal-api/         # TIDAL API client
│  └─ playback/          # Media3 service, playback backend, queue/offline helpers
├─ docs/                 # Specs, release readiness, snapshots, work board
├─ reports/              # Local validation artifacts, not the product source of truth
└─ build.gradle.kts

Roadmap / release status

Current release-track priorities:

1. Finish structured real-watch validation for the known-good line.
2. Finish the README/source-backed repo presentation pass.
3. Decide the beta scope for downloads/offline: keep as narrow proof/MVP surfaces or expand after more real-watch evidence.
4. Validate Full fidelity across more real watches, Bluetooth routes, and LTE/Wi-Fi transitions, including delivered-format and battery measurements.
5. Keep README, release checklist, and work board aligned with shipped behavior.
6. Only then promote from prerelease validation to a broader beta/release channel.

Contributing

Helpful contributions include:

• Real Wear OS device reports with model, Wear OS version, APK/tag, reproduction steps, and logs when possible.
• Small-screen UX fixes: round safe areas, rotary/crown behavior, keyboard/input transitions, AOD legibility, and copy clarity.
• Playback/queue bug reports with the track/album/playlist path used and whether the watch was foregrounded, backgrounded, screen-off, on Wi-Fi, or on Bluetooth.
• Documentation fixes that keep public claims aligned with current validation evidence.

Please do not include private tokens, TIDAL credentials, license data, manifest URLs, or non-public account/library details in issues or pull requests.

License

Untidy is currently source-available, not open-source. The code is public for review, issue filing, and upstream contributions, but commercial use, redistribution, forks, modified APKs, and derivative products are not permitted without written permission. See LICENSE.

This posture is intentional while the product, paid distribution model, and third-party platform/API requirements are still being validated. Third-party dependencies remain under their own licenses.

Legal and responsible use

Untidy is an unofficial, independent Wear OS client for the TIDAL music service. It is not affiliated with, endorsed by, or sponsored by TIDAL, Samsung, Google, or their subsidiaries. All trademarks belong to their respective owners.

Use your own TIDAL account and credentials. Untidy must not be used to bypass subscriptions, DRM, license checks, regional restrictions, or TIDAL API/SDK terms. Offline/download work must use sanctioned download/offline surfaces only; do not cache or redistribute streaming manifests or protected audio outside allowed APIs.

---

_{Built with Kotlin, Jetpack Compose for Wear OS, AndroidX Media3, and TIDAL auth/playback/API integrations.}