Files
otunes/apps/mobile/native/TabletSidebar.swift
T
joshuafhigginsandClaude Opus 5.5 Verified 86235a11c4 feat: playlist cover artwork
Playlists draw a 2x2 of their first albums automatically. Owners can pick
from random grids, reshuffle, or upload an image on web and mobile.
Covers are rendered once into Convex storage and redrawn only when the
playlist's albums change. Web and iPad sidebars show playlist covers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:11:59 -05:00

363 lines
14 KiB
Swift

import UIKit
internal import ExpoModulesCore
final class TabletSidebar: Module {
public func definition() -> ExpoModulesCore.ModuleDefinition {
Name("TabletSidebar")
View(TabletSidebarView.self) {
Events("onProfilePress", "onPlaylistPress")
Prop("playlists") { (view: TabletSidebarView, value: [SidebarPlaylist]) in
view.playlists = value
view.configure()
}
Prop("accountName") { (view: TabletSidebarView, value: String) in
view.accountName = value
view.configure()
}
Prop("initials") { (view: TabletSidebarView, value: String) in
view.initials = value
view.configure()
}
Prop("imageURL") { (view: TabletSidebarView, value: String?) in
view.imageURL = value
view.configure()
}
Prop("active") { (view: TabletSidebarView, value: Bool) in
view.active = value
view.configure()
}
}
}
}
/// A playlist row under the sidebar's Playlists section.
struct SidebarPlaylist: Record {
@Field var id: String = ""
@Field var title: String = ""
/// Cover URL; changes whenever the artwork does. `nil` shows a list icon.
@Field var imageURL: String?
}
/// Adds UIKit sidebar features not yet exposed by Expo Router's native tabs.
final class TabletSidebarView: ExpoView {
let onProfilePress = EventDispatcher()
let onPlaylistPress = EventDispatcher()
var playlists: [SidebarPlaylist] = []
private let selectionProxy = SidebarSelectionProxy()
private var playlistTabs: [String: UITab] = [:]
private var coverImages: [String: UIImage] = [:]
private var coverTasks: [String: URLSessionDataTask] = [:]
var accountName = ""
var initials = ""
var imageURL: String?
var active = false
private var tabsObserver: NSObjectProtocol?
override func didMoveToWindow() {
super.didMoveToWindow()
if let tabsObserver {
NotificationCenter.default.removeObserver(tabsObserver)
self.tabsObserver = nil
}
if window != nil {
tabsObserver = NotificationCenter.default.addObserver(
forName: Notification.Name("oTunesTabsDidUpdate"), object: nil, queue: .main
) { [weak self] notification in
guard let self, self.active, self.window != nil,
let controller = notification.object as? UITabBarController,
self.owningTabController() === controller else { return }
if #available(iOS 18.0, *) { self.configure(controller) }
}
}
configure()
}
override func layoutSubviews() {
super.layoutSubviews()
configure()
}
func configure() {
guard active, window != nil, UIDevice.current.userInterfaceIdiom == .pad else { return }
DispatchQueue.main.async { [weak self] in
guard let self, self.active else { return }
if let tabs = self.owningTabController(), #available(iOS 18.0, *) {
self.configure(tabs)
}
}
}
private func owningTabController() -> UITabBarController? {
var responder: UIResponder? = self
while let current = responder {
if let controller = current as? UIViewController, let tabs = controller.tabBarController {
return tabs
}
responder = current.next
}
return nil
}
deinit {
if let tabsObserver { NotificationCenter.default.removeObserver(tabsObserver) }
coverTasks.values.forEach { $0.cancel() }
}
@available(iOS 18.0, *)
private func configure(_ controller: UITabBarController) {
configureGroups(controller)
configurePlaylists(controller)
let footer: SidebarAccountButton
if let existing = controller.sidebar.bottomBarView as? SidebarAccountButton {
footer = existing
} else {
footer = SidebarAccountButton()
controller.sidebar.bottomBarView = footer
}
configureTabBar(controller, footer: footer)
footer.update(name: accountName, initials: initials, imageURL: imageURL)
footer.onPress = { [weak self] in self?.onProfilePress() }
}
@available(iOS 18.0, *)
private func configureTabBar(_ controller: UITabBarController, footer: SidebarAccountButton) {
let destinations = controller.tabs.compactMap { $0 as? UITabGroup }.flatMap { $0.children }
.filter { !$0.identifier.hasPrefix(playlistTabPrefix) }
let selected = destinations.first { $0 === controller.selectedTab }
let contextualTab = selected ?? footer.contextualTab ?? destinations.first
footer.contextualTab = contextualTab
for tab in destinations {
let placement: UITab.Placement = tab === contextualTab ? .fixed : .sidebarOnly
if tab.preferredPlacement != placement {
tab.preferredPlacement = placement
}
}
}
@available(iOS 18.0, *)
private func configureGroups(_ controller: UITabBarController) {
// Reuse the router's UITab instances so selection and stack state stay native.
if !controller.tabs.contains(where: { $0.identifier == "otunes.library" }) {
let tabs = controller.tabs
guard tabs.count >= 9 else { return }
let selected = controller.selectedTab
func tab(_ route: String) -> UITab? {
tabs.first { $0.identifier == route }
}
let library = ["library", "(artists)", "(albums)", "(songs)", "(recent)"].compactMap(tab)
let playlists = ["(playlists)", "(favorites)"].compactMap(tab)
guard library.count == 5, playlists.count == 2,
let home = tab("home"), let search = tab("search") else { return }
let libraryGroup = UITabGroup(
title: "Library", image: nil, identifier: "otunes.library", children: library,
viewControllerProvider: { _ in UIViewController() })
let playlistGroup = UITabGroup(
title: "Playlists", image: nil, identifier: "otunes.playlists", children: playlists,
viewControllerProvider: { _ in UIViewController() })
// UIKit requires a managing controller to display the selected child of a group.
let libraryNavigation = UINavigationController()
libraryNavigation.isNavigationBarHidden = true
libraryGroup.managingNavigationController = libraryNavigation
let playlistNavigation = UINavigationController()
playlistNavigation.isNavigationBarHidden = true
playlistGroup.managingNavigationController = playlistNavigation
libraryGroup.sidebarAppearance = .rootSection
playlistGroup.sidebarAppearance = .rootSection
libraryGroup.preferredPlacement = .sidebarOnly
playlistGroup.preferredPlacement = .sidebarOnly
home.preferredPlacement = .fixed
search.preferredPlacement = .pinned
let contextualTab = (library + playlists).first { $0 === selected } ?? library.first
for tab in library + playlists {
tab.preferredPlacement = tab === contextualTab ? .fixed : .sidebarOnly
}
let delegate = controller.delegate
controller.delegate = nil
controller.setTabs([home, search, libraryGroup, playlistGroup], animated: false)
controller.selectedTab = selected
controller.delegate = delegate
}
}
}
private let playlistTabPrefix = "otunes.playlist."
private let playlistIconSize: CGFloat = 24
extension TabletSidebarView {
/// Lists each playlist under Playlists with its cover. Rows are never
/// selected natively: a tap opens the playlist in the All Playlists stack.
@available(iOS 18.0, *)
fileprivate func configurePlaylists(_ controller: UITabBarController) {
guard let group = controller.tabs.first(where: { $0.identifier == "otunes.playlists" })
as? UITabGroup else { return }
if !(controller.delegate is SidebarSelectionProxy) {
selectionProxy.original = controller.delegate
controller.delegate = selectionProxy
}
selectionProxy.onPlaylist = { [weak self] id in self?.onPlaylistPress(["id": id]) }
var rows: [UITab] = []
for playlist in playlists {
let identifier = playlistTabPrefix + playlist.id
let tab = playlistTabs[identifier] ?? UITab(
title: playlist.title, image: nil, identifier: identifier,
viewControllerProvider: { _ in UIViewController() })
playlistTabs[identifier] = tab
if tab.title != playlist.title { tab.title = playlist.title }
tab.preferredPlacement = .sidebarOnly
tab.image = playlistImage(identifier: identifier, url: playlist.imageURL)
rows.append(tab)
}
let ids = Set(rows.map(\.identifier))
playlistTabs = playlistTabs.filter { ids.contains($0.key) }
let fixed = group.children.filter { !$0.identifier.hasPrefix(playlistTabPrefix) }
let children = fixed + rows
if group.children.map(\.identifier) != children.map(\.identifier) {
group.children = children
}
}
/// The cached cover for `url`, starting a download on a miss.
@available(iOS 18.0, *)
private func playlistImage(identifier: String, url: String?) -> UIImage? {
let placeholder = UIImage(systemName: "music.note.list")
guard let url, let remote = URL(string: url) else { return placeholder }
if let image = coverImages[url] { return image }
if coverTasks[url] == nil {
let task = URLSession.shared.dataTask(with: remote) { [weak self] data, _, _ in
guard let data, let image = UIImage(data: data) else { return }
DispatchQueue.main.async {
guard let self else { return }
self.coverTasks[url] = nil
self.coverImages[url] = roundedIcon(image)
if let tab = self.playlistTabs[identifier] { tab.image = self.coverImages[url] }
}
}
coverTasks[url] = task
task.resume()
}
return placeholder
}
}
/// Square cover shrunk to sidebar icon size with rounded corners, drawn as is
/// rather than tinted like a symbol.
private func roundedIcon(_ image: UIImage) -> UIImage {
let size = CGSize(width: playlistIconSize, height: playlistIconSize)
let rendered = UIGraphicsImageRenderer(size: size).image { _ in
UIBezierPath(roundedRect: CGRect(origin: .zero, size: size), cornerRadius: 4).addClip()
image.draw(in: CGRect(origin: .zero, size: size))
}
return rendered.withRenderingMode(.alwaysOriginal)
}
/// Sits in front of the router's tab controller delegate. Taps on playlist
/// rows go to JS; everything else is forwarded untouched.
private final class SidebarSelectionProxy: NSObject, UITabBarControllerDelegate {
weak var original: UITabBarControllerDelegate?
var onPlaylist: ((String) -> Void)?
override func responds(to aSelector: Selector!) -> Bool {
super.responds(to: aSelector) || (original?.responds(to: aSelector) ?? false)
}
override func forwardingTarget(for aSelector: Selector!) -> Any? { original }
@available(iOS 18.0, *)
func tabBarController(_ tabBarController: UITabBarController, shouldSelectTab tab: UITab) -> Bool {
if tab.identifier.hasPrefix(playlistTabPrefix) {
onPlaylist?(String(tab.identifier.dropFirst(playlistTabPrefix.count)))
return false
}
return original?.tabBarController?(tabBarController, shouldSelectTab: tab) ?? true
}
}
@available(iOS 18.0, *)
private final class SidebarAccountButton: UIView {
var onPress: (() -> Void)?
var contextualTab: UITab?
private let button = UIButton(type: .system)
private let avatar = UILabel()
private let imageView = UIImageView()
private var currentURL: String?
private var imageTask: URLSessionDataTask?
override init(frame: CGRect) {
super.init(frame: frame)
let separator = UIView()
separator.backgroundColor = .separator
addSubview(separator)
addSubview(button)
button.addSubview(avatar)
avatar.addSubview(imageView)
avatar.backgroundColor = .secondarySystemFill
avatar.textColor = .white
avatar.font = .systemFont(ofSize: 13, weight: .semibold)
avatar.textAlignment = .center
avatar.layer.cornerRadius = 16
avatar.clipsToBounds = true
imageView.contentMode = .scaleAspectFill
button.contentHorizontalAlignment = .leading
button.titleLabel?.font = .systemFont(ofSize: 17, weight: .medium)
button.setTitleColor(.white, for: .normal)
button.addAction(UIAction { [weak self] _ in self?.onPress?() }, for: .touchUpInside)
for view in [separator, button, avatar, imageView] {
view.translatesAutoresizingMaskIntoConstraints = false
}
NSLayoutConstraint.activate([
separator.topAnchor.constraint(equalTo: topAnchor),
separator.leadingAnchor.constraint(equalTo: leadingAnchor),
separator.trailingAnchor.constraint(equalTo: trailingAnchor),
separator.heightAnchor.constraint(equalToConstant: 1 / UIScreen.main.scale),
button.topAnchor.constraint(equalTo: topAnchor),
button.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 20),
button.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
button.bottomAnchor.constraint(equalTo: bottomAnchor),
avatar.leadingAnchor.constraint(equalTo: button.leadingAnchor),
avatar.centerYAnchor.constraint(equalTo: button.centerYAnchor),
avatar.widthAnchor.constraint(equalToConstant: 32),
avatar.heightAnchor.constraint(equalToConstant: 32),
imageView.topAnchor.constraint(equalTo: avatar.topAnchor),
imageView.bottomAnchor.constraint(equalTo: avatar.bottomAnchor),
imageView.leadingAnchor.constraint(equalTo: avatar.leadingAnchor),
imageView.trailingAnchor.constraint(equalTo: avatar.trailingAnchor),
])
button.titleEdgeInsets = UIEdgeInsets(top: 0, left: 44, bottom: 0, right: 0)
}
required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
override func systemLayoutSizeFitting(
_ targetSize: CGSize,
withHorizontalFittingPriority horizontalFittingPriority: UILayoutPriority,
verticalFittingPriority: UILayoutPriority
) -> CGSize {
CGSize(width: targetSize.width, height: 76)
}
func update(name: String, initials: String, imageURL: String?) {
button.setTitle(name, for: .normal)
button.accessibilityLabel = "Open profile, " + name
avatar.text = initials
guard imageURL != currentURL else { return }
currentURL = imageURL
imageTask?.cancel()
imageView.image = nil
guard let imageURL, let url = URL(string: imageURL) else { return }
imageTask = URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
guard let data, let image = UIImage(data: data) else { return }
DispatchQueue.main.async {
guard let self, self.currentURL == imageURL else { return }
self.imageView.image = image
}
}
imageTask?.resume()
}
deinit { imageTask?.cancel() }
}