Channels search, add SDWebImage framework

Model/Applications/InvidiousAPI.swift

@@ -1,3 +1,4 @@
+import AVKit
 import Defaults
 import Foundation
 import Siesta
@@ -80,15 +81,25 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         }
 
         configureTransformer(pathPattern("popular"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
         configureTransformer(pathPattern("trending"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
-        configureTransformer(pathPattern("search"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+        configureTransformer(pathPattern("search"), requestMethods: [.get]) { (content: Entity<JSON>) -> [ContentItem] in
+            content.json.arrayValue.map {
+                let type = $0.dictionaryValue["type"]?.stringValue
+
+                if type == "channel" {
+                    return ContentItem(channel: InvidiousAPI.extractChannel(from: $0))
+                } else if type == "playlist" {
+                    // TODO: fix playlists
+                    return ContentItem(playlist: Playlist(JSON(parseJSON: "{}")))
+                }
+                return ContentItem(video: InvidiousAPI.extractVideo($0))
+            }
         }
 
         configureTransformer(pathPattern("search/suggestions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [String] in
@@ -114,34 +125,34 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
         configureTransformer(pathPattern("auth/feed"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
             if let feedVideos = content.json.dictionaryValue["videos"] {
-                return feedVideos.arrayValue.map(Video.init)
+                return feedVideos.arrayValue.map(InvidiousAPI.extractVideo)
             }
 
             return []
         }
 
         configureTransformer(pathPattern("auth/subscriptions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Channel] in
-            content.json.arrayValue.map(Channel.init)
+            content.json.arrayValue.map(InvidiousAPI.extractChannel)
         }
 
         configureTransformer(pathPattern("channels/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Channel in
-            Channel(json: content.json)
+            InvidiousAPI.extractChannel(from: content.json)
         }
 
         configureTransformer(pathPattern("channels/*/latest"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
         configureTransformer(pathPattern("videos/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Video in
-            Video(content.json)
+            InvidiousAPI.extractVideo(content.json)
         }
     }
 
-    fileprivate func pathPattern(_ path: String) -> String {
+    private func pathPattern(_ path: String) -> String {
         "**\(InvidiousAPI.basePath)/\(path)"
     }
 
-    fileprivate func basePathAppending(_ path: String) -> String {
+    private func basePathAppending(_ path: String) -> String {
         "\(InvidiousAPI.basePath)/\(path)"
     }
 
@@ -207,6 +218,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         var resource = resource(baseURL: account.url, path: basePathAppending("search"))
             .withParam("q", searchQuery(query.query))
             .withParam("sort_by", query.sortBy.parameter)
+            .withParam("type", "all")
 
         if let date = query.date, date != .any {
             resource = resource.withParam("date", date.rawValue)
@@ -242,4 +254,106 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
         return searchQuery
     }
+
+    static func assetURLFrom(instance: Instance, url: URL) -> URL? {
+        guard let instanceURLComponents = URLComponents(string: instance.url),
+              var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return nil }
+
+        urlComponents.scheme = instanceURLComponents.scheme
+        urlComponents.host = instanceURLComponents.host
+
+        return urlComponents.url
+    }
+
+    static func extractVideo(_ json: JSON) -> Video {
+        let indexID: String?
+        var id: Video.ID
+        var publishedAt: Date?
+
+        if let publishedInterval = json["published"].double {
+            publishedAt = Date(timeIntervalSince1970: publishedInterval)
+        }
+
+        let videoID = json["videoId"].stringValue
+
+        if let index = json["indexId"].string {
+            indexID = index
+            id = videoID + index
+        } else {
+            indexID = nil
+            id = videoID
+        }
+
+        return Video(
+            id: id,
+            videoID: videoID,
+            title: json["title"].stringValue,
+            author: json["author"].stringValue,
+            length: json["lengthSeconds"].doubleValue,
+            published: json["publishedText"].stringValue,
+            views: json["viewCount"].intValue,
+            description: json["description"].stringValue,
+            genre: json["genre"].stringValue,
+            channel: extractChannel(from: json),
+            thumbnails: extractThumbnails(from: json),
+            indexID: indexID,
+            live: json["liveNow"].boolValue,
+            upcoming: json["isUpcoming"].boolValue,
+            publishedAt: publishedAt,
+            likes: json["likeCount"].int,
+            dislikes: json["dislikeCount"].int,
+            keywords: json["keywords"].arrayValue.map { $0.stringValue },
+            streams: extractFormatStreams(from: json["formatStreams"].arrayValue) +
+                extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue)
+        )
+    }
+
+    static func extractChannel(from json: JSON) -> Channel {
+        let thumbnailURL = "https:\(json["authorThumbnails"].arrayValue.first?.dictionaryValue["url"]?.stringValue ?? "")"
+
+        return Channel(
+            id: json["authorId"].stringValue,
+            name: json["author"].stringValue,
+            thumbnailURL: URL(string: thumbnailURL),
+            subscriptionsCount: json["subCount"].int,
+            subscriptionsText: json["subCountText"].string,
+            videos: json.dictionaryValue["latestVideos"]?.arrayValue.map(InvidiousAPI.extractVideo) ?? []
+        )
+    }
+
+    private static func extractThumbnails(from details: JSON) -> [Thumbnail] {
+        details["videoThumbnails"].arrayValue.map { json in
+            Thumbnail(url: json["url"].url!, quality: .init(rawValue: json["quality"].string!)!)
+        }
+    }
+
+    private static func extractFormatStreams(from streams: [JSON]) -> [Stream] {
+        streams.map {
+            SingleAssetStream(
+                avAsset: AVURLAsset(url: $0["url"].url!),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
+                kind: .stream,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
+
+    private static 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: audioAssetURL!["url"].url!),
+                videoAsset: AVURLAsset(url: $0["url"].url!),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
+                kind: .adaptive,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
 }

Model/Applications/PipedAPI.swift

@@ -32,19 +32,19 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
         }
 
         configureTransformer(pathPattern("channel/*")) { (content: Entity<JSON>) -> Channel? in
-            self.extractChannel(content.json)
+            PipedAPI.extractChannel(content.json)
         }
 
         configureTransformer(pathPattern("streams/*")) { (content: Entity<JSON>) -> Video? in
-            self.extractVideo(content.json)
+            PipedAPI.extractVideo(content.json)
         }
 
         configureTransformer(pathPattern("trending")) { (content: Entity<JSON>) -> [Video] in
-            self.extractVideos(content.json)
+            PipedAPI.extractVideos(content.json)
         }
 
-        configureTransformer(pathPattern("search")) { (content: Entity<JSON>) -> [Video] in
-            self.extractVideos(content.json.dictionaryValue["items"]!)
+        configureTransformer(pathPattern("search")) { (content: Entity<JSON>) -> [ContentItem] in
+            PipedAPI.extractContentItems(content.json.dictionaryValue["items"]!)
         }
 
         configureTransformer(pathPattern("suggestions")) { (content: Entity<JSON>) -> [String] in
@@ -52,154 +52,6 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
         }
     }
 
-    private func extractChannel(_ content: JSON) -> Channel? {
-        Channel(
-            id: content.dictionaryValue["id"]!.stringValue,
-            name: content.dictionaryValue["name"]!.stringValue,
-            subscriptionsCount: content.dictionaryValue["subscriberCount"]!.intValue,
-            videos: extractVideos(content.dictionaryValue["relatedStreams"]!)
-        )
-    }
-
-    private func extractVideo(_ content: JSON) -> Video? {
-        let details = content.dictionaryValue
-        let url = details["url"]?.string
-
-        if !url.isNil {
-            guard url!.contains("/watch") else {
-                return nil
-            }
-        }
-
-        let channelId = details["uploaderUrl"]!.stringValue.components(separatedBy: "/").last!
-
-        let thumbnails: [Thumbnail] = Thumbnail.Quality.allCases.compactMap {
-            if let url = buildThumbnailURL(content, quality: $0) {
-                return Thumbnail(url: url, quality: $0)
-            }
-
-            return nil
-        }
-
-        let author = details["uploaderName"]?.stringValue ?? details["uploader"]!.stringValue
-
-        return Video(
-            videoID: extractID(content),
-            title: details["title"]!.stringValue,
-            author: author,
-            length: details["duration"]!.doubleValue,
-            published: details["uploadedDate"]?.stringValue ?? details["uploadDate"]!.stringValue,
-            views: details["views"]!.intValue,
-            description: extractDescription(content),
-            channel: Channel(id: channelId, name: author),
-            thumbnails: thumbnails,
-            likes: details["likes"]?.int,
-            dislikes: details["dislikes"]?.int,
-            streams: extractStreams(content)
-        )
-    }
-
-    private func extractID(_ content: JSON) -> Video.ID {
-        content.dictionaryValue["url"]?.stringValue.components(separatedBy: "?v=").last ??
-            extractThumbnailURL(content)!.relativeString.components(separatedBy: "/")[4]
-    }
-
-    private func extractThumbnailURL(_ content: JSON) -> URL? {
-        content.dictionaryValue["thumbnail"]?.url! ?? content.dictionaryValue["thumbnailUrl"]!.url!
-    }
-
-    private func buildThumbnailURL(_ content: JSON, quality: Thumbnail.Quality) -> URL? {
-        let thumbnailURL = extractThumbnailURL(content)
-        guard !thumbnailURL.isNil else {
-            return nil
-        }
-
-        return URL(string: thumbnailURL!
-            .absoluteString
-            .replacingOccurrences(of: "_webp", with: "")
-            .replacingOccurrences(of: ".webp", with: ".jpg")
-            .replacingOccurrences(of: "hqdefault", with: quality.filename)
-            .replacingOccurrences(of: "maxresdefault", with: quality.filename)
-        )!
-    }
-
-    private func extractDescription(_ content: JSON) -> String? {
-        guard var description = content.dictionaryValue["description"]?.string else {
-            return nil
-        }
-
-        description = description.replacingOccurrences(
-            of: "<br/>|<br />|<br>",
-            with: "\n",
-            options: .regularExpression,
-            range: nil
-        )
-
-        description = description.replacingOccurrences(
-            of: "<[^>]+>",
-            with: "",
-            options: .regularExpression,
-            range: nil
-        )
-
-        return description
-    }
-
-    private func extractVideos(_ content: JSON) -> [Video] {
-        content.arrayValue.compactMap(extractVideo(_:))
-    }
-
-    private func extractStreams(_ content: JSON) -> [Stream] {
-        var streams = [Stream]()
-
-        if let hlsURL = content.dictionaryValue["hls"]?.url {
-            streams.append(Stream(hlsURL: hlsURL))
-        }
-
-        guard let audioStream = compatibleAudioStreams(content).first else {
-            return streams
-        }
-
-        let videoStreams = compatibleVideoStream(content)
-
-        videoStreams.forEach { videoStream in
-            let audioAsset = AVURLAsset(url: audioStream.dictionaryValue["url"]!.url!)
-            let videoAsset = AVURLAsset(url: videoStream.dictionaryValue["url"]!.url!)
-
-            let videoOnly = videoStream.dictionaryValue["videoOnly"]?.boolValue ?? true
-            let resolution = Stream.Resolution.from(resolution: videoStream.dictionaryValue["quality"]!.stringValue)
-
-            if videoOnly {
-                streams.append(
-                    Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive)
-                )
-            } else {
-                streams.append(
-                    SingleAssetStream(avAsset: videoAsset, resolution: resolution, kind: .stream)
-                )
-            }
-        }
-
-        return streams
-    }
-
-    private func compatibleAudioStreams(_ content: JSON) -> [JSON] {
-        content
-            .dictionaryValue["audioStreams"]?
-            .arrayValue
-            .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" }
-            .sorted {
-                $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0
-            } ?? []
-    }
-
-    private func compatibleVideoStream(_ content: JSON) -> [JSON] {
-        content
-            .dictionaryValue["videoStreams"]?
-            .arrayValue
-            .filter { $0.dictionaryValue["format"] == "MPEG_4" } ?? []
-    }
-
     func channel(_ id: String) -> Resource {
         resource(baseURL: account.url, path: "channel/\(id)")
     }
@@ -240,4 +92,205 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
     private func pathPattern(_ path: String) -> String {
         "**\(path)"
     }
+
+    private static func extractContentItem(_ content: JSON) -> ContentItem? {
+        let details = content.dictionaryValue
+        let url: String! = details["url"]?.string
+
+        let contentType: ContentItem.ContentType
+
+        if !url.isNil {
+            if url.contains("/playlist") {
+                contentType = .playlist
+            } else if url.contains("/channel") {
+                contentType = .channel
+            } else {
+                contentType = .video
+            }
+        } else {
+            contentType = .video
+        }
+
+        switch contentType {
+        case .video:
+            if let video = PipedAPI.extractVideo(content) {
+                return ContentItem(video: video)
+            }
+
+        case .playlist:
+            return nil
+
+        case .channel:
+            if let channel = PipedAPI.extractChannel(content) {
+                return ContentItem(channel: channel)
+            }
+        }
+
+        return nil
+    }
+
+    private static func extractContentItems(_ content: JSON) -> [ContentItem] {
+        content.arrayValue.compactMap { PipedAPI.extractContentItem($0) }
+    }
+
+    private static func extractChannel(_ content: JSON) -> Channel? {
+        let attributes = content.dictionaryValue
+        guard let id = attributes["id"]?.stringValue ??
+            attributes["url"]?.stringValue.components(separatedBy: "/").last
+        else {
+            return nil
+        }
+
+        let subscriptionsCount = attributes["subscriberCount"]?.intValue ?? attributes["subscribers"]?.intValue
+
+        var videos = [Video]()
+        if let relatedStreams = attributes["relatedStreams"] {
+            videos = PipedAPI.extractVideos(relatedStreams)
+        }
+
+        return Channel(
+            id: id,
+            name: attributes["name"]!.stringValue,
+            thumbnailURL: attributes["thumbnail"]?.url,
+            subscriptionsCount: subscriptionsCount,
+            videos: videos
+        )
+    }
+
+    private static func extractVideo(_ content: JSON) -> Video? {
+        let details = content.dictionaryValue
+        let url = details["url"]?.string
+
+        if !url.isNil {
+            guard url!.contains("/watch") else {
+                return nil
+            }
+        }
+
+        let channelId = details["uploaderUrl"]!.stringValue.components(separatedBy: "/").last!
+
+        let thumbnails: [Thumbnail] = Thumbnail.Quality.allCases.compactMap {
+            if let url = PipedAPI.buildThumbnailURL(content, quality: $0) {
+                return Thumbnail(url: url, quality: $0)
+            }
+
+            return nil
+        }
+
+        let author = details["uploaderName"]?.stringValue ?? details["uploader"]!.stringValue
+
+        return Video(
+            videoID: PipedAPI.extractID(content),
+            title: details["title"]!.stringValue,
+            author: author,
+            length: details["duration"]!.doubleValue,
+            published: details["uploadedDate"]?.stringValue ?? details["uploadDate"]!.stringValue,
+            views: details["views"]!.intValue,
+            description: PipedAPI.extractDescription(content),
+            channel: Channel(id: channelId, name: author),
+            thumbnails: thumbnails,
+            likes: details["likes"]?.int,
+            dislikes: details["dislikes"]?.int,
+            streams: extractStreams(content)
+        )
+    }
+
+    private static func extractID(_ content: JSON) -> Video.ID {
+        content.dictionaryValue["url"]?.stringValue.components(separatedBy: "?v=").last ??
+            extractThumbnailURL(content)!.relativeString.components(separatedBy: "/")[4]
+    }
+
+    private static func extractThumbnailURL(_ content: JSON) -> URL? {
+        content.dictionaryValue["thumbnail"]?.url! ?? content.dictionaryValue["thumbnailUrl"]!.url!
+    }
+
+    private static func buildThumbnailURL(_ content: JSON, quality: Thumbnail.Quality) -> URL? {
+        let thumbnailURL = extractThumbnailURL(content)
+        guard !thumbnailURL.isNil else {
+            return nil
+        }
+
+        return URL(string: thumbnailURL!
+            .absoluteString
+            .replacingOccurrences(of: "hqdefault", with: quality.filename)
+            .replacingOccurrences(of: "maxresdefault", with: quality.filename)
+        )!
+    }
+
+    private static func extractDescription(_ content: JSON) -> String? {
+        guard var description = content.dictionaryValue["description"]?.string else {
+            return nil
+        }
+
+        description = description.replacingOccurrences(
+            of: "<br/>|<br />|<br>",
+            with: "\n",
+            options: .regularExpression,
+            range: nil
+        )
+
+        description = description.replacingOccurrences(
+            of: "<[^>]+>",
+            with: "",
+            options: .regularExpression,
+            range: nil
+        )
+
+        return description
+    }
+
+    private static func extractVideos(_ content: JSON) -> [Video] {
+        content.arrayValue.compactMap(extractVideo(_:))
+    }
+
+    private static func extractStreams(_ content: JSON) -> [Stream] {
+        var streams = [Stream]()
+
+        if let hlsURL = content.dictionaryValue["hls"]?.url {
+            streams.append(Stream(hlsURL: hlsURL))
+        }
+
+        guard let audioStream = PipedAPI.compatibleAudioStreams(content).first else {
+            return streams
+        }
+
+        let videoStreams = PipedAPI.compatibleVideoStream(content)
+
+        videoStreams.forEach { videoStream in
+            let audioAsset = AVURLAsset(url: audioStream.dictionaryValue["url"]!.url!)
+            let videoAsset = AVURLAsset(url: videoStream.dictionaryValue["url"]!.url!)
+
+            let videoOnly = videoStream.dictionaryValue["videoOnly"]?.boolValue ?? true
+            let resolution = Stream.Resolution.from(resolution: videoStream.dictionaryValue["quality"]!.stringValue)
+
+            if videoOnly {
+                streams.append(
+                    Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive)
+                )
+            } else {
+                streams.append(
+                    SingleAssetStream(avAsset: videoAsset, resolution: resolution, kind: .stream)
+                )
+            }
+        }
+
+        return streams
+    }
+
+    private static func compatibleAudioStreams(_ content: JSON) -> [JSON] {
+        content
+            .dictionaryValue["audioStreams"]?
+            .arrayValue
+            .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" }
+            .sorted {
+                $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0
+            } ?? []
+    }
+
+    private static func compatibleVideoStream(_ content: JSON) -> [JSON] {
+        content
+            .dictionaryValue["videoStreams"]?
+            .arrayValue
+            .filter { $0.dictionaryValue["format"] == "MPEG_4" } ?? []
+    }
 }