nomad/ananas
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean up JellyfinRepositoryImpl

Browse source
This commit is contained in:
Jarne Demeulemeester 2022-01-01 18:43:54 +01:00
parent 8e3c4a3a37
commit 9a4f846023
No known key found for this signature in database
GPG key ID: B61B7B150DB6A6D2
2 changed files with 101 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

238
app/src/main/java/dev/jdtech/jellyfin/repository/JellyfinRepositoryImpl.kt
View file

@ -10,21 +10,12 @@ import timber.log.Timber
import java.util.* import java.util.*
class JellyfinRepositoryImpl(private val jellyfinApi: JellyfinApi) : JellyfinRepository { class JellyfinRepositoryImpl(private val jellyfinApi: JellyfinApi) : JellyfinRepository {
override suspend fun getUserViews(): List<BaseItemDto> { override suspend fun getUserViews(): List<BaseItemDto> = withContext(Dispatchers.IO) {
val views: List<BaseItemDto> jellyfinApi.viewsApi.getUserViews(jellyfinApi.userId!!).content.items.orEmpty()
withContext(Dispatchers.IO) {
views =
jellyfinApi.viewsApi.getUserViews(jellyfinApi.userId!!).content.items ?: emptyList()
}
return views
} }
override suspend fun getItem(itemId: UUID): BaseItemDto { override suspend fun getItem(itemId: UUID): BaseItemDto = withContext(Dispatchers.IO) {
val item: BaseItemDto jellyfinApi.userLibraryApi.getItem(jellyfinApi.userId!!, itemId).content
withContext(Dispatchers.IO) {
item = jellyfinApi.userLibraryApi.getItem(jellyfinApi.userId!!, itemId).content
}
return item
} }
override suspend fun getItems( override suspend fun getItems(
@ -33,181 +24,142 @@ class JellyfinRepositoryImpl(private val jellyfinApi: JellyfinApi) : JellyfinRep
recursive: Boolean, recursive: Boolean,
sortBy: SortBy, sortBy: SortBy,
sortOrder: SortOrder sortOrder: SortOrder
): List<BaseItemDto> { ): List<BaseItemDto> = withContext(Dispatchers.IO) {
val items: List<BaseItemDto> jellyfinApi.itemsApi.getItems(
Timber.d("$sortBy $sortOrder") jellyfinApi.userId!!,
withContext(Dispatchers.IO) { parentId = parentId,
items = jellyfinApi.itemsApi.getItems( includeItemTypes = includeTypes,
jellyfinApi.userId!!, recursive = recursive,
parentId = parentId, sortBy = listOf(sortBy.SortString),
includeItemTypes = includeTypes, sortOrder = listOf(sortOrder)
recursive = recursive, ).content.items.orEmpty()
sortBy = listOf(sortBy.SortString),
sortOrder = listOf(sortOrder)
).content.items ?: emptyList()
}
return items
} }
override suspend fun getPersonItems( override suspend fun getPersonItems(
personIds: List<UUID>, personIds: List<UUID>,
includeTypes: List<ContentType>?, includeTypes: List<ContentType>?,
recursive: Boolean recursive: Boolean
): List<BaseItemDto> { ): List<BaseItemDto> = withContext(Dispatchers.IO) {
val items: List<BaseItemDto> jellyfinApi.itemsApi.getItems(
withContext(Dispatchers.IO) { jellyfinApi.userId!!,
items = jellyfinApi.itemsApi.getItems( personIds = personIds,
jellyfinApi.userId!!, includeItemTypes = includeTypes?.map { it.type },
personIds = personIds, recursive = recursive
includeItemTypes = includeTypes?.map { it.type }, ).content.items.orEmpty()
recursive = recursive
).content.items ?: emptyList()
}
return items
} }
override suspend fun getFavoriteItems(): List<BaseItemDto> { override suspend fun getFavoriteItems(): List<BaseItemDto> = withContext(Dispatchers.IO) {
val items: List<BaseItemDto> jellyfinApi.itemsApi.getItems(
withContext(Dispatchers.IO) { jellyfinApi.userId!!,
items = jellyfinApi.itemsApi.getItems( filters = listOf(ItemFilter.IS_FAVORITE),
jellyfinApi.userId!!, includeItemTypes = listOf("Movie", "Series", "Episode"),
filters = listOf(ItemFilter.IS_FAVORITE), recursive = true
includeItemTypes = listOf("Movie", "Series", "Episode"), ).content.items.orEmpty()
recursive = true
).content.items ?: emptyList()
}
return items
} }
override suspend fun getSearchItems(searchQuery: String): List<BaseItemDto> { override suspend fun getSearchItems(searchQuery: String): List<BaseItemDto> =
val items: List<BaseItemDto>
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
items = jellyfinApi.itemsApi.getItems( jellyfinApi.itemsApi.getItems(
jellyfinApi.userId!!, jellyfinApi.userId!!,
searchTerm = searchQuery, searchTerm = searchQuery,
includeItemTypes = listOf("Movie", "Series", "Episode"), includeItemTypes = listOf("Movie", "Series", "Episode"),
recursive = true recursive = true
).content.items ?: emptyList() ).content.items.orEmpty()
} }
return items
override suspend fun getResumeItems(): List<BaseItemDto> = withContext(Dispatchers.IO) {
jellyfinApi.itemsApi.getResumeItems(
jellyfinApi.userId!!,
includeItemTypes = listOf("Movie", "Episode"),
).content.items.orEmpty()
} }
override suspend fun getResumeItems(): List<BaseItemDto> { override suspend fun getLatestMedia(parentId: UUID): List<BaseItemDto> =
val items: List<BaseItemDto>
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
items = jellyfinApi.userLibraryApi.getLatestMedia(
jellyfinApi.itemsApi.getResumeItems(
jellyfinApi.userId!!,
includeItemTypes = listOf("Movie", "Episode"),
).content.items ?: emptyList()
}
return items
}
override suspend fun getLatestMedia(parentId: UUID): List<BaseItemDto> {
val items: List<BaseItemDto>
withContext(Dispatchers.IO) {
items = jellyfinApi.userLibraryApi.getLatestMedia(
jellyfinApi.userId!!, jellyfinApi.userId!!,
parentId = parentId parentId = parentId
).content ).content
} }
return items
}
override suspend fun getSeasons(seriesId: UUID): List<BaseItemDto> { override suspend fun getSeasons(seriesId: UUID): List<BaseItemDto> =
val seasons: List<BaseItemDto>
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
seasons = jellyfinApi.showsApi.getSeasons(seriesId, jellyfinApi.userId!!).content.items jellyfinApi.showsApi.getSeasons(seriesId, jellyfinApi.userId!!).content.items.orEmpty()
?: emptyList()
} }
return seasons
}
override suspend fun getNextUp(seriesId: UUID?): List<BaseItemDto> { override suspend fun getNextUp(seriesId: UUID?): List<BaseItemDto> =
val nextUpItems: List<BaseItemDto>
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
nextUpItems = jellyfinApi.showsApi.getNextUp( jellyfinApi.showsApi.getNextUp(
jellyfinApi.userId!!, jellyfinApi.userId!!,
seriesId = seriesId?.toString(), seriesId = seriesId?.toString(),
).content.items ?: emptyList() ).content.items.orEmpty()
} }
return nextUpItems
}
override suspend fun getEpisodes( override suspend fun getEpisodes(
seriesId: UUID, seriesId: UUID,
seasonId: UUID, seasonId: UUID,
fields: List<ItemFields>?, fields: List<ItemFields>?,
startItemId: UUID? startItemId: UUID?
): List<BaseItemDto> { ): List<BaseItemDto> = withContext(Dispatchers.IO) {
val episodes: List<BaseItemDto> jellyfinApi.showsApi.getEpisodes(
seriesId,
jellyfinApi.userId!!,
seasonId = seasonId,
fields = fields,
startItemId = startItemId
).content.items.orEmpty()
}
override suspend fun getMediaSources(itemId: UUID): List<MediaSourceInfo> =
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
episodes = jellyfinApi.showsApi.getEpisodes( jellyfinApi.mediaInfoApi.getPostedPlaybackInfo(
seriesId, itemId, PlaybackInfoDto(
jellyfinApi.userId!!, userId = jellyfinApi.userId!!,
seasonId = seasonId, deviceProfile = DeviceProfile(
fields = fields, name = "Direct play all",
startItemId = startItemId maxStaticBitrate = 1_000_000_000,
).content.items ?: emptyList() maxStreamingBitrate = 1_000_000_000,
} codecProfiles = emptyList(),
return episodes containerProfiles = emptyList(),
} directPlayProfiles = listOf(
DirectPlayProfile(
override suspend fun getMediaSources(itemId: UUID): List<MediaSourceInfo> { type = DlnaProfileType.VIDEO
val mediaSourceInfoList: List<MediaSourceInfo> ), DirectPlayProfile(type = DlnaProfileType.AUDIO)
val mediaInfo by jellyfinApi.mediaInfoApi.getPostedPlaybackInfo( ),
itemId, PlaybackInfoDto( transcodingProfiles = emptyList(),
userId = jellyfinApi.userId!!, responseProfiles = emptyList(),
deviceProfile = DeviceProfile( enableAlbumArtInDidl = false,
name = "Direct play all", enableMsMediaReceiverRegistrar = false,
maxStaticBitrate = 1_000_000_000, enableSingleAlbumArtLimit = false,
maxStreamingBitrate = 1_000_000_000, enableSingleSubtitleLimit = false,
codecProfiles = emptyList(), ignoreTranscodeByteRangeRequests = false,
containerProfiles = emptyList(), maxAlbumArtHeight = 1_000_000_000,
directPlayProfiles = listOf( maxAlbumArtWidth = 1_000_000_000,
DirectPlayProfile( requiresPlainFolders = false,
type = DlnaProfileType.VIDEO requiresPlainVideoItems = false,
), DirectPlayProfile(type = DlnaProfileType.AUDIO) timelineOffsetSeconds = 0
), ),
transcodingProfiles = emptyList(), startTimeTicks = null,
responseProfiles = emptyList(), audioStreamIndex = null,
enableAlbumArtInDidl = false, subtitleStreamIndex = null,
enableMsMediaReceiverRegistrar = false, maxStreamingBitrate = 1_000_000_000,
enableSingleAlbumArtLimit = false, )
enableSingleSubtitleLimit = false, ).content.mediaSources.orEmpty()
ignoreTranscodeByteRangeRequests = false, }
maxAlbumArtHeight = 1_000_000_000,
maxAlbumArtWidth = 1_000_000_000,
requiresPlainFolders = false,
requiresPlainVideoItems = false,
timelineOffsetSeconds = 0
),
startTimeTicks = null,
audioStreamIndex = null,
subtitleStreamIndex = null,
maxStreamingBitrate = 1_000_000_000,
)
)
mediaSourceInfoList = mediaInfo.mediaSources ?: emptyList()
return mediaSourceInfoList
}
override suspend fun getStreamUrl(itemId: UUID, mediaSourceId: String): String { override suspend fun getStreamUrl(itemId: UUID, mediaSourceId: String): String =
var streamUrl = ""
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
try { try {
streamUrl = jellyfinApi.videosApi.getVideoStreamUrl( jellyfinApi.videosApi.getVideoStreamUrl(
itemId, itemId,
static = true, static = true,
mediaSourceId = mediaSourceId mediaSourceId = mediaSourceId
) )
} catch (e: Exception) { } catch (e: Exception) {
Timber.e(e) Timber.e(e)
""
} }
} }
return streamUrl
}
override suspend fun postCapabilities() { override suspend fun postCapabilities() {
Timber.d("Sending capabilities") Timber.d("Sending capabilities")
@ -291,13 +243,7 @@ class JellyfinRepositoryImpl(private val jellyfinApi: JellyfinApi) : JellyfinRep
} }
} }
override suspend fun getIntros(itemId: UUID): List<BaseItemDto> { override suspend fun getIntros(itemId: UUID): List<BaseItemDto> = withContext(Dispatchers.IO) {
val intros: List<BaseItemDto> jellyfinApi.userLibraryApi.getIntros(jellyfinApi.userId!!, itemId).content.items.orEmpty()
withContext(Dispatchers.IO) {
intros =
jellyfinApi.userLibraryApi.getIntros(jellyfinApi.userId!!, itemId).content.items
?: emptyList()
}
return intros
} }
} }

20
app/src/main/java/dev/jdtech/jellyfin/viewmodels/HomeViewModel.kt
View file

@ -63,7 +63,7 @@ class HomeViewModel @Inject internal constructor(
} }
} }
private suspend fun loadDynamicItems() = withContext(Dispatchers.IO) { private suspend fun loadDynamicItems(): List<Section> {
val resumeItems = repository.getResumeItems() val resumeItems = repository.getResumeItems()
val nextUpItems = repository.getNextUp() val nextUpItems = repository.getNextUp()
@ -88,18 +88,16 @@ class HomeViewModel @Inject internal constructor(
) )
} }
items.map { Section(it) } return items.map { Section(it) }
} }
private suspend fun loadViews() = withContext(Dispatchers.IO) { private suspend fun loadViews() = repository
repository .getUserViews()
.getUserViews() .filter { view -> unsupportedCollections().none { it.type == view.collectionType } }
.filter { view -> unsupportedCollections().none { it.type == view.collectionType } } .map { view -> view to repository.getLatestMedia(view.id) }
.map { view -> view to repository.getLatestMedia(view.id) } .filter { (_, latest) -> latest.isNotEmpty() }
.filter { (_, latest) -> latest.isNotEmpty() } .map { (view, latest) -> view.toView().apply { items = latest } }
.map { (view, latest) -> view.toView().apply { items = latest } } .map { ViewItem(it) }
.map { ViewItem(it) }
}
} }