1
0
mirror of https://github.com/yattee/yattee.git synced 2024-12-14 22:30:32 +05:30
yattee/Model/Applications/InvidiousAPI.swift

517 lines
17 KiB
Swift
Raw Normal View History

import AVKit
2021-07-08 04:09:18 +05:30
import Defaults
2021-06-28 16:13:07 +05:30
import Foundation
import Siesta
import SwiftyJSON
2021-10-21 03:51:50 +05:30
final class InvidiousAPI: Service, ObservableObject, VideosAPI {
2021-09-25 13:48:22 +05:30
static let basePath = "/api/v1"
2021-06-28 16:13:07 +05:30
2021-10-21 03:51:50 +05:30
@Published var account: Account!
2021-06-28 16:13:07 +05:30
2021-10-17 04:18:58 +05:30
@Published var validInstance = true
2021-09-29 17:15:00 +05:30
@Published var signedIn = false
2021-06-28 16:13:07 +05:30
2021-10-21 03:51:50 +05:30
init(account: Account? = nil) {
2021-10-17 04:18:58 +05:30
super.init()
guard !account.isNil else {
2021-10-18 03:19:56 +05:30
self.account = .init(name: "Empty")
2021-10-17 04:18:58 +05:30
return
}
setAccount(account!)
}
2021-10-21 03:51:50 +05:30
func setAccount(_ account: Account) {
2021-09-25 13:48:22 +05:30
self.account = account
signedIn = false
2021-09-25 13:48:22 +05:30
2021-12-19 22:26:47 +05:30
validInstance = account.anonymous
2021-09-25 13:48:22 +05:30
configure()
2021-12-19 22:26:47 +05:30
if !account.anonymous {
validate()
}
2021-09-25 13:48:22 +05:30
}
func validate() {
validateInstance()
validateSID()
}
func validateInstance() {
guard !validInstance else {
return
}
2021-10-21 03:51:50 +05:30
home?
2021-09-25 13:48:22 +05:30
.load()
.onSuccess { _ in
self.validInstance = true
}
.onFailure { _ in
self.validInstance = false
}
}
func validateSID() {
guard !signedIn else {
return
}
2021-10-21 03:51:50 +05:30
feed?
2021-09-25 13:48:22 +05:30
.load()
.onSuccess { _ in
self.signedIn = true
}
.onFailure { _ in
self.signedIn = false
}
}
func configure() {
2021-06-28 16:13:07 +05:30
configure {
if !self.account.username.isEmpty {
2021-10-17 04:18:58 +05:30
$0.headers["Cookie"] = self.cookieHeader
}
2021-06-28 16:13:07 +05:30
$0.pipeline[.parsing].add(SwiftyJSONTransformer, contentTypes: ["*/json"])
}
configure("**", requestMethods: [.post]) {
$0.pipeline[.parsing].removeTransformers()
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("popular"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
2021-12-17 22:09:26 +05:30
content.json.arrayValue.map(self.extractVideo)
2021-06-28 16:13:07 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("trending"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
2021-12-17 22:09:26 +05:30
content.json.arrayValue.map(self.extractVideo)
2021-06-28 16:13:07 +05:30
}
configureTransformer(pathPattern("search"), requestMethods: [.get]) { (content: Entity<JSON>) -> SearchPage in
2022-03-29 00:56:38 +05:30
let results = content.json.arrayValue.compactMap { json -> ContentItem? in
let type = json.dictionaryValue["type"]?.stringValue
if type == "channel" {
return ContentItem(channel: self.extractChannel(from: json))
} else if type == "playlist" {
return ContentItem(playlist: self.extractChannelPlaylist(from: json))
2022-03-29 00:56:38 +05:30
} else if type == "video" {
return ContentItem(video: self.extractVideo(from: json))
}
2022-03-29 00:56:38 +05:30
return nil
}
return SearchPage(results: results, last: results.isEmpty)
2021-06-28 16:13:07 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("search/suggestions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [String] in
2021-09-14 02:11:16 +05:30
if let suggestions = content.json.dictionaryValue["suggestions"] {
return suggestions.arrayValue.map(String.init)
}
return []
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("auth/playlists"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Playlist] in
2021-12-17 22:09:26 +05:30
content.json.arrayValue.map(self.extractPlaylist)
2021-06-28 16:13:07 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("auth/playlists/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Playlist in
2021-12-17 22:09:26 +05:30
self.extractPlaylist(from: content.json)
2021-08-30 03:06:18 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("auth/playlists"), requestMethods: [.post, .patch]) { (content: Entity<Data>) -> Playlist in
2021-07-08 20:44:54 +05:30
// hacky, to verify if possible to get it in easier way
Playlist(JSON(parseJSON: String(data: content.content, encoding: .utf8)!))
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("auth/feed"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
2021-06-28 16:13:07 +05:30
if let feedVideos = content.json.dictionaryValue["videos"] {
2021-12-17 22:09:26 +05:30
return feedVideos.arrayValue.map(self.extractVideo)
2021-06-28 16:13:07 +05:30
}
return []
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("auth/subscriptions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Channel] in
2021-12-17 22:09:26 +05:30
content.json.arrayValue.map(self.extractChannel)
2021-08-26 03:42:59 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("channels/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Channel in
2021-12-17 22:09:26 +05:30
self.extractChannel(from: content.json)
2021-06-28 16:13:07 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("channels/*/latest"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
2021-12-17 22:09:26 +05:30
content.json.arrayValue.map(self.extractVideo)
2021-09-19 02:06:42 +05:30
}
2021-10-23 04:34:03 +05:30
configureTransformer(pathPattern("playlists/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> ChannelPlaylist in
2021-12-17 22:09:26 +05:30
self.extractChannelPlaylist(from: content.json)
2021-10-23 04:34:03 +05:30
}
2021-09-25 13:48:22 +05:30
configureTransformer(pathPattern("videos/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Video in
2021-12-17 22:09:26 +05:30
self.extractVideo(from: content.json)
2021-06-28 16:13:07 +05:30
}
}
private func pathPattern(_ path: String) -> String {
2022-05-21 01:23:17 +05:30
"**\(Self.basePath)/\(path)"
2021-09-25 13:48:22 +05:30
}
private func basePathAppending(_ path: String) -> String {
2022-05-21 01:23:17 +05:30
"\(Self.basePath)/\(path)"
2021-09-25 13:48:22 +05:30
}
private var cookieHeader: String {
"SID=\(account.username)"
2021-09-25 13:48:22 +05:30
}
2021-06-28 16:13:07 +05:30
2021-10-21 03:51:50 +05:30
var popular: Resource? {
2022-05-21 01:23:17 +05:30
resource(baseURL: account.url, path: "\(Self.basePath)/popular")
2021-06-28 16:13:07 +05:30
}
2021-10-21 03:51:50 +05:30
func trending(country: Country, category: TrendingCategory?) -> Resource {
2022-05-21 01:23:17 +05:30
resource(baseURL: account.url, path: "\(Self.basePath)/trending")
2021-11-05 03:31:27 +05:30
.withParam("type", category?.name)
2021-06-28 16:13:07 +05:30
.withParam("region", country.rawValue)
}
2021-10-21 03:51:50 +05:30
var home: Resource? {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: "/feed/subscriptions")
2021-09-19 23:01:21 +05:30
}
2021-10-21 03:51:50 +05:30
var feed: Resource? {
2022-05-21 01:23:17 +05:30
resource(baseURL: account.url, path: "\(Self.basePath)/auth/feed")
2021-09-25 13:48:22 +05:30
}
2021-10-21 03:51:50 +05:30
var subscriptions: Resource? {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
2021-08-26 03:42:59 +05:30
}
func subscribe(_ channelID: String, onCompletion: @escaping () -> Void = {}) {
resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
.child(channelID)
.request(.post)
.onCompletion { _ in onCompletion() }
}
func unsubscribe(_ channelID: String, onCompletion: @escaping () -> Void) {
resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
.child(channelID)
.request(.delete)
.onCompletion { _ in onCompletion() }
2021-08-26 03:42:59 +05:30
}
func channel(_ id: String) -> Resource {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("channels/\(id)"))
2021-06-28 16:13:07 +05:30
}
2021-09-19 02:06:42 +05:30
func channelVideos(_ id: String) -> Resource {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("channels/\(id)/latest"))
2021-09-19 02:06:42 +05:30
}
2021-06-28 16:13:07 +05:30
func video(_ id: String) -> Resource {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("videos/\(id)"))
2021-06-28 16:13:07 +05:30
}
2021-10-21 03:51:50 +05:30
var playlists: Resource? {
if account.isNil || account.anonymous {
return nil
}
return resource(baseURL: account.url, path: basePathAppending("auth/playlists"))
2021-06-28 16:13:07 +05:30
}
2021-10-21 03:51:50 +05:30
func playlist(_ id: String) -> Resource? {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("auth/playlists/\(id)"))
2021-07-08 22:48:36 +05:30
}
2021-10-21 03:51:50 +05:30
func playlistVideos(_ id: String) -> Resource? {
playlist(id)?.child("videos")
}
2021-10-21 03:51:50 +05:30
func playlistVideo(_ playlistID: String, _ videoID: String) -> Resource? {
playlist(playlistID)?.child("videos").child(videoID)
}
func addVideoToPlaylist(
_ videoID: String,
_ playlistID: String,
onFailure: @escaping (RequestError) -> Void = { _ in },
onSuccess: @escaping () -> Void = {}
) {
let resource = playlistVideos(playlistID)
let body = ["videoId": videoID]
resource?
.request(.post, json: body)
.onSuccess { _ in onSuccess() }
.onFailure(onFailure)
}
func removeVideoFromPlaylist(
_ index: String,
_ playlistID: String,
onFailure: @escaping (RequestError) -> Void,
onSuccess: @escaping () -> Void
) {
let resource = playlistVideo(playlistID, index)
resource?
.request(.delete)
.onSuccess { _ in onSuccess() }
.onFailure(onFailure)
}
func playlistForm(
_ name: String,
_ visibility: String,
playlist: Playlist?,
onFailure: @escaping (RequestError) -> Void,
onSuccess: @escaping (Playlist?) -> Void
) {
let body = ["title": name, "privacy": visibility]
let resource = !playlist.isNil ? self.playlist(playlist!.id) : playlists
resource?
.request(!playlist.isNil ? .patch : .post, json: body)
.onSuccess { response in
if let modifiedPlaylist: Playlist = response.typedContent() {
onSuccess(modifiedPlaylist)
}
}
.onFailure(onFailure)
}
func deletePlaylist(
_ playlist: Playlist,
onFailure: @escaping (RequestError) -> Void,
onSuccess: @escaping () -> Void
) {
self.playlist(playlist.id)?
.request(.delete)
.onSuccess { _ in onSuccess() }
.onFailure(onFailure)
}
2021-10-23 04:34:03 +05:30
func channelPlaylist(_ id: String) -> Resource? {
resource(baseURL: account.url, path: basePathAppending("playlists/\(id)"))
}
func search(_ query: SearchQuery, page: String?) -> Resource {
2021-09-25 13:48:22 +05:30
var resource = resource(baseURL: account.url, path: basePathAppending("search"))
2021-07-08 04:09:18 +05:30
.withParam("q", searchQuery(query.query))
.withParam("sort_by", query.sortBy.parameter)
.withParam("type", "all")
2021-07-08 04:09:18 +05:30
if let date = query.date, date != .any {
resource = resource.withParam("date", date.rawValue)
2021-07-08 04:09:18 +05:30
}
if let duration = query.duration, duration != .any {
resource = resource.withParam("duration", duration.rawValue)
2021-07-08 04:09:18 +05:30
}
if let page = page {
resource = resource.withParam("page", page)
}
2021-07-08 04:09:18 +05:30
return resource
2021-06-28 16:13:07 +05:30
}
2021-09-14 02:11:16 +05:30
func searchSuggestions(query: String) -> Resource {
2021-09-25 13:48:22 +05:30
resource(baseURL: account.url, path: basePathAppending("search/suggestions"))
2021-09-14 02:11:16 +05:30
.withParam("q", query.lowercased())
}
2021-12-05 01:05:41 +05:30
func comments(_: Video.ID, page _: String?) -> Resource? { nil }
2021-06-28 16:13:07 +05:30
private func searchQuery(_ query: String) -> String {
var searchQuery = query
let url = URLComponents(string: query)
if url != nil,
url!.host == "youtu.be"
{
searchQuery = url!.path.replacingOccurrences(of: "/", with: "")
}
let queryItem = url?.queryItems?.first { item in item.name == "v" }
if let id = queryItem?.value {
searchQuery = id
}
2021-07-08 20:44:54 +05:30
return searchQuery
2021-06-28 16:13:07 +05:30
}
2021-10-22 20:30:09 +05:30
static func proxiedAsset(instance: Instance, asset: AVURLAsset) -> AVURLAsset? {
2021-10-28 02:41:38 +05:30
guard let instanceURLComponents = URLComponents(string: instance.apiURL),
2021-10-22 20:30:09 +05:30
var urlComponents = URLComponents(url: asset.url, resolvingAgainstBaseURL: false) else { return nil }
urlComponents.scheme = instanceURLComponents.scheme
urlComponents.host = instanceURLComponents.host
2021-10-22 20:30:09 +05:30
guard let url = urlComponents.url else {
return nil
}
return AVURLAsset(url: url)
}
2021-12-17 22:09:26 +05:30
func extractVideo(from 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 },
2021-11-03 04:32:02 +05:30
streams: extractStreams(from: json),
related: extractRelated(from: json)
)
}
2021-12-17 22:09:26 +05:30
func extractChannel(from json: JSON) -> Channel {
var thumbnailURL = json["authorThumbnails"].arrayValue.last?.dictionaryValue["url"]?.stringValue ?? ""
// append protocol to unproxied thumbnail URL if it's missing
2021-12-17 22:09:26 +05:30
if thumbnailURL.count > 2,
String(thumbnailURL[..<thumbnailURL.index(thumbnailURL.startIndex, offsetBy: 2)]) == "//",
let accountUrlComponents = URLComponents(string: account.url)
2021-12-17 22:09:26 +05:30
{
thumbnailURL = "\(accountUrlComponents.scheme ?? "https"):\(thumbnailURL)"
2021-12-17 22:09:26 +05:30
}
return Channel(
id: json["authorId"].stringValue,
name: json["author"].stringValue,
thumbnailURL: URL(string: thumbnailURL),
subscriptionsCount: json["subCount"].int,
subscriptionsText: json["subCountText"].string,
2021-12-17 22:09:26 +05:30
videos: json.dictionaryValue["latestVideos"]?.arrayValue.map(extractVideo) ?? []
)
}
2021-12-17 22:09:26 +05:30
func extractChannelPlaylist(from json: JSON) -> ChannelPlaylist {
2021-10-23 04:34:03 +05:30
let details = json.dictionaryValue
return ChannelPlaylist(
id: details["playlistId"]!.stringValue,
title: details["title"]!.stringValue,
thumbnailURL: details["playlistThumbnail"]?.url,
channel: extractChannel(from: json),
2021-12-17 22:09:26 +05:30
videos: details["videos"]?.arrayValue.compactMap(extractVideo) ?? []
2021-10-23 04:34:03 +05:30
)
}
2021-12-17 22:09:26 +05:30
private func extractThumbnails(from details: JSON) -> [Thumbnail] {
details["videoThumbnails"].arrayValue.compactMap { json in
guard let url = json["url"].url,
var components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let quality = json["quality"].string,
let accountUrlComponents = URLComponents(string: account.url)
else {
return nil
}
// some of instances are not configured properly and return thumbnails links
// with incorrect scheme
components.scheme = accountUrlComponents.scheme
guard let thumbnailUrl = components.url else {
return nil
}
return Thumbnail(url: thumbnailUrl, quality: .init(rawValue: quality)!)
}
}
2021-12-17 22:09:26 +05:30
private func extractStreams(from json: JSON) -> [Stream] {
2021-11-03 04:32:02 +05:30
extractFormatStreams(from: json["formatStreams"].arrayValue) +
extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue)
}
2021-12-17 22:09:26 +05:30
private 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
)
}
}
2021-12-17 22:09:26 +05:30
private func extractAdaptiveFormats(from streams: [JSON]) -> [Stream] {
let audioAssetURL = streams.first { $0["type"].stringValue.starts(with: "audio/mp4") }
guard audioAssetURL != nil else {
return []
}
2022-02-17 01:53:11 +05:30
let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/") }
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,
2022-02-17 01:53:11 +05:30
encoding: $0["encoding"].stringValue,
videoFormat: $0["type"].stringValue
)
}
}
2021-11-03 04:32:02 +05:30
2021-12-17 22:09:26 +05:30
private func extractRelated(from content: JSON) -> [Video] {
2021-11-03 04:32:02 +05:30
content
.dictionaryValue["recommendedVideos"]?
.arrayValue
.compactMap(extractVideo(from:)) ?? []
}
2021-12-17 22:09:26 +05:30
private func extractPlaylist(from content: JSON) -> Playlist {
.init(
id: content["playlistId"].stringValue,
title: content["title"].stringValue,
visibility: content["isListed"].boolValue ? .public : .private,
updated: content["updated"].doubleValue,
videos: content["videos"].arrayValue.map { extractVideo(from: $0) }
)
}
2021-06-28 16:13:07 +05:30
}