Resolution switching support

Model/AppState.swift

@@ -1,6 +1,7 @@
+import AVFoundation
 import Foundation
 
-class AppState: ObservableObject {
+final class AppState: ObservableObject {
     @Published var showingChannel = false
     @Published var channelID: String = ""
     @Published var channel: String = ""

Model/ChannelVideosProvider.swift

@@ -1,13 +1,15 @@
 import Foundation
 import SwiftyJSON
 
-class ChannelVideosProvider: DataProvider {
+final class ChannelVideosProvider: DataProvider {
     @Published var videos = [Video]()
 
     var channelID: String? = ""
 
     func load() {
-        guard channelID != nil else { return }
+        guard channelID != nil else {
+            return
+        }
 
         let searchPath = "channels/\(channelID!)"
         DataProvider.request(searchPath).responseJSON { response in

Model/DataProvider.swift

@@ -1,9 +1,20 @@
 import Alamofire
 import Foundation
 
+// swiftlint:disable:next final_class
 class DataProvider: ObservableObject {
     static let instance = "https://invidious.home.arekf.net"
 
+    static func proxyURLForAsset(_ url: String) -> URL? {
+        guard let instanceURLComponents = URLComponents(string: DataProvider.instance),
+              var urlComponents = URLComponents(string: url) else { return nil }
+
+        urlComponents.scheme = instanceURLComponents.scheme
+        urlComponents.host = instanceURLComponents.host
+
+        return urlComponents.url
+    }
+
     static func request(_ path: String, headers: HTTPHeaders? = nil) -> DataRequest {
         AF.request(apiURLString(path), headers: headers)
     }

Model/MuxedStream.swift

@@ -0,0 +1,12 @@
+import AVFoundation
+import Foundation
+
+final class MuxedStream: Stream {
+    var muxedAsset: AVURLAsset
+
+    init(muxedAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
+        self.muxedAsset = muxedAsset
+
+        super.init(audioAsset: muxedAsset, videoAsset: muxedAsset, resolution: resolution, type: type, encoding: encoding)
+    }
+}

Model/PlayerState.swift

@@ -0,0 +1,7 @@
+import AVFoundation
+import Foundation
+
+final class PlayerState: ObservableObject {
+    @Published var currentStream: Stream!
+    @Published var seekTo: CMTime?
+}

Model/SearchedVideosProvider.swift

@@ -1,13 +1,28 @@
 import Foundation
 import SwiftyJSON
 
-class SearchedVideosProvider: DataProvider {
+final class SearchedVideosProvider: DataProvider {
     @Published var videos = [Video]()
 
-    var query: String = ""
+    var currentQuery: String = ""
 
-    func load() {
-        let searchPath = "search?q=\(query.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
+    func load(_ query: String) {
+        var newQuery = query
+
+        if let url = URLComponents(string: query),
+           let queryItem = url.queryItems?.first(where: { item in item.name == "v" }),
+           let id = queryItem.value
+        {
+            newQuery = id
+        }
+
+        if newQuery == currentQuery {
+            return
+        }
+
+        currentQuery = newQuery
+
+        let searchPath = "search?q=\(currentQuery.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!)"
         DataProvider.request(searchPath).responseJSON { response in
             switch response.result {
             case let .success(value):

Model/Stream.swift

@@ -0,0 +1,29 @@
+import AVFoundation
+import Foundation
+
+// swiftlint:disable:next final_class
+class Stream: Equatable {
+    var audioAsset: AVURLAsset
+    var videoAsset: AVURLAsset
+
+    var resolution: StreamResolution
+    var type: StreamType
+
+    var encoding: String
+
+    init(audioAsset: AVURLAsset, videoAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
+        self.audioAsset = audioAsset
+        self.videoAsset = videoAsset
+        self.resolution = resolution
+        self.type = type
+        self.encoding = encoding
+    }
+
+    var description: String {
+        "\(resolution.height)p"
+    }
+
+    static func == (lhs: Stream, rhs: Stream) -> Bool {
+        lhs.resolution == rhs.resolution && lhs.type == rhs.type
+    }
+}

Model/StreamResolution.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+enum StreamResolution: String, CaseIterable, Comparable {
+    case hd_1080p, hd_720p, sd_480p, sd_360p, sd_240p, sd_144p
+
+    var height: Int {
+        Int(rawValue.components(separatedBy: CharacterSet.decimalDigits.inverted).joined())!
+    }
+
+    static func from(resolution: String) -> StreamResolution? {
+        allCases.first { "\($0)".contains(resolution) }
+    }
+
+    static func < (lhs: StreamResolution, rhs: StreamResolution) -> Bool {
+        lhs.height < rhs.height
+    }
+}

Model/StreamType.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+enum StreamType: String, Comparable {
+    case stream, adaptive
+
+    private var sortOrder: Int {
+        switch self {
+        case .stream:
+            return 0
+        case .adaptive:
+            return 1
+        }
+    }
+
+    static func < (lhs: StreamType, rhs: StreamType) -> Bool {
+        lhs.sortOrder < rhs.sortOrder
+    }
+}

Model/SubscriptionVideosProvider.swift

@@ -2,7 +2,7 @@ import Alamofire
 import Foundation
 import SwiftyJSON
 
-class SubscriptionVideosProvider: DataProvider {
+final class SubscriptionVideosProvider: DataProvider {
     @Published var videos = [Video]()
 
     var sid: String = "RpoS7YPPK2-QS81jJF9z4KSQAjmzsOnMpn84c73-GQ8="

Model/Video.swift

@@ -1,4 +1,5 @@
 import Alamofire
+import AVKit
 import Foundation
 import SwiftyJSON
 
@@ -10,11 +11,9 @@ final class Video: Identifiable, ObservableObject {
     var length: TimeInterval
     var published: String
     var views: Int
-
     var channelID: String
 
-    @Published var url: URL?
-    @Published var error: Bool = false
+    var streams = [Stream]()
 
     init(
         id: String,
@@ -23,8 +22,8 @@ final class Video: Identifiable, ObservableObject {
         author: String,
         length: TimeInterval,
         published: String,
-        channelID: String,
-        views: Int = 0
+        views: Int,
+        channelID: String
     ) {
         self.id = id
         self.title = title
@@ -32,41 +31,22 @@ final class Video: Identifiable, ObservableObject {
         self.author = author
         self.length = length
         self.published = published
-        self.channelID = channelID
         self.views = views
+        self.channelID = channelID
     }
 
     init(_ json: JSON) {
-        func extractThumbnailURL(from details: JSON) -> URL? {
-            if details["videoThumbnails"].arrayValue.isEmpty {
-                return nil
-            }
-
-            let thumbnail = details["videoThumbnails"].arrayValue.first(where: { $0["quality"].stringValue == "medium" })!
-            return thumbnail["url"].url!
-        }
-
-        func extractFormatStreamURL(from streams: [JSON]) -> URL? {
-            if streams.isEmpty {
-                error = true
-                return nil
-            }
-
-            let stream = streams.last!
-
-            return stream["url"].url
-        }
-
         id = json["videoId"].stringValue
         title = json["title"].stringValue
-        thumbnailURL = extractThumbnailURL(from: json)
         author = json["author"].stringValue
         length = json["lengthSeconds"].doubleValue
         published = json["publishedText"].stringValue
         views = json["viewCount"].intValue
         channelID = json["authorId"].stringValue
+        thumbnailURL = extractThumbnailURL(from: json)
 
-        url = extractFormatStreamURL(from: json["formatStreams"].arrayValue)
+        streams = extractFormatStreams(from: json["formatStreams"].arrayValue)
+        streams.append(contentsOf: extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue))
     }
 
     var playTime: String? {
@@ -97,4 +77,60 @@ final class Video: Identifiable, ObservableObject {
 
         return "\(formatter.string(from: number)!)\(unit)"
     }
+
+    var selectableStreams: [Stream] {
+        let streams = streams.sorted { $0.resolution > $1.resolution }
+        var selectable = [Stream]()
+
+        StreamResolution.allCases.forEach { resolution in
+            if let stream = streams.filter({ $0.resolution == resolution }).min(by: { $0.type < $1.type }) {
+                selectable.append(stream)
+            }
+        }
+
+        return selectable
+    }
+
+    var defaultStream: Stream? {
+        selectableStreams.first { $0.type == .stream }
+    }
+
+    private func extractThumbnailURL(from details: JSON) -> URL? {
+        if details["videoThumbnails"].arrayValue.isEmpty {
+            return nil
+        }
+
+        let thumbnail = details["videoThumbnails"].arrayValue.first { $0["quality"].stringValue == "medium" }!
+        return thumbnail["url"].url!
+    }
+
+    private func extractFormatStreams(from streams: [JSON]) -> [Stream] {
+        streams.map {
+            MuxedStream(
+                muxedAsset: AVURLAsset(url: DataProvider.proxyURLForAsset($0["url"].stringValue)!),
+                resolution: StreamResolution.from(resolution: $0["resolution"].stringValue)!,
+                type: .stream,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
+
+    private func extractAdaptiveFormats(from streams: [JSON]) -> [Stream] {
+        let audioAssetURL = streams.first { $0["type"].stringValue.starts(with: "audio/mp4") }
+        guard audioAssetURL != nil else {
+            return []
+        }
+
+        let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/mp4") && $0["encoding"].stringValue == "h264" }
+
+        return videoAssetsURLs.map {
+            Stream(
+                audioAsset: AVURLAsset(url: DataProvider.proxyURLForAsset(audioAssetURL!["url"].stringValue)!),
+                videoAsset: AVURLAsset(url: DataProvider.proxyURLForAsset($0["url"].stringValue)!),
+                resolution: StreamResolution.from(resolution: $0["resolution"].stringValue)!,
+                type: .adaptive,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
 }