mirror of
https://github.com/yattee/yattee.git
synced 2024-11-09 15:58:20 +00:00
726 lines
33 KiB
Swift
726 lines
33 KiB
Swift
import Defaults
|
|
import Foundation
|
|
import SwiftUI
|
|
#if os(iOS)
|
|
import UIKit
|
|
#endif
|
|
|
|
extension Defaults.Keys {
|
|
// MARK: GROUP - Browsing
|
|
|
|
static let showHome = Key<Bool>("showHome", default: true)
|
|
static let showOpenActionsInHome = Key<Bool>("showOpenActionsInHome", default: true)
|
|
static let showQueueInHome = Key<Bool>("showQueueInHome", default: true)
|
|
static let showFavoritesInHome = Key<Bool>("showFavoritesInHome", default: true)
|
|
static let favorites = Key<[FavoriteItem]>("favorites", default: [])
|
|
static let widgetsSettings = Key<[WidgetSettings]>("widgetsSettings", default: [])
|
|
static let startupSection = Key<StartupSection>("startupSection", default: .home)
|
|
static let showSearchSuggestions = Key<Bool>("showSearchSuggestions", default: true)
|
|
static let visibleSections = Key<Set<VisibleSection>>("visibleSections", default: [.subscriptions, .trending, .playlists])
|
|
|
|
static let showOpenActionsToolbarItem = Key<Bool>("showOpenActionsToolbarItem", default: false)
|
|
#if os(iOS)
|
|
static let showDocuments = Key<Bool>("showDocuments", default: false)
|
|
static let lockPortraitWhenBrowsing = Key<Bool>("lockPortraitWhenBrowsing", default: Constants.isIPhone)
|
|
#endif
|
|
|
|
#if !os(tvOS)
|
|
#if os(macOS)
|
|
static let accountPickerDisplaysUsernameDefault = true
|
|
#else
|
|
static let accountPickerDisplaysUsernameDefault = Constants.isIPad
|
|
#endif
|
|
static let accountPickerDisplaysUsername = Key<Bool>("accountPickerDisplaysUsername", default: accountPickerDisplaysUsernameDefault)
|
|
#endif
|
|
|
|
static let accountPickerDisplaysAnonymousAccounts = Key<Bool>("accountPickerDisplaysAnonymousAccounts", default: true)
|
|
static let showUnwatchedFeedBadges = Key<Bool>("showUnwatchedFeedBadges", default: false)
|
|
static let expandChannelDescription = Key<Bool>("expandChannelDescription", default: false)
|
|
|
|
static let keepChannelsWithUnwatchedFeedOnTop = Key<Bool>("keepChannelsWithUnwatchedFeedOnTop", default: true)
|
|
static let showChannelAvatarInChannelsLists = Key<Bool>("showChannelAvatarInChannelsLists", default: true)
|
|
static let showChannelAvatarInVideosListing = Key<Bool>("showChannelAvatarInVideosListing", default: true)
|
|
|
|
static let playerButtonSingleTapGesture = Key<PlayerTapGestureAction>("playerButtonSingleTapGesture", default: .togglePlayer)
|
|
static let playerButtonDoubleTapGesture = Key<PlayerTapGestureAction>("playerButtonDoubleTapGesture", default: .togglePlayerVisibility)
|
|
static let playerButtonShowsControlButtonsWhenMinimized = Key<Bool>("playerButtonShowsControlButtonsWhenMinimized", default: true)
|
|
static let playerButtonIsExpanded = Key<Bool>("playerButtonIsExpanded", default: true)
|
|
static let playerBarMaxWidth = Key<String>("playerBarMaxWidth", default: "600")
|
|
static let channelOnThumbnail = Key<Bool>("channelOnThumbnail", default: false)
|
|
static let timeOnThumbnail = Key<Bool>("timeOnThumbnail", default: true)
|
|
static let roundedThumbnails = Key<Bool>("roundedThumbnails", default: true)
|
|
static let thumbnailsQuality = Key<ThumbnailsQuality>("thumbnailsQuality", default: .highest)
|
|
|
|
// MARK: GROUP - Player
|
|
|
|
static let playerInstanceID = Key<Instance.ID?>("playerInstance")
|
|
|
|
#if os(tvOS)
|
|
static let pauseOnHidingPlayerDefault = true
|
|
#else
|
|
static let pauseOnHidingPlayerDefault = false
|
|
#endif
|
|
static let pauseOnHidingPlayer = Key<Bool>("pauseOnHidingPlayer", default: pauseOnHidingPlayerDefault)
|
|
|
|
static let closeVideoOnEOF = Key<Bool>("closeVideoOnEOF", default: false)
|
|
|
|
#if !os(macOS)
|
|
static let pauseOnEnteringBackground = Key<Bool>("pauseOnEnteringBackground", default: false)
|
|
#endif
|
|
|
|
#if os(iOS)
|
|
static let expandVideoDescriptionDefault = Constants.isIPad
|
|
#else
|
|
static let expandVideoDescriptionDefault = true
|
|
#endif
|
|
static let expandVideoDescription = Key<Bool>("expandVideoDescription", default: expandVideoDescriptionDefault)
|
|
|
|
static let collapsedLinesDescription = Key<Int>("collapsedLinesDescription", default: 5)
|
|
static let exitFullscreenOnEOF = Key<Bool>("exitFullscreenOnEOF", default: true)
|
|
|
|
static let showChapters = Key<Bool>("showChapters", default: true)
|
|
static let showChapterThumbnails = Key<Bool>("showChapterThumbnails", default: true)
|
|
static let showChapterThumbnailsOnlyWhenDifferent = Key<Bool>("showChapterThumbnailsOnlyWhenDifferent", default: false)
|
|
static let expandChapters = Key<Bool>("expandChapters", default: true)
|
|
static let showRelated = Key<Bool>("showRelated", default: true)
|
|
static let showInspector = Key<ShowInspectorSetting>("showInspector", default: .onlyLocal)
|
|
|
|
static let playerSidebar = Key<PlayerSidebarSetting>("playerSidebar", default: .defaultValue)
|
|
static let showKeywords = Key<Bool>("showKeywords", default: false)
|
|
static let showComments = Key<Bool>("showComments", default: true)
|
|
#if !os(tvOS)
|
|
static let showScrollToTopInComments = Key<Bool>("showScrollToTopInComments", default: true)
|
|
#endif
|
|
static let enableReturnYouTubeDislike = Key<Bool>("enableReturnYouTubeDislike", default: false)
|
|
|
|
#if os(iOS)
|
|
static let isOrientationLocked = Key<Bool>("isOrientationLocked", default: Constants.isIPhone)
|
|
static let enterFullscreenInLandscape = Key<Bool>("enterFullscreenInLandscape", default: Constants.isIPhone)
|
|
static let rotateToLandscapeOnEnterFullScreen = Key<FullScreenRotationSetting>("rotateToLandscapeOnEnterFullScreen", default: .landscapeRight)
|
|
#endif
|
|
|
|
static let closePiPOnNavigation = Key<Bool>("closePiPOnNavigation", default: false)
|
|
static let closePiPOnOpeningPlayer = Key<Bool>("closePiPOnOpeningPlayer", default: false)
|
|
static let closePlayerOnOpeningPiP = Key<Bool>("closePlayerOnOpeningPiP", default: false)
|
|
#if !os(macOS)
|
|
static let closePiPAndOpenPlayerOnEnteringForeground = Key<Bool>("closePiPAndOpenPlayerOnEnteringForeground", default: false)
|
|
#endif
|
|
|
|
static let captionsAutoShow = Key<Bool>("captionsAutoShow", default: false)
|
|
static let captionsDefaultLanguageCode = Key<String>("captionsDefaultLanguageCode", default: LanguageCodes.English.rawValue)
|
|
static let captionsFallbackLanguageCode = Key<String>("captionsDefaultFallbackCode", default: LanguageCodes.English.rawValue)
|
|
static let captionsFontScaleSize = Key<String>("captionsFontScale", default: "1.0")
|
|
static let captionsFontColor = Key<String>("captionsFontColor", default: "#FFFFFF")
|
|
|
|
// MARK: GROUP - Controls
|
|
|
|
static let avPlayerUsesSystemControls = Key<Bool>("avPlayerUsesSystemControls", default: Constants.isTvOS)
|
|
static let horizontalPlayerGestureEnabled = Key<Bool>("horizontalPlayerGestureEnabled", default: true)
|
|
static let seekGestureSensitivity = Key<Double>("seekGestureSensitivity", default: 30.0)
|
|
static let seekGestureSpeed = Key<Double>("seekGestureSpeed", default: 0.5)
|
|
|
|
#if os(iOS)
|
|
static let playerControlsLayoutDefault = Constants.isIPad ? PlayerControlsLayout.medium : .small
|
|
static let fullScreenPlayerControlsLayoutDefault = Constants.isIPad ? PlayerControlsLayout.medium : .small
|
|
#elseif os(tvOS)
|
|
static let playerControlsLayoutDefault = PlayerControlsLayout.tvRegular
|
|
static let fullScreenPlayerControlsLayoutDefault = PlayerControlsLayout.tvRegular
|
|
#else
|
|
static let playerControlsLayoutDefault = PlayerControlsLayout.medium
|
|
static let fullScreenPlayerControlsLayoutDefault = PlayerControlsLayout.medium
|
|
#endif
|
|
|
|
static let playerControlsLayout = Key<PlayerControlsLayout>("playerControlsLayout", default: playerControlsLayoutDefault)
|
|
static let fullScreenPlayerControlsLayout = Key<PlayerControlsLayout>("fullScreenPlayerControlsLayout", default: fullScreenPlayerControlsLayoutDefault)
|
|
static let playerControlsBackgroundOpacity = Key<Double>("playerControlsBackgroundOpacity", default: 0.2)
|
|
|
|
static let systemControlsCommands = Key<SystemControlsCommands>("systemControlsCommands", default: .restartAndAdvanceToNext)
|
|
|
|
static let buttonBackwardSeekDuration = Key<String>("buttonBackwardSeekDuration", default: "10")
|
|
static let buttonForwardSeekDuration = Key<String>("buttonForwardSeekDuration", default: "10")
|
|
static let gestureBackwardSeekDuration = Key<String>("gestureBackwardSeekDuration", default: "10")
|
|
static let gestureForwardSeekDuration = Key<String>("gestureForwardSeekDuration", default: "10")
|
|
static let systemControlsSeekDuration = Key<String>("systemControlsBackwardSeekDuration", default: "10")
|
|
|
|
#if os(iOS)
|
|
static let playerControlsLockOrientationEnabled = Key<Bool>("playerControlsLockOrientationEnabled", default: true)
|
|
#endif
|
|
#if os(tvOS)
|
|
static let playerControlsSettingsEnabledDefault = true
|
|
#else
|
|
static let playerControlsSettingsEnabledDefault = false
|
|
#endif
|
|
static let playerControlsSettingsEnabled = Key<Bool>("playerControlsSettingsEnabled", default: playerControlsSettingsEnabledDefault)
|
|
static let playerControlsCloseEnabled = Key<Bool>("playerControlsCloseEnabled", default: true)
|
|
static let playerControlsRestartEnabled = Key<Bool>("playerControlsRestartEnabled", default: false)
|
|
static let playerControlsAdvanceToNextEnabled = Key<Bool>("playerControlsAdvanceToNextEnabled", default: false)
|
|
static let playerControlsPlaybackModeEnabled = Key<Bool>("playerControlsPlaybackModeEnabled", default: false)
|
|
static let playerControlsMusicModeEnabled = Key<Bool>("playerControlsMusicModeEnabled", default: false)
|
|
|
|
static let playerActionsButtonLabelStyle = Key<ButtonLabelStyle>("playerActionsButtonLabelStyle", default: .iconAndText)
|
|
|
|
static let actionButtonShareEnabled = Key<Bool>("actionButtonShareEnabled", default: true)
|
|
static let actionButtonAddToPlaylistEnabled = Key<Bool>("actionButtonAddToPlaylistEnabled", default: true)
|
|
static let actionButtonSubscribeEnabled = Key<Bool>("actionButtonSubscribeEnabled", default: false)
|
|
static let actionButtonSettingsEnabled = Key<Bool>("actionButtonSettingsEnabled", default: true)
|
|
static let actionButtonHideEnabled = Key<Bool>("actionButtonHideEnabled", default: false)
|
|
static let actionButtonCloseEnabled = Key<Bool>("actionButtonCloseEnabled", default: true)
|
|
static let actionButtonFullScreenEnabled = Key<Bool>("actionButtonFullScreenEnabled", default: false)
|
|
static let actionButtonPipEnabled = Key<Bool>("actionButtonPipEnabled", default: false)
|
|
static let actionButtonLockOrientationEnabled = Key<Bool>("actionButtonLockOrientationEnabled", default: false)
|
|
static let actionButtonRestartEnabled = Key<Bool>("actionButtonRestartEnabled", default: false)
|
|
static let actionButtonAdvanceToNextItemEnabled = Key<Bool>("actionButtonAdvanceToNextItemEnabled", default: false)
|
|
static let actionButtonMusicModeEnabled = Key<Bool>("actionButtonMusicModeEnabled", default: true)
|
|
|
|
// MARK: GROUP - Quality
|
|
|
|
static let hd2160p60MPVProfile = QualityProfile(id: "hd2160p60MPVProfile", backend: .mpv, resolution: .hd2160p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let hd1080p60MPVProfile = QualityProfile(id: "hd1080p60MPVProfile", backend: .mpv, resolution: .hd1080p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let hd1080pMPVProfile = QualityProfile(id: "hd1080pMPVProfile", backend: .mpv, resolution: .hd1080p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let hd720p60MPVProfile = QualityProfile(id: "hd720p60MPVProfile", backend: .mpv, resolution: .hd720p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let hd720pMPVProfile = QualityProfile(id: "hd720pMPVProfile", backend: .mpv, resolution: .hd720p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let sd360pMPVProfile = QualityProfile(id: "sd360pMPVProfile", backend: .mpv, resolution: .sd360p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
|
|
static let hd720pAVPlayerProfile = QualityProfile(id: "hd720pAVPlayerProfile", backend: .appleAVPlayer, resolution: .hd720p30, formats: [.stream, .hls], order: Array(QualityProfile.Format.allCases.indices))
|
|
static let sd360pAVPlayerProfile = QualityProfile(id: "sd360pAVPlayerProfile", backend: .appleAVPlayer, resolution: .sd360p30, formats: [.stream, .hls], order: Array(QualityProfile.Format.allCases.indices))
|
|
|
|
#if os(iOS)
|
|
enum QualityProfiles {
|
|
// iPad-specific settings
|
|
enum iPad {
|
|
static let qualityProfilesDefault = [
|
|
hd1080p60MPVProfile,
|
|
hd1080pMPVProfile,
|
|
hd720p60MPVProfile,
|
|
hd720pMPVProfile
|
|
]
|
|
|
|
static let batteryCellularProfileDefault = hd720pMPVProfile.id
|
|
static let batteryNonCellularProfileDefault = hd720p60MPVProfile.id
|
|
static let chargingCellularProfileDefault = hd1080pMPVProfile.id
|
|
static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
}
|
|
|
|
// iPhone-specific settings
|
|
enum iPhone {
|
|
static let qualityProfilesDefault = [
|
|
hd1080p60MPVProfile,
|
|
hd1080pMPVProfile,
|
|
hd720p60MPVProfile,
|
|
hd720pMPVProfile,
|
|
sd360pMPVProfile
|
|
]
|
|
|
|
static let batteryCellularProfileDefault = sd360pMPVProfile.id
|
|
static let batteryNonCellularProfileDefault = hd720p60MPVProfile.id
|
|
static let chargingCellularProfileDefault = hd720pMPVProfile.id
|
|
static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
}
|
|
|
|
// Access the correct profile based on device type
|
|
static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
|
|
if Constants.isIPad {
|
|
return (
|
|
qualityProfilesDefault: iPad.qualityProfilesDefault,
|
|
batteryCellularProfileDefault: iPad.batteryCellularProfileDefault,
|
|
batteryNonCellularProfileDefault: iPad.batteryNonCellularProfileDefault,
|
|
chargingCellularProfileDefault: iPad.chargingCellularProfileDefault,
|
|
chargingNonCellularProfileDefault: iPad.chargingNonCellularProfileDefault
|
|
)
|
|
}
|
|
|
|
return (
|
|
qualityProfilesDefault: iPhone.qualityProfilesDefault,
|
|
batteryCellularProfileDefault: iPhone.batteryCellularProfileDefault,
|
|
batteryNonCellularProfileDefault: iPhone.batteryNonCellularProfileDefault,
|
|
chargingCellularProfileDefault: iPhone.chargingCellularProfileDefault,
|
|
chargingNonCellularProfileDefault: iPhone.chargingNonCellularProfileDefault
|
|
)
|
|
}
|
|
}
|
|
|
|
#elseif os(tvOS)
|
|
enum QualityProfiles {
|
|
// tvOS-specific settings
|
|
enum tvOS {
|
|
static let qualityProfilesDefault = [
|
|
hd2160p60MPVProfile,
|
|
hd1080p60MPVProfile,
|
|
hd720p60MPVProfile,
|
|
hd720pAVPlayerProfile
|
|
]
|
|
|
|
static let batteryCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let batteryNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let chargingCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
}
|
|
|
|
// Access the correct profile based on device type
|
|
static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
|
|
(
|
|
qualityProfilesDefault: tvOS.qualityProfilesDefault,
|
|
batteryCellularProfileDefault: tvOS.batteryCellularProfileDefault,
|
|
batteryNonCellularProfileDefault: tvOS.batteryNonCellularProfileDefault,
|
|
chargingCellularProfileDefault: tvOS.chargingCellularProfileDefault,
|
|
chargingNonCellularProfileDefault: tvOS.chargingNonCellularProfileDefault
|
|
)
|
|
}
|
|
}
|
|
#else
|
|
enum QualityProfiles {
|
|
// macOS-specific settings
|
|
enum macOS {
|
|
static let qualityProfilesDefault = [
|
|
hd2160p60MPVProfile,
|
|
hd1080p60MPVProfile,
|
|
hd1080pMPVProfile,
|
|
hd720p60MPVProfile
|
|
]
|
|
|
|
static let batteryCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let batteryNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let chargingCellularProfileDefault = hd1080p60MPVProfile.id
|
|
static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
|
|
}
|
|
|
|
// Access the correct profile for other platforms
|
|
static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
|
|
(
|
|
qualityProfilesDefault: macOS.qualityProfilesDefault,
|
|
batteryCellularProfileDefault: macOS.batteryCellularProfileDefault,
|
|
batteryNonCellularProfileDefault: macOS.batteryNonCellularProfileDefault,
|
|
chargingCellularProfileDefault: macOS.chargingCellularProfileDefault,
|
|
chargingNonCellularProfileDefault: macOS.chargingNonCellularProfileDefault
|
|
)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static let batteryCellularProfile = Key<QualityProfile.ID>(
|
|
"batteryCellularProfile",
|
|
default: QualityProfiles.currentProfile.batteryCellularProfileDefault
|
|
)
|
|
static let batteryNonCellularProfile = Key<QualityProfile.ID>(
|
|
"batteryNonCellularProfile",
|
|
default: QualityProfiles.currentProfile.batteryNonCellularProfileDefault
|
|
)
|
|
static let chargingCellularProfile = Key<QualityProfile.ID>(
|
|
"chargingCellularProfile",
|
|
default: QualityProfiles.currentProfile.chargingCellularProfileDefault
|
|
)
|
|
static let chargingNonCellularProfile = Key<QualityProfile.ID>(
|
|
"chargingNonCellularProfile",
|
|
default: QualityProfiles.currentProfile.chargingNonCellularProfileDefault
|
|
)
|
|
static let forceAVPlayerForLiveStreams = Key<Bool>(
|
|
"forceAVPlayerForLiveStreams",
|
|
default: true
|
|
)
|
|
static let qualityProfiles = Key<[QualityProfile]>(
|
|
"qualityProfiles",
|
|
default: QualityProfiles.currentProfile.qualityProfilesDefault
|
|
)
|
|
|
|
// MARK: GROUP - History
|
|
|
|
static let saveRecents = Key<Bool>("saveRecents", default: true)
|
|
static let saveHistory = Key<Bool>("saveHistory", default: true)
|
|
static let showRecents = Key<Bool>("showRecents", default: true)
|
|
static let limitRecents = Key<Bool>("limitRecents", default: false)
|
|
static let limitRecentsAmount = Key<Int>("limitRecentsAmount", default: 10)
|
|
static let showWatchingProgress = Key<Bool>("showWatchingProgress", default: true)
|
|
static let saveLastPlayed = Key<Bool>("saveLastPlayed", default: false)
|
|
|
|
static let watchedVideoPlayNowBehavior = Key<WatchedVideoPlayNowBehavior>("watchedVideoPlayNowBehavior", default: .continue)
|
|
static let watchedThreshold = Key<Int>("watchedThreshold", default: 90)
|
|
static let resetWatchedStatusOnPlaying = Key<Bool>("resetWatchedStatusOnPlaying", default: false)
|
|
|
|
static let watchedVideoStyle = Key<WatchedVideoStyle>("watchedVideoStyle", default: .badge)
|
|
static let watchedVideoBadgeColor = Key<WatchedVideoBadgeColor>("WatchedVideoBadgeColor", default: .red)
|
|
static let showToggleWatchedStatusButton = Key<Bool>("showToggleWatchedStatusButton", default: false)
|
|
|
|
// MARK: GROUP - SponsorBlock
|
|
|
|
static let sponsorBlockInstance = Key<String>("sponsorBlockInstance", default: "https://sponsor.ajay.app")
|
|
static let sponsorBlockCategories = Key<Set<String>>("sponsorBlockCategories", default: Set(SponsorBlockAPI.categories))
|
|
static let sponsorBlockColors = Key<[String: String]>("sponsorBlockColors", default: SponsorBlockColors.dictionary)
|
|
static let sponsorBlockShowTimeWithSkipsRemoved = Key<Bool>("sponsorBlockShowTimeWithSkipsRemoved", default: false)
|
|
static let sponsorBlockShowCategoriesInTimeline = Key<Bool>("sponsorBlockShowCategoriesInTimeline", default: true)
|
|
static let sponsorBlockShowNoticeAfterSkip = Key<Bool>("sponsorBlockShowNoticeAfterSkip", default: true)
|
|
|
|
// MARK: GROUP - Locations
|
|
|
|
static let instancesManifest = Key<String>("instancesManifest", default: "")
|
|
static let countryOfPublicInstances = Key<String?>("countryOfPublicInstances")
|
|
|
|
static let instances = Key<[Instance]>("instances", default: [])
|
|
static let accounts = Key<[Account]>("accounts", default: [])
|
|
|
|
// MARK: Group - Advanced
|
|
|
|
static let showPlayNowInBackendContextMenu = Key<Bool>("showPlayNowInBackendContextMenu", default: false)
|
|
static let videoLoadingRetryCount = Key<Int>("videoLoadingRetryCount", default: 10)
|
|
|
|
static let showMPVPlaybackStats = Key<Bool>("showMPVPlaybackStats", default: false)
|
|
static let mpvEnableLogging = Key<Bool>("mpvEnableLogging", default: false)
|
|
static let mpvCacheSecs = Key<String>("mpvCacheSecs", default: "120")
|
|
static let mpvCachePauseWait = Key<String>("mpvCachePauseWait", default: "3")
|
|
static let mpvCachePauseInital = Key<Bool>("mpvCachePauseInitial", default: false)
|
|
static let mpvDeinterlace = Key<Bool>("mpvDeinterlace", default: false)
|
|
static let mpvHWdec = Key<String>("hwdec", default: "auto-safe")
|
|
static let mpvDemuxerLavfProbeInfo = Key<String>("mpvDemuxerLavfProbeInfo", default: "no")
|
|
static let mpvInitialAudioSync = Key<Bool>("mpvInitialAudioSync", default: true)
|
|
static let mpvSetRefreshToContentFPS = Key<Bool>("mpvSetRefreshToContentFPS", default: false)
|
|
|
|
static let showCacheStatus = Key<Bool>("showCacheStatus", default: false)
|
|
static let feedCacheSize = Key<String>("feedCacheSize", default: "50")
|
|
|
|
// MARK: GROUP - Other exportable
|
|
|
|
static let lastAccountID = Key<Account.ID?>("lastAccountID")
|
|
static let lastInstanceID = Key<Instance.ID?>("lastInstanceID")
|
|
|
|
static let playerRate = Key<Double>("playerRate", default: 1.0)
|
|
static let recentlyOpened = Key<[RecentItem]>("recentlyOpened", default: [])
|
|
|
|
static let trendingCategory = Key<TrendingCategory>("trendingCategory", default: .default)
|
|
static let trendingCountry = Key<Country>("trendingCountry", default: .us)
|
|
|
|
static let subscriptionsViewPage = Key<SubscriptionsView.Page>("subscriptionsViewPage", default: .feed)
|
|
|
|
static let subscriptionsListingStyle = Key<ListingStyle>("subscriptionsListingStyle", default: .cells)
|
|
static let popularListingStyle = Key<ListingStyle>("popularListingStyle", default: .cells)
|
|
static let trendingListingStyle = Key<ListingStyle>("trendingListingStyle", default: .cells)
|
|
static let playlistListingStyle = Key<ListingStyle>("playlistListingStyle", default: .list)
|
|
static let channelPlaylistListingStyle = Key<ListingStyle>("channelPlaylistListingStyle", default: .cells)
|
|
static let searchListingStyle = Key<ListingStyle>("searchListingStyle", default: .cells)
|
|
static let hideShorts = Key<Bool>("hideShorts", default: false)
|
|
static let hideWatched = Key<Bool>("hideWatched", default: false)
|
|
|
|
// MARK: GROUP - Not exportable
|
|
|
|
static let queue = Key<[PlayerQueueItem]>("queue", default: [])
|
|
static let playbackMode = Key<PlayerModel.PlaybackMode>("playbackMode", default: .queue)
|
|
static let lastPlayed = Key<PlayerQueueItem?>("lastPlayed")
|
|
|
|
static let activeBackend = Key<PlayerBackendType>("activeBackend", default: .mpv)
|
|
static let captionsLanguageCode = Key<String?>("captionsLanguageCode")
|
|
static let lastUsedPlaylistID = Key<Playlist.ID?>("lastPlaylistID")
|
|
static let lastAccountIsPublic = Key<Bool>("lastAccountIsPublic", default: false)
|
|
|
|
// MARK: LEGACY
|
|
|
|
static let homeHistoryItems = Key<Int>("homeHistoryItems", default: 10)
|
|
}
|
|
|
|
enum ResolutionSetting: String, CaseIterable, Defaults.Serializable {
|
|
case hd2160p60
|
|
case hd2160p30
|
|
case hd1440p60
|
|
case hd1440p30
|
|
case hd1080p60
|
|
case hd1080p30
|
|
case hd720p60
|
|
case hd720p30
|
|
case sd480p30
|
|
case sd360p30
|
|
case sd240p30
|
|
case sd144p30
|
|
|
|
var value: Stream.Resolution {
|
|
if let predefined = Stream.Resolution.PredefinedResolution(rawValue: rawValue) {
|
|
return .predefined(predefined)
|
|
}
|
|
// Provide a default value of 720p 30
|
|
return .custom(height: 720, refreshRate: 30)
|
|
}
|
|
|
|
var description: String {
|
|
let resolution = value
|
|
let height = resolution.height
|
|
let refreshRate = resolution.refreshRate
|
|
|
|
// Superscript labels
|
|
let superscript4K = "⁴ᴷ"
|
|
let superscriptHD = "ᴴᴰ"
|
|
|
|
// Special handling for specific resolutions
|
|
switch height {
|
|
case 2160:
|
|
// 4K superscript after the refresh rate
|
|
return refreshRate == 30 ? "2160p \(superscript4K)" : "2160p\(refreshRate) \(superscript4K)"
|
|
case 1440, 1080:
|
|
// HD superscript after the refresh rate
|
|
return refreshRate == 30 ? "\(height)p \(superscriptHD)" : "\(height)p\(refreshRate) \(superscriptHD)"
|
|
default:
|
|
// Default formatting for other resolutions
|
|
return refreshRate == 30 ? "\(height)p" : "\(height)p\(refreshRate)"
|
|
}
|
|
}
|
|
}
|
|
|
|
enum PlayerSidebarSetting: String, CaseIterable, Defaults.Serializable {
|
|
case always, whenFits, never
|
|
|
|
static var defaultValue: Self {
|
|
#if os(macOS)
|
|
.always
|
|
#else
|
|
.whenFits
|
|
#endif
|
|
}
|
|
}
|
|
|
|
enum VisibleSection: String, CaseIterable, Comparable, Defaults.Serializable {
|
|
case subscriptions, popular, trending, playlists
|
|
|
|
var title: String {
|
|
rawValue.capitalized.localized()
|
|
}
|
|
|
|
var tabSelection: TabSelection {
|
|
switch self {
|
|
case .subscriptions:
|
|
return TabSelection.subscriptions
|
|
case .popular:
|
|
return TabSelection.popular
|
|
case .trending:
|
|
return TabSelection.trending
|
|
case .playlists:
|
|
return TabSelection.playlists
|
|
}
|
|
}
|
|
|
|
private var sortOrder: Int {
|
|
switch self {
|
|
case .subscriptions:
|
|
return 0
|
|
case .popular:
|
|
return 1
|
|
case .trending:
|
|
return 2
|
|
case .playlists:
|
|
return 3
|
|
}
|
|
}
|
|
|
|
static func < (lhs: Self, rhs: Self) -> Bool {
|
|
lhs.sortOrder < rhs.sortOrder
|
|
}
|
|
}
|
|
|
|
enum StartupSection: String, CaseIterable, Defaults.Serializable {
|
|
case home, subscriptions, popular, trending, playlists, search
|
|
|
|
var label: String {
|
|
rawValue.capitalized.localized()
|
|
}
|
|
|
|
var tabSelection: TabSelection {
|
|
switch self {
|
|
case .home:
|
|
return .home
|
|
case .subscriptions:
|
|
return .subscriptions
|
|
case .popular:
|
|
return .popular
|
|
case .trending:
|
|
return .trending
|
|
case .playlists:
|
|
return .playlists
|
|
case .search:
|
|
return .search
|
|
}
|
|
}
|
|
}
|
|
|
|
enum WatchedVideoStyle: String, Defaults.Serializable {
|
|
case nothing, badge, decreasedOpacity, both
|
|
|
|
var isShowingBadge: Bool {
|
|
self == .badge || self == .both
|
|
}
|
|
|
|
var isDecreasingOpacity: Bool {
|
|
self == .decreasedOpacity || self == .both
|
|
}
|
|
}
|
|
|
|
enum WatchedVideoBadgeColor: String, Defaults.Serializable {
|
|
case colorSchemeBased, red, blue
|
|
}
|
|
|
|
enum WatchedVideoPlayNowBehavior: String, Defaults.Serializable {
|
|
case `continue`, restart
|
|
}
|
|
|
|
enum ButtonLabelStyle: String, CaseIterable, Defaults.Serializable {
|
|
case iconOnly, iconAndText
|
|
|
|
var text: Bool {
|
|
self == .iconAndText
|
|
}
|
|
|
|
var description: String {
|
|
switch self {
|
|
case .iconOnly:
|
|
return "Icon only".localized()
|
|
case .iconAndText:
|
|
return "Icon and text".localized()
|
|
}
|
|
}
|
|
}
|
|
|
|
enum ThumbnailsQuality: String, CaseIterable, Defaults.Serializable {
|
|
case highest, high, medium, low
|
|
|
|
var description: String {
|
|
switch self {
|
|
case .highest:
|
|
return "Best quality".localized()
|
|
case .high:
|
|
return "High quality".localized()
|
|
case .medium:
|
|
return "Medium quality".localized()
|
|
case .low:
|
|
return "Low quality".localized()
|
|
}
|
|
}
|
|
}
|
|
|
|
enum SystemControlsCommands: String, CaseIterable, Defaults.Serializable {
|
|
case seek, restartAndAdvanceToNext
|
|
}
|
|
|
|
enum ShowInspectorSetting: String, Defaults.Serializable {
|
|
case always, onlyLocal
|
|
}
|
|
|
|
enum DetailsToolbarPositionSetting: String, CaseIterable, Defaults.Serializable {
|
|
case left, center, right
|
|
|
|
var needsLeftSpacer: Bool {
|
|
self == .center || self == .right
|
|
}
|
|
|
|
var needsRightSpacer: Bool {
|
|
self == .center || self == .left
|
|
}
|
|
}
|
|
|
|
enum PlayerTapGestureAction: String, CaseIterable, Defaults.Serializable {
|
|
case togglePlayerVisibility
|
|
case togglePlayer
|
|
case openChannel
|
|
case nothing
|
|
|
|
var label: String {
|
|
switch self {
|
|
case .togglePlayerVisibility:
|
|
return "Toggle size"
|
|
case .togglePlayer:
|
|
return "Toggle player"
|
|
case .openChannel:
|
|
return "Open channel"
|
|
case .nothing:
|
|
return "Do nothing"
|
|
}
|
|
}
|
|
}
|
|
|
|
enum FullScreenRotationSetting: String, CaseIterable, Defaults.Serializable {
|
|
case landscapeLeft
|
|
case landscapeRight
|
|
|
|
#if os(iOS)
|
|
var interfaceOrientation: UIInterfaceOrientation {
|
|
switch self {
|
|
case .landscapeLeft:
|
|
return .landscapeLeft
|
|
case .landscapeRight:
|
|
return .landscapeRight
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
struct WidgetSettings: Defaults.Serializable {
|
|
static let defaultLimit = 10
|
|
static let maxLimit: [WidgetListingStyle: Int] = [
|
|
.horizontalCells: 50,
|
|
.list: 50
|
|
]
|
|
|
|
static var bridge = WidgetSettingsBridge()
|
|
|
|
var id: String
|
|
var listingStyle = WidgetListingStyle.horizontalCells
|
|
var limit = Self.defaultLimit
|
|
|
|
var viewID: String {
|
|
"\(id)-\(listingStyle.rawValue)-\(limit)"
|
|
}
|
|
|
|
static func maxLimit(_ style: WidgetListingStyle) -> Int {
|
|
maxLimit[style] ?? defaultLimit
|
|
}
|
|
}
|
|
|
|
struct WidgetSettingsBridge: Defaults.Bridge {
|
|
typealias Value = WidgetSettings
|
|
typealias Serializable = [String: String]
|
|
|
|
func serialize(_ value: Value?) -> Serializable? {
|
|
guard let value else { return nil }
|
|
|
|
return [
|
|
"id": value.id,
|
|
"listingStyle": value.listingStyle.rawValue,
|
|
"limit": String(value.limit)
|
|
]
|
|
}
|
|
|
|
func deserialize(_ object: Serializable?) -> Value? {
|
|
guard let object, let id = object["id"], !id.isEmpty else { return nil }
|
|
var listingStyle = WidgetListingStyle.horizontalCells
|
|
if let style = object["listingStyle"] {
|
|
listingStyle = WidgetListingStyle(rawValue: style) ?? .horizontalCells
|
|
}
|
|
let limit = Int(object["limit"] ?? "\(WidgetSettings.defaultLimit)") ?? WidgetSettings.defaultLimit
|
|
|
|
return Value(
|
|
id: id,
|
|
listingStyle: listingStyle,
|
|
limit: limit
|
|
)
|
|
}
|
|
}
|
|
|
|
enum WidgetListingStyle: String, CaseIterable, Defaults.Serializable {
|
|
case horizontalCells
|
|
case list
|
|
}
|
|
|
|
enum SponsorBlockColors: String {
|
|
case sponsor = "#00D400" // Green
|
|
case selfpromo = "#FFFF00" // Yellow
|
|
case interaction = "#CC00FF" // Purple
|
|
case intro = "#00FFFF" // Cyan
|
|
case outro = "#0202ED" // Dark Blue
|
|
case preview = "#008FD6" // Light Blue
|
|
case filler = "#7300FF" // Violet
|
|
case music_offtopic = "#FF9900" // Orange
|
|
|
|
// Define all cases, can be used to iterate over the colors
|
|
static let allCases: [SponsorBlockColors] = [Self.sponsor, Self.selfpromo, Self.interaction, Self.intro, Self.outro, Self.preview, Self.filler, Self.music_offtopic]
|
|
|
|
// Create a dictionary with the category names as keys and colors as values
|
|
static let dictionary: [String: String] = {
|
|
var dict = [String: String]()
|
|
for item in allCases {
|
|
dict[String(describing: item)] = item.rawValue
|
|
}
|
|
return dict
|
|
}()
|
|
}
|