160 lines
4.9 KiB
TypeScript
160 lines
4.9 KiB
TypeScript
import {
|
|
useIsFocused,
|
|
useRoute,
|
|
useNavigation,
|
|
type NativeStackNavigationProp,
|
|
} from "expo-router"
|
|
import {
|
|
createContext,
|
|
useCallback,
|
|
useContext,
|
|
useLayoutEffect,
|
|
useMemo,
|
|
useRef,
|
|
useState,
|
|
type PropsWithChildren,
|
|
} from "react"
|
|
import { Platform } from "react-native"
|
|
import {
|
|
useSharedValue,
|
|
useAnimatedStyle,
|
|
withTiming,
|
|
type SharedValue,
|
|
} from "react-native-reanimated"
|
|
|
|
import { themeCoverPalette, type CoverPalette } from "@/lib/cover-palette"
|
|
import { useIsDark, useThemeColors } from "@/lib/theme"
|
|
|
|
type TabTheme = {
|
|
palette: CoverPalette
|
|
hasArtworkPalette: boolean
|
|
tabletBackground: SharedValue<string>
|
|
setPalette: (palette: CoverPalette | null, owner: string) => void
|
|
}
|
|
const AndroidTabTheme = createContext<TabTheme | null>(null)
|
|
|
|
const isTablet = Platform.OS === "ios" && Platform.isPad
|
|
const sharesPalette = Platform.OS === "android" || isTablet
|
|
|
|
function useDefaultPalette() {
|
|
const theme = useThemeColors()
|
|
const isDark = useIsDark()
|
|
return useMemo(() => themeCoverPalette(theme, isDark), [theme, isDark])
|
|
}
|
|
|
|
export function ScreenPaletteProvider({ children }: PropsWithChildren) {
|
|
const defaultPalette = useDefaultPalette()
|
|
const [screen, setScreen] = useState<{
|
|
palette: CoverPalette
|
|
owner: string
|
|
} | null>(null)
|
|
const palette = screen?.palette ?? defaultPalette
|
|
const hasArtwork =
|
|
palette.background !== defaultPalette.background ||
|
|
palette.foreground !== defaultPalette.foreground ||
|
|
palette.secondaryForeground !== defaultPalette.secondaryForeground ||
|
|
palette.accent !== defaultPalette.accent
|
|
const tabletBackground = useSharedValue(defaultPalette.background)
|
|
useLayoutEffect(() => {
|
|
if (!isTablet) return
|
|
tabletBackground.value = withTiming(palette.background, {
|
|
duration: TABLET_FADE_MS,
|
|
})
|
|
}, [tabletBackground, palette.background])
|
|
const paletteOwner = useRef<string | null>(null)
|
|
const setPalette = useCallback(
|
|
(palette: CoverPalette | null, owner: string) => {
|
|
if (!palette && paletteOwner.current !== owner) return
|
|
paletteOwner.current = palette ? owner : null
|
|
if (isTablet) {
|
|
// React may defer commits while the iPad stack is animating.
|
|
tabletBackground.value = withTiming(
|
|
(palette ?? defaultPalette).background,
|
|
{ duration: TABLET_FADE_MS }
|
|
)
|
|
}
|
|
setScreen(palette ? { palette, owner } : null)
|
|
},
|
|
[tabletBackground, defaultPalette]
|
|
)
|
|
const value = useMemo(
|
|
() => ({
|
|
palette: hasArtwork ? palette : defaultPalette,
|
|
hasArtworkPalette: hasArtwork,
|
|
tabletBackground,
|
|
setPalette,
|
|
}),
|
|
[defaultPalette, hasArtwork, palette, setPalette, tabletBackground]
|
|
)
|
|
return (
|
|
<AndroidTabTheme.Provider value={value}>
|
|
{children}
|
|
</AndroidTabTheme.Provider>
|
|
)
|
|
}
|
|
|
|
export function useAndroidTabPalette() {
|
|
const theme = useContext(AndroidTabTheme)
|
|
const defaultPalette = useDefaultPalette()
|
|
return theme?.palette ?? defaultPalette
|
|
}
|
|
|
|
export function useAndroidTabHasArtworkPalette() {
|
|
return useContext(AndroidTabTheme)?.hasArtworkPalette ?? false
|
|
}
|
|
|
|
/** iPad fades the sidebar and content pane together; other layouts skip it. */
|
|
export function useTabletBackgroundStyle() {
|
|
const background = useContext(AndroidTabTheme)?.tabletBackground
|
|
return useAnimatedStyle(() =>
|
|
isTablet && background ? { backgroundColor: background.value } : {}
|
|
)
|
|
}
|
|
|
|
const TABLET_FADE_MS = 400
|
|
|
|
/**
|
|
* Artwork screens always paint their own palette so it slides with the page.
|
|
* Shared chrome (tab bar, mini player) switches when the transition starts.
|
|
*/
|
|
export function useScreenPalette(palette: CoverPalette) {
|
|
const isFocused = useIsFocused()
|
|
const owner = useRoute().key
|
|
const navigation =
|
|
useNavigation<NativeStackNavigationProp<Record<string, undefined>>>()
|
|
const [laidOut, setLaidOut] = useState(false)
|
|
const [closing, setClosing] = useState(false)
|
|
const onLayout = useCallback(() => setLaidOut(true), [])
|
|
const setPalette = useContext(AndroidTabTheme)?.setPalette
|
|
useLayoutEffect(() => {
|
|
if (!sharesPalette) return
|
|
const start = navigation.addListener("transitionStart", ({ data }) => {
|
|
if (data.closing) setPalette?.(null, owner)
|
|
else setPalette?.(palette, owner)
|
|
setClosing(data.closing)
|
|
})
|
|
const cancel = navigation.addListener("gestureCancel", () => {
|
|
setPalette?.(palette, owner)
|
|
setClosing(false)
|
|
})
|
|
return () => {
|
|
start()
|
|
cancel()
|
|
}
|
|
}, [navigation, setPalette, owner, palette])
|
|
const ready = laidOut || isTablet
|
|
const backgroundStyle = useTabletBackgroundStyle()
|
|
|
|
useLayoutEffect(() => {
|
|
if (!sharesPalette || !setPalette || !isFocused || !ready || closing) return
|
|
setPalette(palette, owner)
|
|
return () => setPalette(null, owner)
|
|
}, [closing, ready, isFocused, owner, palette, setPalette])
|
|
|
|
return {
|
|
palette,
|
|
backgroundStyle,
|
|
onLayout: sharesPalette ? onLayout : undefined,
|
|
}
|
|
}
|