ashikk
/
jellyflood
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updates swiftformat

This commit is contained in:
Joe Diragi 2022-05-01 15:23:52 -04:00
parent b43abf1548
commit 0ca924c8f2
2 changed files with 566 additions and 563 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

485
Shared/ServerDiscovery/UDPBroadCastConnection.swift
View File

@ -16,298 +16,297 @@ let INADDR_BROADCAST = in_addr(s_addr: 0xFFFF_FFFF)
/// An object representing the UDP broadcast connection. Uses a dispatch source to handle the incoming traffic on the UDP socket. /// An object representing the UDP broadcast connection. Uses a dispatch source to handle the incoming traffic on the UDP socket.
open class UDPBroadcastConnection { open class UDPBroadcastConnection {
// MARK: Properties // MARK: Properties
/// The address of the UDP socket. /// The address of the UDP socket.
var address: sockaddr_in var address: sockaddr_in
/// Type of a closure that handles incoming UDP packets. /// Type of a closure that handles incoming UDP packets.
public typealias ReceiveHandler = (_ ipAddress: String, _ port: Int, _ response: Data) -> Void public typealias ReceiveHandler = (_ ipAddress: String, _ port: Int, _ response: Data) -> Void
/// Closure that handles incoming UDP packets. /// Closure that handles incoming UDP packets.
var handler: ReceiveHandler? var handler: ReceiveHandler?
/// Type of a closure that handles errors that were encountered during receiving UDP packets. /// Type of a closure that handles errors that were encountered during receiving UDP packets.
public typealias ErrorHandler = (_ error: ConnectionError) -> Void public typealias ErrorHandler = (_ error: ConnectionError) -> Void
/// Closure that handles errors that were encountered during receiving UDP packets. /// Closure that handles errors that were encountered during receiving UDP packets.
var errorHandler: ErrorHandler? var errorHandler: ErrorHandler?
/// A dispatch source for reading data from the UDP socket. /// A dispatch source for reading data from the UDP socket.
var responseSource: DispatchSourceRead? var responseSource: DispatchSourceRead?
/// The dispatch queue to run responseSource & reconnection on /// The dispatch queue to run responseSource & reconnection on
var dispatchQueue = DispatchQueue.main var dispatchQueue = DispatchQueue.main
/// Bind to port to start listening without first sending a message /// Bind to port to start listening without first sending a message
var shouldBeBound: Bool = false var shouldBeBound: Bool = false
// MARK: Initializers // MARK: Initializers
/// Initializes the UDP connection with the correct port address. /// Initializes the UDP connection with the correct port address.
/// - Note: This doesn't open a socket! The socket is opened transparently as needed when sending broadcast messages. If you want to open a socket immediately, use the `bindIt` parameter. This will also try to reopen the socket if it gets closed. /// - Note: This doesn't open a socket! The socket is opened transparently as needed when sending broadcast messages. If you want to open a socket immediately, use the `bindIt` parameter. This will also try to reopen the socket if it gets closed.
/// ///
/// - Parameters: /// - Parameters:
/// - port: Number of the UDP port to use. /// - port: Number of the UDP port to use.
/// - bindIt: Opens a port immediately if true, on demand if false. Default is false. /// - bindIt: Opens a port immediately if true, on demand if false. Default is false.
/// - handler: Handler that gets called when data is received. /// - handler: Handler that gets called when data is received.
/// - errorHandler: Handler that gets called when an error occurs. /// - errorHandler: Handler that gets called when an error occurs.
/// - Throws: Throws a `ConnectionError` if an error occurs. /// - Throws: Throws a `ConnectionError` if an error occurs.
public init(port: UInt16, bindIt: Bool = false, handler: ReceiveHandler?, errorHandler: ErrorHandler?) throws { public init(port: UInt16, bindIt: Bool = false, handler: ReceiveHandler?, errorHandler: ErrorHandler?) throws {
self.address = sockaddr_in(sin_len: __uint8_t(MemoryLayout<sockaddr_in>.size), self.address = sockaddr_in(sin_len: __uint8_t(MemoryLayout<sockaddr_in>.size),
sin_family: sa_family_t(AF_INET), sin_family: sa_family_t(AF_INET),
sin_port: UDPBroadcastConnection.htonsPort(port: port), sin_port: UDPBroadcastConnection.htonsPort(port: port),
sin_addr: INADDR_BROADCAST, sin_addr: INADDR_BROADCAST,
sin_zero: (0, 0, 0, 0, 0, 0, 0, 0)) sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
self.handler = handler self.handler = handler
self.errorHandler = errorHandler self.errorHandler = errorHandler
self.shouldBeBound = bindIt self.shouldBeBound = bindIt
if bindIt { if bindIt {
try createSocket() try createSocket()
} }
} }
deinit { deinit {
if responseSource != nil { if responseSource != nil {
responseSource!.cancel() responseSource!.cancel()
} }
} }
// MARK: Interface // MARK: Interface
/// Create a UDP socket for broadcasting and set up cancel and event handlers /// Create a UDP socket for broadcasting and set up cancel and event handlers
/// ///
/// - Throws: Throws a `ConnectionError` if an error occurs. /// - Throws: Throws a `ConnectionError` if an error occurs.
fileprivate func createSocket() throws { fileprivate func createSocket() throws {
// Create new socket // Create new socket
let newSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) let newSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
guard newSocket > 0 else { throw ConnectionError.createSocketFailed } guard newSocket > 0 else { throw ConnectionError.createSocketFailed }
// Enable broadcast on socket // Enable broadcast on socket
var broadcastEnable = Int32(1) var broadcastEnable = Int32(1)
let ret = setsockopt(newSocket, SOL_SOCKET, SO_BROADCAST, &broadcastEnable, socklen_t(MemoryLayout<UInt32>.size)) let ret = setsockopt(newSocket, SOL_SOCKET, SO_BROADCAST, &broadcastEnable, socklen_t(MemoryLayout<UInt32>.size))
if ret == -1 { if ret == -1 {
debugPrint("Couldn't enable broadcast on socket") debugPrint("Couldn't enable broadcast on socket")
close(newSocket) close(newSocket)
throw ConnectionError.enableBroadcastFailed throw ConnectionError.enableBroadcastFailed
} }
// Bind socket if needed // Bind socket if needed
if shouldBeBound { if shouldBeBound {
var saddr = sockaddr(sa_len: 0, sa_family: 0, var saddr = sockaddr(sa_len: 0, sa_family: 0,
sa_data: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) sa_data: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
address.sin_addr = INADDR_ANY address.sin_addr = INADDR_ANY
memcpy(&saddr, &address, MemoryLayout<sockaddr_in>.size) memcpy(&saddr, &address, MemoryLayout<sockaddr_in>.size)
address.sin_addr = INADDR_BROADCAST address.sin_addr = INADDR_BROADCAST
let isBound = bind(newSocket, &saddr, socklen_t(MemoryLayout<sockaddr_in>.size)) let isBound = bind(newSocket, &saddr, socklen_t(MemoryLayout<sockaddr_in>.size))
if isBound == -1 { if isBound == -1 {
debugPrint("Couldn't bind socket") debugPrint("Couldn't bind socket")
close(newSocket) close(newSocket)
throw ConnectionError.bindSocketFailed throw ConnectionError.bindSocketFailed
} }
} }
// Disable global SIGPIPE handler so that the app doesn't crash // Disable global SIGPIPE handler so that the app doesn't crash
setNoSigPipe(socket: newSocket) setNoSigPipe(socket: newSocket)
// Set up a dispatch source // Set up a dispatch source
let newResponseSource = DispatchSource.makeReadSource(fileDescriptor: newSocket, queue: dispatchQueue) let newResponseSource = DispatchSource.makeReadSource(fileDescriptor: newSocket, queue: dispatchQueue)
// Set up cancel handler // Set up cancel handler
newResponseSource.setCancelHandler { newResponseSource.setCancelHandler {
// debugPrint("Closing UDP socket") // debugPrint("Closing UDP socket")
let UDPSocket = Int32(newResponseSource.handle) let UDPSocket = Int32(newResponseSource.handle)
shutdown(UDPSocket, SHUT_RDWR) shutdown(UDPSocket, SHUT_RDWR)
close(UDPSocket) close(UDPSocket)
} }
// Set up event handler (gets called when data arrives at the UDP socket) // Set up event handler (gets called when data arrives at the UDP socket)
newResponseSource.setEventHandler { [unowned self] in newResponseSource.setEventHandler { [unowned self] in
guard let source = self.responseSource else { return } guard let source = self.responseSource else { return }
var socketAddress = sockaddr_storage() var socketAddress = sockaddr_storage()
var socketAddressLength = socklen_t(MemoryLayout<sockaddr_storage>.size) var socketAddressLength = socklen_t(MemoryLayout<sockaddr_storage>.size)
let response = [UInt8](repeating: 0, count: 4096) let response = [UInt8](repeating: 0, count: 4096)
let UDPSocket = Int32(source.handle) let UDPSocket = Int32(source.handle)
let pointer = UnsafeMutablePointer<[UInt8]>.allocate(capacity: response.capacity) let pointer = UnsafeMutablePointer<[UInt8]>.allocate(capacity: response.capacity)
pointer.initialize(to: response) pointer.initialize(to: response)
let bytesRead = withUnsafeMutablePointer(to: &socketAddress) { let bytesRead = withUnsafeMutablePointer(to: &socketAddress) {
recvfrom(UDPSocket, pointer, response.count, 0, recvfrom(UDPSocket, pointer, response.count, 0,
UnsafeMutableRawPointer($0).bindMemory(to: sockaddr.self, capacity: 1), &socketAddressLength) UnsafeMutableRawPointer($0).bindMemory(to: sockaddr.self, capacity: 1), &socketAddressLength)
} }
do { do {
guard bytesRead > 0 else { guard bytesRead > 0 else {
self.closeConnection() self.closeConnection()
if bytesRead == 0 { if bytesRead == 0 {
debugPrint("recvfrom returned EOF") debugPrint("recvfrom returned EOF")
throw ConnectionError.receivedEndOfFile throw ConnectionError.receivedEndOfFile
} else { } else {
if let errorString = String(validatingUTF8: strerror(errno)) { if let errorString = String(validatingUTF8: strerror(errno)) {
debugPrint("recvfrom failed: \(errorString)") debugPrint("recvfrom failed: \(errorString)")
} }
throw ConnectionError.receiveFailed(code: errno) throw ConnectionError.receiveFailed(code: errno)
} }
} }
guard let endpoint = withUnsafePointer(to: &socketAddress, guard let endpoint = withUnsafePointer(to: &socketAddress, {
{ self
self .getEndpointFromSocketAddress(socketAddressPointer: UnsafeRawPointer($0)
.getEndpointFromSocketAddress(socketAddressPointer: UnsafeRawPointer($0) .bindMemory(to: sockaddr.self, capacity: 1)) })
.bindMemory(to: sockaddr.self, capacity: 1)) }) else {
else { // debugPrint("Failed to get the address and port from the socket address received from recvfrom")
// debugPrint("Failed to get the address and port from the socket address received from recvfrom") self.closeConnection()
self.closeConnection() return
return }
}
// debugPrint("UDP connection received \(bytesRead) bytes from \(endpoint.host):\(endpoint.port)") // debugPrint("UDP connection received \(bytesRead) bytes from \(endpoint.host):\(endpoint.port)")
let responseBytes = Data(response[0 ..< bytesRead]) let responseBytes = Data(response[0 ..< bytesRead])
// Handle response // Handle response
self.handler?(endpoint.host, endpoint.port, responseBytes) self.handler?(endpoint.host, endpoint.port, responseBytes)
} catch { } catch {
if let error = error as? ConnectionError { if let error = error as? ConnectionError {
self.errorHandler?(error) self.errorHandler?(error)
} else { } else {
self.errorHandler?(ConnectionError.underlying(error: error)) self.errorHandler?(ConnectionError.underlying(error: error))
} }
} }
} }
newResponseSource.resume() newResponseSource.resume()
responseSource = newResponseSource responseSource = newResponseSource
} }
/// Send broadcast message. /// Send broadcast message.
/// ///
/// - Parameter message: Message to send via broadcast. /// - Parameter message: Message to send via broadcast.
/// - Throws: Throws a `ConnectionError` if an error occurs. /// - Throws: Throws a `ConnectionError` if an error occurs.
open func sendBroadcast(_ message: String) throws { open func sendBroadcast(_ message: String) throws {
guard let data = message.data(using: .utf8) else { throw ConnectionError.messageEncodingFailed } guard let data = message.data(using: .utf8) else { throw ConnectionError.messageEncodingFailed }
try sendBroadcast(data) try sendBroadcast(data)
} }
/// Send broadcast data. /// Send broadcast data.
/// ///
/// - Parameter data: Data to send via broadcast. /// - Parameter data: Data to send via broadcast.
/// - Throws: Throws a `ConnectionError` if an error occurs. /// - Throws: Throws a `ConnectionError` if an error occurs.
open func sendBroadcast(_ data: Data) throws { open func sendBroadcast(_ data: Data) throws {
if responseSource == nil { if responseSource == nil {
try createSocket() try createSocket()
} }
guard let source = responseSource else { return } guard let source = responseSource else { return }
let UDPSocket = Int32(source.handle) let UDPSocket = Int32(source.handle)
let socketLength = socklen_t(address.sin_len) let socketLength = socklen_t(address.sin_len)
try data.withUnsafeBytes { broadcastMessage in try data.withUnsafeBytes { broadcastMessage in
let broadcastMessageLength = data.count let broadcastMessageLength = data.count
let sent = withUnsafeMutablePointer(to: &address) { pointer -> Int in let sent = withUnsafeMutablePointer(to: &address) { pointer -> Int in
let memory = UnsafeRawPointer(pointer).bindMemory(to: sockaddr.self, capacity: 1) let memory = UnsafeRawPointer(pointer).bindMemory(to: sockaddr.self, capacity: 1)
return sendto(UDPSocket, broadcastMessage.baseAddress, broadcastMessageLength, 0, memory, socketLength) return sendto(UDPSocket, broadcastMessage.baseAddress, broadcastMessageLength, 0, memory, socketLength)
} }
guard sent > 0 else { guard sent > 0 else {
closeConnection() closeConnection()
throw ConnectionError.sendingMessageFailed(code: errno) throw ConnectionError.sendingMessageFailed(code: errno)
} }
} }
} }
/// Close the connection. /// Close the connection.
/// ///
/// - Parameter reopen: Automatically reopens the connection if true. Defaults to true. /// - Parameter reopen: Automatically reopens the connection if true. Defaults to true.
open func closeConnection(reopen: Bool = true) { open func closeConnection(reopen: Bool = true) {
if let source = responseSource { if let source = responseSource {
source.cancel() source.cancel()
responseSource = nil responseSource = nil
} }
if shouldBeBound, reopen { if shouldBeBound, reopen {
dispatchQueue.async { dispatchQueue.async {
do { do {
try self.createSocket() try self.createSocket()
} catch { } catch {
self.errorHandler?(ConnectionError.reopeningSocketFailed(error: error)) self.errorHandler?(ConnectionError.reopeningSocketFailed(error: error))
} }
} }
} }
} }
// MARK: - Helper // MARK: - Helper
/// Convert a sockaddr structure into an IP address string and port. /// Convert a sockaddr structure into an IP address string and port.
/// ///
/// - Parameter socketAddressPointer: socketAddressPointer: Pointer to a socket address. /// - Parameter socketAddressPointer: socketAddressPointer: Pointer to a socket address.
/// - Returns: Returns a tuple of the host IP address and the port in the socket address given. /// - Returns: Returns a tuple of the host IP address and the port in the socket address given.
func getEndpointFromSocketAddress(socketAddressPointer: UnsafePointer<sockaddr>) -> (host: String, port: Int)? { func getEndpointFromSocketAddress(socketAddressPointer: UnsafePointer<sockaddr>) -> (host: String, port: Int)? {
let socketAddress = UnsafePointer<sockaddr>(socketAddressPointer).pointee let socketAddress = UnsafePointer<sockaddr>(socketAddressPointer).pointee
switch Int32(socketAddress.sa_family) { switch Int32(socketAddress.sa_family) {
case AF_INET: case AF_INET:
var socketAddressInet = UnsafeRawPointer(socketAddressPointer).load(as: sockaddr_in.self) var socketAddressInet = UnsafeRawPointer(socketAddressPointer).load(as: sockaddr_in.self)
let length = Int(INET_ADDRSTRLEN) + 2 let length = Int(INET_ADDRSTRLEN) + 2
var buffer = [CChar](repeating: 0, count: length) var buffer = [CChar](repeating: 0, count: length)
let hostCString = inet_ntop(AF_INET, &socketAddressInet.sin_addr, &buffer, socklen_t(length)) let hostCString = inet_ntop(AF_INET, &socketAddressInet.sin_addr, &buffer, socklen_t(length))
let port = Int(UInt16(socketAddressInet.sin_port).byteSwapped) let port = Int(UInt16(socketAddressInet.sin_port).byteSwapped)
return (String(cString: hostCString!), port) return (String(cString: hostCString!), port)
case AF_INET6: case AF_INET6:
var socketAddressInet6 = UnsafeRawPointer(socketAddressPointer).load(as: sockaddr_in6.self) var socketAddressInet6 = UnsafeRawPointer(socketAddressPointer).load(as: sockaddr_in6.self)
let length = Int(INET6_ADDRSTRLEN) + 2 let length = Int(INET6_ADDRSTRLEN) + 2
var buffer = [CChar](repeating: 0, count: length) var buffer = [CChar](repeating: 0, count: length)
let hostCString = inet_ntop(AF_INET6, &socketAddressInet6.sin6_addr, &buffer, socklen_t(length)) let hostCString = inet_ntop(AF_INET6, &socketAddressInet6.sin6_addr, &buffer, socklen_t(length))
let port = Int(UInt16(socketAddressInet6.sin6_port).byteSwapped) let port = Int(UInt16(socketAddressInet6.sin6_port).byteSwapped)
return (String(cString: hostCString!), port) return (String(cString: hostCString!), port)
default: default:
return nil return nil
} }
} }
// MARK: - Private // MARK: - Private
/// Prevents crashes when blocking calls are pending and the app is paused (via Home button). /// Prevents crashes when blocking calls are pending and the app is paused (via Home button).
/// ///
/// - Parameter socket: The socket for which the signal should be disabled. /// - Parameter socket: The socket for which the signal should be disabled.
fileprivate func setNoSigPipe(socket: CInt) { fileprivate func setNoSigPipe(socket: CInt) {
var no_sig_pipe: Int32 = 1 var no_sig_pipe: Int32 = 1
setsockopt(socket, SOL_SOCKET, SO_NOSIGPIPE, &no_sig_pipe, socklen_t(MemoryLayout<Int32>.size)) setsockopt(socket, SOL_SOCKET, SO_NOSIGPIPE, &no_sig_pipe, socklen_t(MemoryLayout<Int32>.size))
} }
fileprivate class func htonsPort(port: in_port_t) -> in_port_t { fileprivate class func htonsPort(port: in_port_t) -> in_port_t {
let isLittleEndian = Int(OSHostByteOrder()) == OSLittleEndian let isLittleEndian = Int(OSHostByteOrder()) == OSLittleEndian
return isLittleEndian ? _OSSwapInt16(port) : port return isLittleEndian ? _OSSwapInt16(port) : port
} }
fileprivate class func ntohs(value: CUnsignedShort) -> CUnsignedShort { fileprivate class func ntohs(value: CUnsignedShort) -> CUnsignedShort {
(value << 8) + (value >> 8) (value << 8) + (value >> 8)
} }
} }
// Created by Gunter Hager on 25.03.19. // Created by Gunter Hager on 25.03.19.
// Copyright © 2019 Gunter Hager. All rights reserved. // Copyright © 2019 Gunter Hager. All rights reserved.
// //
public extension UDPBroadcastConnection { public extension UDPBroadcastConnection {
enum ConnectionError: Error { enum ConnectionError: Error {
// Creating socket // Creating socket
case createSocketFailed case createSocketFailed
case enableBroadcastFailed case enableBroadcastFailed
case bindSocketFailed case bindSocketFailed
// Sending message // Sending message
case messageEncodingFailed case messageEncodingFailed
case sendingMessageFailed(code: Int32) case sendingMessageFailed(code: Int32)
// Receiving data // Receiving data
case receivedEndOfFile case receivedEndOfFile
case receiveFailed(code: Int32) case receiveFailed(code: Int32)
// Closing socket // Closing socket
case reopeningSocketFailed(error: Error) case reopeningSocketFailed(error: Error)
// Underlying // Underlying
case underlying(error: Error) case underlying(error: Error)
} }
} }

644
Swiftfin tvOS/Views/VideoPlayer/Overlays/SmallMenuOverlay.swift
View File

@ -11,352 +11,356 @@ import SwiftUI
// TODO: Needs replacement/reworking // TODO: Needs replacement/reworking
struct SmallMediaStreamSelectionView: View { struct SmallMediaStreamSelectionView: View {
enum Layer: Hashable {
case subtitles
case audio
case playbackSpeed
case chapters
}
enum MediaSection: Hashable { enum Layer: Hashable {
case titles case subtitles
case items case audio
} case playbackSpeed
case chapters
}
@ObservedObject enum MediaSection: Hashable {
var viewModel: VideoPlayerViewModel case titles
private let chapterImages: [URL] case items
}
@State @ObservedObject
private var updateFocusedLayer: Layer = .subtitles var viewModel: VideoPlayerViewModel
@State private let chapterImages: [URL]
private var lastFocusedLayer: Layer = .subtitles
@FocusState @State
private var subtitlesFocused: Bool private var updateFocusedLayer: Layer = .subtitles
@FocusState @State
private var audioFocused: Bool private var lastFocusedLayer: Layer = .subtitles
@FocusState
private var playbackSpeedFocused: Bool
@FocusState
private var chaptersFocused: Bool
@FocusState
private var focusedSection: MediaSection?
@FocusState
private var focusedLayer: Layer? {
willSet {
updateFocusedLayer = newValue!
if focusedSection == .titles { @FocusState
lastFocusedLayer = newValue! private var subtitlesFocused: Bool
} @FocusState
} private var audioFocused: Bool
} @FocusState
private var playbackSpeedFocused: Bool
@FocusState
private var chaptersFocused: Bool
@FocusState
private var focusedSection: MediaSection?
@FocusState
private var focusedLayer: Layer? {
willSet {
updateFocusedLayer = newValue!
init(viewModel: VideoPlayerViewModel) { if focusedSection == .titles {
self.viewModel = viewModel lastFocusedLayer = newValue!
self.chapterImages = viewModel.item.getChapterImage(maxWidth: 500) }
} }
}
var body: some View { init(viewModel: VideoPlayerViewModel) {
ZStack(alignment: .bottom) { self.viewModel = viewModel
LinearGradient(gradient: Gradient(colors: [.clear, .black.opacity(0.8), .black]), self.chapterImages = viewModel.item.getChapterImage(maxWidth: 500)
startPoint: .top, }
endPoint: .bottom)
.ignoresSafeArea()
.frame(height: 300)
VStack { var body: some View {
Spacer() ZStack(alignment: .bottom) {
LinearGradient(gradient: Gradient(colors: [.clear, .black.opacity(0.8), .black]),
startPoint: .top,
endPoint: .bottom)
.ignoresSafeArea()
.frame(height: 300)
HStack { VStack {
// MARK: Subtitle Header
Button { Spacer()
updateFocusedLayer = .subtitles
focusedLayer = .subtitles
} label: {
if updateFocusedLayer == .subtitles {
HStack(spacing: 15) {
Image(systemName: "captions.bubble")
L10n.subtitles.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "captions.bubble")
L10n.subtitles.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .subtitles)
.focused($subtitlesFocused)
.onChange(of: subtitlesFocused) { isFocused in
if isFocused {
focusedLayer = .subtitles
}
}
// MARK: Audio Header HStack {
Button { // MARK: Subtitle Header
updateFocusedLayer = .audio
focusedLayer = .audio
} label: {
if updateFocusedLayer == .audio {
HStack(spacing: 15) {
Image(systemName: "speaker.wave.3")
L10n.audio.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "speaker.wave.3")
L10n.audio.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .audio)
.focused($audioFocused)
.onChange(of: audioFocused) { isFocused in
if isFocused {
focusedLayer = .audio
}
}
// MARK: Playback Speed Header Button {
updateFocusedLayer = .subtitles
focusedLayer = .subtitles
} label: {
if updateFocusedLayer == .subtitles {
HStack(spacing: 15) {
Image(systemName: "captions.bubble")
L10n.subtitles.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "captions.bubble")
L10n.subtitles.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .subtitles)
.focused($subtitlesFocused)
.onChange(of: subtitlesFocused) { isFocused in
if isFocused {
focusedLayer = .subtitles
}
}
Button { // MARK: Audio Header
updateFocusedLayer = .playbackSpeed
focusedLayer = .playbackSpeed
} label: {
if updateFocusedLayer == .playbackSpeed {
HStack(spacing: 15) {
Image(systemName: "speedometer")
L10n.playbackSpeed.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "speedometer")
L10n.playbackSpeed.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .playbackSpeed)
.focused($playbackSpeedFocused)
.onChange(of: playbackSpeedFocused) { isFocused in
if isFocused {
focusedLayer = .playbackSpeed
}
}
// MARK: Chapters Header Button {
updateFocusedLayer = .audio
focusedLayer = .audio
} label: {
if updateFocusedLayer == .audio {
HStack(spacing: 15) {
Image(systemName: "speaker.wave.3")
L10n.audio.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "speaker.wave.3")
L10n.audio.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .audio)
.focused($audioFocused)
.onChange(of: audioFocused) { isFocused in
if isFocused {
focusedLayer = .audio
}
}
if !viewModel.chapters.isEmpty { // MARK: Playback Speed Header
Button {
updateFocusedLayer = .chapters
focusedLayer = .chapters
} label: {
if updateFocusedLayer == .chapters {
HStack(spacing: 15) {
Image(systemName: "list.dash")
L10n.chapters.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "list.dash")
L10n.chapters.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .chapters)
.focused($chaptersFocused)
.onChange(of: chaptersFocused) { isFocused in
if isFocused {
focusedLayer = .chapters
}
}
}
Spacer() Button {
} updateFocusedLayer = .playbackSpeed
.padding() focusedLayer = .playbackSpeed
.focusSection() } label: {
.focused($focusedSection, equals: .titles) if updateFocusedLayer == .playbackSpeed {
.onChange(of: focusedSection) { _ in HStack(spacing: 15) {
if focusedSection == .titles { Image(systemName: "speedometer")
if lastFocusedLayer == .subtitles { L10n.playbackSpeed.text
subtitlesFocused = true }
} else if lastFocusedLayer == .audio { .padding()
audioFocused = true .background(Color.white)
} else if lastFocusedLayer == .playbackSpeed { .foregroundColor(.black)
playbackSpeedFocused = true } else {
} HStack(spacing: 15) {
} Image(systemName: "speedometer")
} L10n.playbackSpeed.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .playbackSpeed)
.focused($playbackSpeedFocused)
.onChange(of: playbackSpeedFocused) { isFocused in
if isFocused {
focusedLayer = .playbackSpeed
}
}
if updateFocusedLayer == .subtitles, lastFocusedLayer == .subtitles { // MARK: Chapters Header
// MARK: Subtitles
subtitleMenuView if !viewModel.chapters.isEmpty {
} else if updateFocusedLayer == .audio, lastFocusedLayer == .audio { Button {
// MARK: Audio updateFocusedLayer = .chapters
focusedLayer = .chapters
} label: {
if updateFocusedLayer == .chapters {
HStack(spacing: 15) {
Image(systemName: "list.dash")
L10n.chapters.text
}
.padding()
.background(Color.white)
.foregroundColor(.black)
} else {
HStack(spacing: 15) {
Image(systemName: "list.dash")
L10n.chapters.text
}
.padding()
}
}
.buttonStyle(PlainButtonStyle())
.background(Color.clear)
.focused($focusedLayer, equals: .chapters)
.focused($chaptersFocused)
.onChange(of: chaptersFocused) { isFocused in
if isFocused {
focusedLayer = .chapters
}
}
}
audioMenuView Spacer()
} else if updateFocusedLayer == .playbackSpeed, lastFocusedLayer == .playbackSpeed { }
// MARK: Playback Speed .padding()
.focusSection()
.focused($focusedSection, equals: .titles)
.onChange(of: focusedSection) { _ in
if focusedSection == .titles {
if lastFocusedLayer == .subtitles {
subtitlesFocused = true
} else if lastFocusedLayer == .audio {
audioFocused = true
} else if lastFocusedLayer == .playbackSpeed {
playbackSpeedFocused = true
}
}
}
playbackSpeedMenuView if updateFocusedLayer == .subtitles && lastFocusedLayer == .subtitles {
} else if updateFocusedLayer == .chapters, lastFocusedLayer == .chapters { // MARK: Subtitles
// MARK: Chapters
chaptersMenuView subtitleMenuView
} } else if updateFocusedLayer == .audio && lastFocusedLayer == .audio {
} // MARK: Audio
}
}
@ViewBuilder audioMenuView
private var subtitleMenuView: some View { } else if updateFocusedLayer == .playbackSpeed && lastFocusedLayer == .playbackSpeed {
ScrollView(.horizontal) { // MARK: Playback Speed
HStack {
if viewModel.subtitleStreams.isEmpty {
Button {} label: {
L10n.none.text
}
} else {
ForEach(viewModel.subtitleStreams, id: \.self) { subtitleStream in
Button {
viewModel.selectedSubtitleStreamIndex = subtitleStream.index ?? -1
} label: {
if subtitleStream.index == viewModel.selectedSubtitleStreamIndex {
Label(subtitleStream.displayTitle ?? L10n.noTitle, systemImage: "checkmark")
} else {
Text(subtitleStream.displayTitle ?? L10n.noTitle)
}
}
}
}
}
.padding(.vertical)
.focusSection()
.focused($focusedSection, equals: .items)
}
}
@ViewBuilder playbackSpeedMenuView
private var audioMenuView: some View { } else if updateFocusedLayer == .chapters && lastFocusedLayer == .chapters {
ScrollView(.horizontal) { // MARK: Chapters
HStack {
if viewModel.audioStreams.isEmpty {
Button {} label: {
Text("None")
}
} else {
ForEach(viewModel.audioStreams, id: \.self) { audioStream in
Button {
viewModel.selectedAudioStreamIndex = audioStream.index ?? -1
} label: {
if audioStream.index == viewModel.selectedAudioStreamIndex {
Label(audioStream.displayTitle ?? L10n.noTitle, systemImage: "checkmark")
} else {
Text(audioStream.displayTitle ?? L10n.noTitle)
}
}
}
}
}
.padding(.vertical)
.focusSection()
.focused($focusedSection, equals: .items)
}
}
@ViewBuilder chaptersMenuView
private var playbackSpeedMenuView: some View { }
ScrollView(.horizontal) { }
HStack { }
ForEach(PlaybackSpeed.allCases, id: \.self) { playbackSpeed in }
Button {
viewModel.playbackSpeed = playbackSpeed
} label: {
if playbackSpeed == viewModel.playbackSpeed {
Label(playbackSpeed.displayTitle, systemImage: "checkmark")
} else {
Text(playbackSpeed.displayTitle)
}
}
}
}
.padding(.vertical)
.focusSection()
.focused($focusedSection, equals: .items)
}
}
@ViewBuilder @ViewBuilder
private var chaptersMenuView: some View { private var subtitleMenuView: some View {
ScrollView(.horizontal, showsIndicators: false) { ScrollView(.horizontal) {
ScrollViewReader { reader in HStack {
HStack { if viewModel.subtitleStreams.isEmpty {
ForEach(0 ..< viewModel.chapters.count, id: \.self) { chapterIndex in Button {} label: {
VStack(alignment: .leading) { L10n.none.text
Button { }
viewModel.playerOverlayDelegate?.didSelectChapter(viewModel.chapters[chapterIndex]) } else {
} label: { ForEach(viewModel.subtitleStreams, id: \.self) { subtitleStream in
ImageView(chapterImages[chapterIndex]) Button {
.cornerRadius(10) viewModel.selectedSubtitleStreamIndex = subtitleStream.index ?? -1
.frame(width: 350, height: 210) } label: {
} if subtitleStream.index == viewModel.selectedSubtitleStreamIndex {
.buttonStyle(CardButtonStyle()) Label(subtitleStream.displayTitle ?? L10n.noTitle, systemImage: "checkmark")
} else {
Text(subtitleStream.displayTitle ?? L10n.noTitle)
}
}
}
}
}
.padding(.vertical)
.focusSection()
.focused($focusedSection, equals: .items)
}
}
VStack(alignment: .leading, spacing: 5) { @ViewBuilder
Text(viewModel.chapters[chapterIndex].name ?? L10n.noTitle) private var audioMenuView: some View {
.font(.subheadline) ScrollView(.horizontal) {
.fontWeight(.semibold) HStack {
.foregroundColor(.white) if viewModel.audioStreams.isEmpty {
Button {} label: {
Text("None")
}
} else {
ForEach(viewModel.audioStreams, id: \.self) { audioStream in
Button {
viewModel.selectedAudioStreamIndex = audioStream.index ?? -1
} label: {
if audioStream.index == viewModel.selectedAudioStreamIndex {
Label(audioStream.displayTitle ?? L10n.noTitle, systemImage: "checkmark")
} else {
Text(audioStream.displayTitle ?? L10n.noTitle)
}
}
}
}
}
.padding(.vertical)
.focusSection()
.focused($focusedSection, equals: .items)
}
}
Text(viewModel.chapters[chapterIndex].timestampLabel) @ViewBuilder
.font(.subheadline) private var playbackSpeedMenuView: some View {
.fontWeight(.semibold) ScrollView(.horizontal) {
.foregroundColor(Color(UIColor.systemBlue)) HStack {
.padding(.vertical, 2) ForEach(PlaybackSpeed.allCases, id: \.self) { playbackSpeed in
.padding(.horizontal, 4) Button {
.background { viewModel.playbackSpeed = playbackSpeed
Color(UIColor.darkGray).opacity(0.2).cornerRadius(4) } label: {
} if playbackSpeed == viewModel.playbackSpeed {
} Label(playbackSpeed.displayTitle, systemImage: "checkmark")
} } else {
.id(viewModel.chapters[chapterIndex]) Text(playbackSpeed.displayTitle)
} }
} }
.padding(.top) }
.onAppear { }
reader.scrollTo(viewModel.currentChapter) .padding(.vertical)
} .focusSection()
} .focused($focusedSection, equals: .items)
} }
} }
@ViewBuilder
private var chaptersMenuView: some View {
ScrollView(.horizontal, showsIndicators: false) {
ScrollViewReader { reader in
HStack {
ForEach(0 ..< viewModel.chapters.count, id: \.self) { chapterIndex in
VStack(alignment: .leading) {
Button {
viewModel.playerOverlayDelegate?.didSelectChapter(viewModel.chapters[chapterIndex])
} label: {
ImageView(chapterImages[chapterIndex])
.cornerRadius(10)
.frame(width: 350, height: 210)
}
.buttonStyle(CardButtonStyle())
VStack(alignment: .leading, spacing: 5) {
Text(viewModel.chapters[chapterIndex].name ?? L10n.noTitle)
.font(.subheadline)
.fontWeight(.semibold)
.foregroundColor(.white)
Text(viewModel.chapters[chapterIndex].timestampLabel)
.font(.subheadline)
.fontWeight(.semibold)
.foregroundColor(Color(UIColor.systemBlue))
.padding(.vertical, 2)
.padding(.horizontal, 4)
.background {
Color(UIColor.darkGray).opacity(0.2).cornerRadius(4)
}
}
}
.id(viewModel.chapters[chapterIndex])
}
}
.padding(.top)
.onAppear {
reader.scrollTo(viewModel.currentChapter)
}
}
}
}
} }