Multiplatform playing first steps

Shared/Defaults.swift

@@ -1,7 +1,9 @@
 import Defaults
 
 extension Defaults.Keys {
-    static let layout = Key<ListingLayout>("listingLayout", default: .cells)
+    #if os(tvOS)
+        static let layout = Key<ListingLayout>("listingLayout", default: .cells)
+    #endif
     static let searchQuery = Key<String>("searchQuery", default: "")
 
     static let searchSortOrder = Key<SearchSortOrder>("searchSortOrder", default: .relevance)

Shared/Player.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+struct Player: UIViewControllerRepresentable {
+    var video: Video?
+
+    func makeUIViewController(context _: Context) -> PlayerViewController {
+        let controller = PlayerViewController()
+        controller.video = video
+
+        return controller
+    }
+
+    func updateUIViewController(_: PlayerViewController, context _: Context) {}
+}

Shared/PlayerViewController.swift

@@ -0,0 +1,81 @@
+import AVKit
+import Logging
+import SwiftUI
+
+final class PlayerViewController: UIViewController {
+    var video: Video!
+
+    var playerLoaded = false
+    var playingFullScreen = false
+
+    var player = AVPlayer()
+    var playerState: PlayerState! = PlayerState()
+    var playerViewController = AVPlayerViewController()
+
+    override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+
+        if !playerLoaded {
+            loadPlayer()
+        }
+
+        try? AVAudioSession.sharedInstance().setCategory(.playback, mode: .default)
+        try? AVAudioSession.sharedInstance().setActive(true)
+    }
+
+    override func viewDidDisappear(_ animated: Bool) {
+        #if os(iOS)
+            if !playingFullScreen {
+                playerViewController.player?.replaceCurrentItem(with: nil)
+                playerViewController.player = nil
+            }
+        #endif
+
+        super.viewDidDisappear(animated)
+    }
+
+    func loadPlayer() {
+        playerState.player = player
+        playerViewController.player = playerState.player
+        playerState.loadVideo(video)
+
+        #if os(tvOS)
+            present(playerViewController, animated: false)
+        #else
+            playerViewController.exitsFullScreenWhenPlaybackEnds = true
+            playerViewController.view.frame = view.bounds
+
+            addChild(playerViewController)
+            view.addSubview(playerViewController.view)
+
+            playerViewController.didMove(toParent: self)
+        #endif
+
+        playerViewController.delegate = self
+        playerLoaded = true
+    }
+}
+
+extension PlayerViewController: AVPlayerViewControllerDelegate {
+    func playerViewControllerShouldDismiss(_: AVPlayerViewController) -> Bool {
+        true
+    }
+
+    func playerViewControllerWillBeginDismissalTransition(_: AVPlayerViewController) {
+        dismiss(animated: false)
+    }
+
+    func playerViewController(
+        _: AVPlayerViewController,
+        willBeginFullScreenPresentationWithAnimationCoordinator _: UIViewControllerTransitionCoordinator
+    ) {
+        playingFullScreen = true
+    }
+
+    func playerViewController(
+        _: AVPlayerViewController,
+        willEndFullScreenPresentationWithAnimationCoordinator _: UIViewControllerTransitionCoordinator
+    ) {
+        playingFullScreen = false
+    }
+}

Shared/VideoPlayerView.swift

@@ -0,0 +1,65 @@
+import AVKit
+import Siesta
+import SwiftUI
+
+struct VideoPlayerView: View {
+    @EnvironmentObject<NavigationState> private var navigationState
+
+    @ObservedObject private var store = Store<Video>()
+
+    var resource: Resource {
+        InvidiousAPI.shared.video(video.id)
+    }
+
+    var video: Video
+
+    var player: AVPlayer!
+
+    init(_ video: Video) {
+        self.video = video
+        resource.addObserver(store)
+
+        player = AVPlayer()
+    }
+
+    var body: some View {
+        VStack {
+            #if os(tvOS)
+                if store.item == nil {
+                    VideoLoading(video: video)
+                }
+            #endif
+
+            VStack {
+                Player(video: video)
+                    .frame(alignment: .leading)
+
+                #if !os(tvOS)
+                    ScrollView(.vertical) {
+                        VStack(alignment: .leading) {
+                            Text(video.title)
+                            Text(video.author)
+                        }
+                        .frame(minWidth: 0, maxWidth: .infinity, alignment: .leading)
+                    }
+                #endif
+            }
+        }
+        .onAppear {
+            resource.loadIfNeeded()
+        }
+        .onDisappear {
+            resource.removeObservers(ownedBy: store)
+            resource.invalidate()
+
+            navigationState.showingVideoDetails = navigationState.returnToDetails
+        }
+        #if os(tvOS)
+            .background(.thinMaterial)
+        #elseif os(macOS)
+            .navigationTitle(video.title)
+        #elseif os(iOS)
+            .navigationBarTitle(video.title, displayMode: .inline)
+        #endif
+    }
+}