Skip to content

Liquid Glass and Apple Music touches for the Spotify iOS app. A GPL-3.0 fork of spoti.pw 0.21.1.

C

feat: record clean view trees screen by screen, each marked with the mod's settings

Vojtěch Škopek98ba047a5d71
diff --git a/.gitignore b/.gitignore
index a83bdc90..093514cf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,4 @@ tweak/obj/
tweak/packages/
tweak/Sources/Features/Flags/SGFlagList.m
/trees/continuous
+/trees/clean
diff --git a/Makefile b/Makefile
index b145c8c6..d82ab295 100644
--- a/Makefile
+++ b/Makefile
@@ -12,7 +12,7 @@ FLEX_ARG := $(if $(filter 0,$(FLEX)),--no-flex,)
DEV_NAME ?= spoti.dev
DEV_ICON ?= docs/icon.png
-.PHONY: build release install publish push trees log flags
+.PHONY: build release install publish push trees session log flags
build: ## FLEX + glass IPA into out/
./scripts/pipeline.sh $(IPA)
release: ## glass only, no FLEX
@@ -25,7 +25,9 @@ push: ## commit and push the staged release in both repos
./scripts/publish.sh push
trees: ## record per-screen view trees into trees/ (needs a FLEX build on the phone)
./scripts/record-trees.py
-log: ## stream the tweak's log lines from the phone
+session: ## record clean trees screen by screen into trees/clean/, Enter per snapshot, n for the next screen (SCREENS="playlist artist" for some)
+ ./scripts/record-session.py $(SCREENS)
+log: ## stream the tweak's log lines from the phone
./scripts/dump-log.sh
flags: ## regenerate tweak/Sources/Features/Flags/SGFlagList.m, Spotify's remote-config flags, from the IPA
./scripts/extract-flags.py $(IPA)
diff --git a/docs/tweaks.md b/docs/tweaks.md
index 80c9881f..b505fed5 100644
--- a/docs/tweaks.md
+++ b/docs/tweaks.md
@@ -12,8 +12,10 @@
tweak/Sources/Features/ one directory per feature, see below
tweak/Sources/Diagnostics/ screen dumps and the tree server of FLEX builds
scripts/ pipeline.sh (build + inject), install.sh (sign + install), record-trees.py,
- dump-log.sh, extract-flags.py, publish.sh (release: version bump, site release.json)
- trees/ recorded view trees, one per screen; the input for every new hook
+ record-session.py, dump-log.sh, extract-flags.py, publish.sh (release: version bump,
+ site release.json)
+ trees/ recorded view trees, one per screen; the input for every new hook. trees/clean/ holds
+ the numbered snapshots per screen of record-session.py, taken of Spotify as it came
plist/ Info.plist overrides merged into the app (turns UIDesignRequiresCompatibility off)
vendor/ AutoFLEX deb
ipa/, out/ decrypted Spotify IPA in, built IPAs out (both gitignored)
@@ -80,6 +82,8 @@ out again, as are the Home gradient's colour, strength and height, but not the s
make install # build without FLEX, sign with your certificate, install over USB
make install FLEX=1 # the same with FLEX, which is what make trees reads through
make trees # record view trees screen by screen (FLEX build open on the phone, USB)
+ make session # clean trees, as many snapshots per screen as you like: Enter saves, n goes to the next screen
+ # (SCREENS="playlist artist" for some); every snapshot says whether the mod was at stock
make log # stream [spotifyglass] log lines from the phone
make flags # regenerate the flag table from the IPA
diff --git a/scripts/record-session.py b/scripts/record-session.py
new file mode 100755
index 00000000..6275df55
--- /dev/null
+++ b/scripts/record-session.py
@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""Record clean view trees screen by screen, as many snapshots of each screen as you like.
+
+ scripts/record-session.py # every screen of the session, in order
+ scripts/record-session.py playlist artist # only these screens
+ scripts/record-session.py --list # the screens and what is recorded so far
+ scripts/record-session.py -o trees/other # another folder (default trees/clean)
+ scripts/record-session.py --url URL # fetch from URL instead of the phone (testing)
+
+It names a screen ("now record: playlist") and every Enter saves the tree of what the phone shows as
+the next numbered file of that screen, trees/clean/<screen>/01.txt, 02.txt and on. Type a few words
+before Enter to put them in the name ("02 scrolled.txt"); a screen's name alone jumps to that screen
+instead. n goes on to the next screen, b back to the one before; u takes back the last snapshot, q quits. trees/clean/INDEX.txt lists what is recorded.
+
+The tree comes from the tree server of a FLEX build (make install FLEX=1), through iproxy over USB, the
+way scripts/record-trees.py gets it. That build also reports the mod's own settings under "== mod", so
+every snapshot says whether it shows Spotify as it came or a screen a switch of the mod's has changed.
+"""
+import datetime
+import hashlib
+import importlib.util
+import os
+import re
+try:
+ import readline # noqa: F401 arrow keys and history at the prompt
+except ImportError:
+ pass
+import subprocess
+import sys
+import time
+import urllib.request
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+PORT = 8085
+
+# The tree recorder's own helpers (describe, fetch), so both scripts read the phone the same way.
+_spec = importlib.util.spec_from_file_location("record_trees", os.path.join(HERE, "record-trees.py"))
+recorder = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(recorder)
+
+# (folder, how to get there, the states worth a snapshot each)
+SESSION = [
+ ("home", "the Home tab", [
+ "the top of Home",
+ "scroll down a screen at a time to the bottom, Enter after each",
+ "the side drawer (tap your avatar)",
+ ]),
+ ("search", "the Search tab", [
+ "the browse page, top",
+ "the browse page scrolled to the bottom",
+ "tap the search field: recent searches",
+ "type an artist's name: the results",
+ "each filter chip in turn: Songs, Artists, Albums, Playlists",
+ "results scrolled",
+ ]),
+ ("library", "the Library tab", [
+ "the top, as a list",
+ "as a grid",
+ "each filter chip in turn: Playlists, Albums, Artists, Downloaded",
+ "the sort sheet",
+ "scrolled to the bottom",
+ "search in Library opened",
+ ]),
+ ("playlist", "a playlist someone else made, a Spotify editorial one for instance", [
+ "the top",
+ "scroll down a screen at a time to the very bottom (recommended songs)",
+ "find in playlist opened",
+ "the sort sheet",
+ "the … menu of a track",
+ ]),
+ ("liked-songs", "Library → Liked Songs", [
+ "the top",
+ "scrolled",
+ ]),
+ ("own-playlist", "a playlist you made yourself", [
+ "the top",
+ "scrolled",
+ "edit mode",
+ ]),
+ ("album", "any album (a multi-disc one too, if you have one)", [
+ "the top",
+ "scroll down a screen at a time to the very bottom",
+ ]),
+ ("artist", "any artist page", [
+ "the top",
+ "scroll down a screen at a time to the very bottom",
+ "Popular, after tapping See more",
+ "the discography page (Show all)",
+ ]),
+ ("player", "tap the now playing bar to open the full screen player", [
+ "the player while playing",
+ "the player paused",
+ "scroll down through every card to the very bottom",
+ "a track with a Canvas video, if you come across one",
+ ]),
+ ("lyrics", "open the lyrics from the player", [
+ "the lyrics page",
+ "scrolled by hand",
+ ]),
+ ("queue", "open the queue from the player", [
+ "the top",
+ "scrolled",
+ ]),
+]
+
+CHECKLIST = """Before recording, the phone needs:
+ 1. the FLEX build of the mod on it: make install FLEX=1 (only that build serves the tree)
+ 2. stock Spotify: Mod Settings → Mod → Export settings (keep the file), then Reset all settings.
+ Spotify restarts with every switch off; close the welcome tour if it comes up.
+ Afterwards, Mod Settings → Mod → Import settings brings your settings back.
+ 3. Spotify open in the foreground, the phone unlocked and on USB."""
+
+HELP = """ Enter save a snapshot of what the phone shows
+ words + Enter save a snapshot with those words in its name ("scrolled", "see more")
+ n / b next screen / the screen before
+ j <screen> jump to a screen by name or number (a screen's name alone jumps too)
+ u take back the last snapshot saved on this screen
+ r delete every snapshot of this screen (asks first)
+ l what is recorded so far
+ q quit"""
+
+NUMBERED = re.compile(r"^(\d+)(?: (.*))?\.txt$")
+UNSAFE = re.compile(r"[^\w\- ]+")
+
+
+def shown(path):
+ """A path as the user reads it: relative to the repo when it is inside it."""
+ relative = os.path.relpath(path, ROOT)
+ return path if relative.startswith("..") else relative
+
+
+def ask(prompt):
+ try:
+ return input(prompt).strip()
+ except EOFError:
+ return "q"
+
+
+def mod_state(text):
+ """(clean, reason) from the tree's "== mod" section; clean is None for a build without one."""
+ lines = text.split("\n")
+ try:
+ start = lines.index("== mod")
+ except ValueError:
+ return None, "the build on the phone does not report the mod's settings; reinstall with make install FLEX=1"
+ stock, dirty = False, []
+ for line in lines[start + 1:]:
+ if line.startswith("== "):
+ break
+ if line.startswith("stock "):
+ stock = line.split(" ", 1)[1].strip() == "yes"
+ continue
+ key, sep, value = line.partition(" = ")
+ if not sep:
+ continue
+ value = value.strip()
+ if key.startswith("spotifyglass.flag."):
+ dirty.append(f"flag {key[len('spotifyglass.flag.'):]} forced {value}")
+ elif value.startswith(("list:", "map:")):
+ if not value.endswith(":0"):
+ dirty.append(f"{key} ({value})")
+ elif re.fullmatch(r"-?\d+(\.\d+)?", value):
+ if float(value) > 0:
+ dirty.append(f"{key} = {value}")
+ if not stock:
+ dirty.insert(0, "Reset all settings has not been run, so every switch that defaults to on is on")
+ return not dirty, "; ".join(dirty)
+
+
+class Screen:
+ def __init__(self, index, name, hint, states, folder):
+ self.index, self.name, self.hint, self.states = index, name, hint, states
+ self.folder = os.path.join(folder, name)
+ self.saved = [] # paths saved by this run, newest last, for u
+
+ def snapshots(self):
+ if not os.path.isdir(self.folder):
+ return []
+ found = []
+ for entry in os.listdir(self.folder):
+ m = NUMBERED.match(entry)
+ if m:
+ found.append((int(m.group(1)), os.path.join(self.folder, entry)))
+ return [path for _, path in sorted(found)]
+
+ def next_number(self):
+ numbers = [int(NUMBERED.match(os.path.basename(p)).group(1)) for p in self.snapshots()]
+ return max(numbers, default=0) + 1
+
+
+def header_of(path):
+ info = {}
+ with open(path, errors="replace") as f:
+ for line in f:
+ if not line.startswith("# ") or line.startswith("# tree:"):
+ break
+ key, _, value = line[2:].rstrip("\n").partition(": ")
+ info[key] = value
+ return info
+
+
+def write_index(folder, screens):
+ lines = [f"# Clean view trees, recorded with scripts/record-session.py. Written {datetime.datetime.now():%Y-%m-%d %H:%M}.", ""]
+ names = [s.name for s in screens]
+ others = sorted(d for d in os.listdir(folder) if os.path.isdir(os.path.join(folder, d)) and d not in names) if os.path.isdir(folder) else []
+ for screen in screens + [Screen(0, d, "", [], folder) for d in others]:
+ paths = screen.snapshots()
+ if not paths:
+ continue
+ lines.append(f"{screen.name}/")
+ for path in paths:
+ info = header_of(path)
+ lines.append(f" {os.path.basename(path):<28} {info.get('recorded', ''):<28} mod: {info.get('mod', '?'):<10} {info.get('shape', '')}")
+ lines.append("")
+ os.makedirs(folder, exist_ok=True)
+ with open(os.path.join(folder, "INDEX.txt"), "w") as f:
+ f.write("\n".join(lines))
+
+
+def fetch_tree(url, attempts=1):
+ for attempt in range(attempts):
+ try:
+ text = recorder.fetch(url)
+ if "== window" in text:
+ return text, None
+ error = "the phone answered, but not with a tree"
+ except Exception as e: # the tunnel may still be coming up, or Spotify is in the background
+ error = str(e)
+ if attempt + 1 < attempts:
+ time.sleep(1)
+ return None, error
+
+
+def save(screen, url, note, last_hash):
+ text, error = fetch_tree(url)
+ if text is None:
+ print(f" could not get the tree ({error}).")
+ print(" Spotify (the FLEX build) must be in the foreground, the phone unlocked and on USB; press Enter to try again.")
+ return last_hash
+ digest = hashlib.sha1(text.encode()).hexdigest()
+ if digest == last_hash:
+ print(" the same tree as the snapshot before, not saved (the screen has not changed yet?)")
+ return last_hash
+ clean, reason = mod_state(text)
+ os.makedirs(screen.folder, exist_ok=True)
+ number = screen.next_number()
+ label = UNSAFE.sub("", note).strip()[:40]
+ path = os.path.join(screen.folder, f"{number:02d}{' ' + label if label else ''}.txt")
+ mod = "clean" if clean else ("unknown" if clean is None else "NOT CLEAN")
+ with open(path, "w") as f:
+ f.write(f"# screen: {screen.name}\n")
+ f.write(f"# snapshot: {number}{' (' + label + ')' if label else ''}\n")
+ f.write(f"# recorded: {datetime.datetime.now():%Y-%m-%d %H:%M:%S} via usb\n")
+ f.write(f"# mod: {mod}\n")
+ if reason:
+ f.write(f"# mod detail: {reason}\n")
+ f.write(f"# shape: {recorder.describe(text)}\n")
+ f.write("# tree:\n" + text + ("" if text.endswith("\n") else "\n"))
+ screen.saved.append(path)
+ print(f" saved {shown(path)}: {text.count(chr(10))} lines, mod {mod}")
+ if clean is False:
+ print(f" ⚠ not stock Spotify: {reason}")
+ elif clean is None:
+ print(f" ⚠ {reason}")
+ return digest
+
+
+def show_progress(screens, current=None):
+ print()
+ for screen in screens:
+ count = len(screen.snapshots())
+ mark = "▶" if screen is current else " "
+ print(f" {mark} {screen.index:2d}. {screen.name:<13} {count:>3} snapshot{'s' if count != 1 else ' '} {screen.hint}")
+ print()
+
+
+def introduce(screen, total):
+ print(f"\n━━ {screen.index}/{total} now record: {screen.name.upper()} ━━")
+ print(f" go to {screen.hint}")
+ if screen.states:
+ print(" worth a snapshot each:")
+ for state in screen.states:
+ print(f" · {state}")
+ existing = len(screen.snapshots())
+ if existing:
+ print(f" {existing} already recorded here; new ones are numbered from {screen.next_number()} (r clears them)")
+ print(" Enter saves, words + Enter saves with a name, a screen's name jumps there, n next, b back, h help")
+
+
+def run(screens, url, folder):
+ position, last_hash = 0, None
+ introduce(screens[0], len(screens))
+ while True:
+ screen = screens[position]
+ answer = ask(f" {screen.name} > ")
+ command = answer.lower()
+ if command == "q":
+ return
+ if command in ("h", "?", "help"):
+ print(HELP)
+ elif command == "n" or command == "b":
+ step = 1 if command == "n" else -1
+ if not 0 <= position + step < len(screens):
+ if command == "n":
+ print(" that was the last screen: q quits, b goes back, j <screen> jumps")
+ continue
+ position += step
+ last_hash = None
+ introduce(screens[position], len(screens))
+ elif command.startswith("j ") or command == "j" or command in [s.name for s in screens]:
+ target = command[1:].strip() if command.startswith("j") and command not in [s.name for s in screens] else command
+ match = [s for s in screens if s.name == target or str(s.index) == target]
+ if not match:
+ print(f" no screen {target!r}; l lists them")
+ continue
+ position = screens.index(match[0])
+ last_hash = None
+ introduce(screens[position], len(screens))
+ elif command == "l":
+ show_progress(screens, screen)
+ elif command == "u":
+ if not screen.saved:
+ print(" nothing saved on this screen in this run to take back")
+ continue
+ path = screen.saved.pop()
+ if os.path.exists(path):
+ os.remove(path)
+ last_hash = None
+ print(f" removed {shown(path)}")
+ elif command == "r":
+ paths = screen.snapshots()
+ if not paths:
+ print(" nothing recorded on this screen")
+ continue
+ if ask(f" delete all {len(paths)} snapshots of {screen.name}? [y/N] ").lower() == "y":
+ for path in paths:
+ os.remove(path)
+ screen.saved.clear()
+ last_hash = None
+ print(" cleared")
+ elif command in [name for name, _, _ in SESSION]:
+ print(f" {command} is not in this run; start the script without screen names to have every screen")
+ continue
+ elif len(command) == 1:
+ print(" not a command; h lists them (a name for a snapshot needs two letters or more)")
+ continue
+ else:
+ last_hash = save(screen, url, answer, last_hash)
+ write_index(folder, screens)
+
+
+def main():
+ args = sys.argv[1:]
+ folder = os.path.join(ROOT, "trees", "clean")
+ url, listing, wanted = None, False, []
+ while args:
+ arg = args.pop(0)
+ if arg in ("-h", "--help"):
+ sys.exit(__doc__)
+ elif arg == "-o" and args:
+ folder = os.path.abspath(args.pop(0))
+ elif arg == "--url" and args:
+ url = args.pop(0)
+ elif arg == "--list":
+ listing = True
+ elif arg.startswith("-"):
+ sys.exit(__doc__)
+ else:
+ wanted.append(arg.lower())
+
+ names = [name for name, _, _ in SESSION]
+ unknown = [w for w in wanted if w not in names]
+ if unknown:
+ sys.exit(f"unknown screen {', '.join(unknown)}; the session has: {', '.join(names)}")
+ chosen = [entry for entry in SESSION if not wanted or entry[0] in wanted]
+ screens = [Screen(i, name, hint, states, folder) for i, (name, hint, states) in enumerate(chosen, 1)]
+
+ if listing:
+ print(f"trees in {shown(folder)}/")
+ show_progress(screens)
+ return
+
+ tunnel = None
+ if url is None:
+ if subprocess.run(["idevice_id", "-l"], capture_output=True, text=True).stdout.strip() == "":
+ sys.exit("no iPhone on USB: plug it in, unlock it, tap Trust if asked, then run again")
+ tunnel = subprocess.Popen(["iproxy", f"{PORT}:{PORT}"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+ url = f"http://127.0.0.1:{PORT}/tree"
+
+ try:
+ print(CHECKLIST)
+ while True:
+ text, error = fetch_tree(url, attempts=4)
+ if text is not None:
+ break
+ print(f"\n the phone is not answering yet ({error}).")
+ if ask(" press Enter to try again, q to quit > ").lower() == "q":
+ return
+ clean, reason = mod_state(text)
+ if clean:
+ print("\n ✓ the phone answers, and the mod is at stock: every snapshot will be Spotify as it came")
+ else:
+ print(f"\n ⚠ the phone answers, but {'the mod is not at stock' if clean is False else 'the mod state is unknown'}: {reason}")
+ print(" snapshots are still saved and marked NOT CLEAN; see step 2 above to make them clean")
+ run(screens, url, folder)
+ except KeyboardInterrupt:
+ print()
+ finally:
+ if tunnel:
+ tunnel.terminate()
+ write_index(folder, screens)
+ print(f"done, trees are in {shown(folder)}/ (INDEX.txt lists them)")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tweak/Sources/Diagnostics/Diagnostics.x b/tweak/Sources/Diagnostics/Diagnostics.x
index 54da80e5..dd1fde45 100644
--- a/tweak/Sources/Diagnostics/Diagnostics.x
+++ b/tweak/Sources/Diagnostics/Diagnostics.x
@@ -43,6 +43,36 @@ BOOL SGIsDebugBuild(void) {
return NSClassFromString(@"FLEXManager") != nil;
}
+// What the mod has set, so a recorded tree says whether it shows Spotify as it came or a screen some
+// switch has already changed: the stock marker Reset all settings leaves, then every key of the mod's
+// with its value. The counters, the update check, the signing warning, the tour and the Musixmatch
+// token belong to the install rather than to a choice, as in About/Backup.m, and are left out.
+// scripts/record-session.py reads this section to call a snapshot clean or not.
+static NSString *describeValue(id value) {
+ if ([value isKindOfClass:NSArray.class] || [value isKindOfClass:NSDictionary.class]) {
+ return [NSString stringWithFormat:@"%@%lu", [value isKindOfClass:NSArray.class] ? @"list:" : @"map:", (unsigned long)[value count]];
+ }
+ if ([value isKindOfClass:NSString.class]) {
+ NSString *text = value;
+ return [NSString stringWithFormat:@"\"%@\"", text.length > 40 ? [[text substringToIndex:40] stringByAppendingString:@"…"] : text];
+ }
+ return [value description];
+}
+
+static void appendModState(NSMutableString *out) {
+ NSDictionary *stored = [NSUserDefaults.standardUserDefaults persistentDomainForName:NSBundle.mainBundle.bundleIdentifier] ?: @{};
+ [out appendFormat:@"== mod\nstock %@\n", [stored[SGKeyStock] boolValue] ? @"yes" : @"no"];
+ NSArray<NSString *> *local = @[@"spotifyglass.adblock.counts", @"spotifyglass.privacy.counts", @"spotifyglass.update.",
+ @"spotifyglass.signing.", @"spotifyglass.onboarding.", @"spotifyglass.navbar.stock",
+ @"spotifyglass.musixmatch.token"];
+ for (NSString *key in [stored.allKeys sortedArrayUsingSelector:@selector(compare:)]) {
+ if (![key hasPrefix:@"spotifyglass."] || [key isEqualToString:SGKeyStock]) continue;
+ BOOL skip = NO;
+ for (NSString *prefix in local) skip |= [key hasPrefix:prefix];
+ if (!skip) [out appendFormat:@"%@ = %@\n", key, describeValue(stored[key])];
+ }
+}
+
NSString *SGScreenTree(void) {
NSMutableString *out = [NSMutableString string];
UIViewController *root = nil;
@@ -58,6 +88,7 @@ NSString *SGScreenTree(void) {
if ([root respondsToSelector:@selector(_printHierarchy)]) {
[out appendFormat:@"== view controllers\n%@\n", [root _printHierarchy]];
}
+ appendModState(out);
return out;
}