From 743098d0b0f323ab50b464f9d48b66d7637a409d Mon Sep 17 00:00:00 2001 From: Koitharu Date: Tue, 25 Oct 2022 15:18:44 +0300 Subject: [PATCH 1/3] Basic AniList api implementation --- app/build.gradle | 2 + .../kotatsu/core/network/CommonHeaders.kt | 1 + .../kotatsu/core/prefs/AppSettings.kt | 1 + .../kotatsu/scrobbling/ScrobblingModule.kt | 24 +- .../anilist/data/AniListAuthenticator.kt | 53 ++++ .../anilist/data/AniListInterceptor.kt | 23 ++ .../anilist/data/AniListRepository.kt | 232 ++++++++++++++++++ .../scrobbling/anilist/data/AniListStorage.kt | 40 +++ .../anilist/data/model/AniListUser.kt | 42 ++++ .../anilist/domain/AniListScrobbler.kt | 71 ++++++ .../anilist/ui/AniListSettingsFragment.kt | 86 +++++++ .../anilist/ui/AniListSettingsViewModel.kt | 57 +++++ .../domain/model/ScrobblerService.kt | 5 +- .../settings/HistorySettingsFragment.kt | 32 +++ .../kotatsu/settings/SettingsActivity.kt | 7 + app/src/main/res/drawable/ic_anilist.xml | 10 + app/src/main/res/values/strings.xml | 1 + app/src/main/res/xml/pref_anilist.xml | 19 ++ app/src/main/res/xml/pref_history.xml | 7 + 19 files changed, 709 insertions(+), 4 deletions(-) create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt create mode 100644 app/src/main/res/drawable/ic_anilist.xml create mode 100644 app/src/main/res/xml/pref_anilist.xml diff --git a/app/build.gradle b/app/build.gradle index 3324502f5..a7c55a360 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -29,6 +29,8 @@ android { // define this values in your local.properties file buildConfigField 'String', 'SHIKIMORI_CLIENT_ID', "\"${localProperty('shikimori.clientId')}\"" buildConfigField 'String', 'SHIKIMORI_CLIENT_SECRET', "\"${localProperty('shikimori.clientSecret')}\"" + buildConfigField 'String', 'ANILIST_CLIENT_ID', "\"${localProperty('anilist.clientId')}\"" + buildConfigField 'String', 'ANILIST_CLIENT_SECRET', "\"${localProperty('anilist.clientSecret')}\"" resValue "string", "acra_login", "${localProperty('acra.login')}" resValue "string", "acra_password", "${localProperty('acra.password')}" } diff --git a/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt b/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt index 9b27ccfc2..dd0124f01 100644 --- a/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt +++ b/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt @@ -7,6 +7,7 @@ object CommonHeaders { const val REFERER = "Referer" const val USER_AGENT = "User-Agent" const val ACCEPT = "Accept" + const val CONTENT_TYPE = "Content-Type" const val CONTENT_DISPOSITION = "Content-Disposition" const val COOKIE = "Cookie" const val CONTENT_ENCODING = "Content-Encoding" diff --git a/app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt b/app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt index 6fa3a8803..04ea9092a 100644 --- a/app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt +++ b/app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt @@ -339,6 +339,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) { const val KEY_SUGGESTIONS_EXCLUDE_NSFW = "suggestions_exclude_nsfw" const val KEY_SUGGESTIONS_EXCLUDE_TAGS = "suggestions_exclude_tags" const val KEY_SHIKIMORI = "shikimori" + const val KEY_ANILIST = "anilist" const val KEY_DOWNLOADS_PARALLELISM = "downloads_parallelism" const val KEY_DOWNLOADS_SLOWDOWN = "downloads_slowdown" const val KEY_ALL_FAVOURITES_VISIBLE = "all_favourites_visible" diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt index 0cbd62f4a..9afbf1854 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt @@ -5,15 +5,20 @@ import dagger.Provides import dagger.hilt.InstallIn import dagger.hilt.components.SingletonComponent import dagger.multibindings.ElementsIntoSet -import javax.inject.Singleton import okhttp3.OkHttpClient import org.koitharu.kotatsu.core.db.MangaDatabase +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListAuthenticator +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListInterceptor +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListStorage +import org.koitharu.kotatsu.scrobbling.anilist.domain.AniListScrobbler import org.koitharu.kotatsu.scrobbling.domain.Scrobbler import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriAuthenticator import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriInterceptor import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriStorage import org.koitharu.kotatsu.scrobbling.shikimori.domain.ShikimoriScrobbler +import javax.inject.Singleton @Module @InstallIn(SingletonComponent::class) @@ -33,9 +38,24 @@ object ScrobblingModule { return ShikimoriRepository(okHttp, storage, database) } + @Provides + @Singleton + fun provideAniListRepository( + storage: AniListStorage, + database: MangaDatabase, + authenticator: AniListAuthenticator, + ): AniListRepository { + val okHttp = OkHttpClient.Builder().apply { + authenticator(authenticator) + addInterceptor(AniListInterceptor(storage)) + }.build() + return AniListRepository(okHttp, storage, database) + } + @Provides @ElementsIntoSet fun provideScrobblers( shikimoriScrobbler: ShikimoriScrobbler, - ): Set<@JvmSuppressWildcards Scrobbler> = setOf(shikimoriScrobbler) + aniListScrobbler: AniListScrobbler, + ): Set<@JvmSuppressWildcards Scrobbler> = setOf(shikimoriScrobbler, aniListScrobbler) } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt new file mode 100644 index 000000000..5a32ee6e7 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt @@ -0,0 +1,53 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import kotlinx.coroutines.runBlocking +import okhttp3.Authenticator +import okhttp3.Request +import okhttp3.Response +import okhttp3.Route +import org.koitharu.kotatsu.BuildConfig +import org.koitharu.kotatsu.core.network.CommonHeaders +import javax.inject.Inject +import javax.inject.Provider + +class AniListAuthenticator @Inject constructor( + private val storage: AniListStorage, + private val repositoryProvider: Provider, +) : Authenticator { + + override fun authenticate(route: Route?, response: Response): Request? { + val accessToken = storage.accessToken ?: return null + if (!isRequestWithAccessToken(response)) { + return null + } + synchronized(this) { + val newAccessToken = storage.accessToken ?: return null + if (accessToken != newAccessToken) { + return newRequestWithAccessToken(response.request, newAccessToken) + } + val updatedAccessToken = refreshAccessToken() ?: return null + return newRequestWithAccessToken(response.request, updatedAccessToken) + } + } + + private fun isRequestWithAccessToken(response: Response): Boolean { + val header = response.request.header(CommonHeaders.AUTHORIZATION) + return header?.startsWith("Bearer") == true + } + + private fun newRequestWithAccessToken(request: Request, accessToken: String): Request { + return request.newBuilder() + .header(CommonHeaders.AUTHORIZATION, "Bearer $accessToken") + .build() + } + + private fun refreshAccessToken(): String? = runCatching { + val repository = repositoryProvider.get() + runBlocking { repository.authorize(null) } + return storage.accessToken + }.onFailure { + if (BuildConfig.DEBUG) { + it.printStackTrace() + } + }.getOrNull() +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt new file mode 100644 index 000000000..70f124ee6 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt @@ -0,0 +1,23 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import okhttp3.Interceptor +import okhttp3.Response +import org.koitharu.kotatsu.core.network.CommonHeaders + +private const val JSON = "application/json" + +class AniListInterceptor(private val storage: AniListStorage) : Interceptor { + + override fun intercept(chain: Interceptor.Chain): Response { + val sourceRequest = chain.request() + val request = sourceRequest.newBuilder() + request.header(CommonHeaders.CONTENT_TYPE, JSON) + request.header(CommonHeaders.ACCEPT, JSON) + if (!sourceRequest.url.pathSegments.contains("oauth")) { + storage.accessToken?.let { + request.header(CommonHeaders.AUTHORIZATION, "Bearer $it") + } + } + return chain.proceed(request.build()) + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt new file mode 100644 index 000000000..320fba9a8 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt @@ -0,0 +1,232 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import okhttp3.FormBody +import okhttp3.HttpUrl.Companion.toHttpUrl +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import org.json.JSONObject +import org.koitharu.kotatsu.BuildConfig +import org.koitharu.kotatsu.core.db.MangaDatabase +import org.koitharu.kotatsu.parsers.exception.GraphQLException +import org.koitharu.kotatsu.parsers.model.MangaChapter +import org.koitharu.kotatsu.parsers.util.await +import org.koitharu.kotatsu.parsers.util.json.getStringOrNull +import org.koitharu.kotatsu.parsers.util.json.mapJSON +import org.koitharu.kotatsu.parsers.util.parseJson +import org.koitharu.kotatsu.parsers.util.parseJsonArray +import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl +import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.utils.ext.toRequestBody + +private const val REDIRECT_URI = "kotatsu://anilist-auth" +private const val BASE_URL = "https://anilist.co/api/v2/" +private const val ENDPOINT = "https://graphql.anilist.co" +private const val MANGA_PAGE_SIZE = 10 + +class AniListRepository( + private val okHttp: OkHttpClient, + private val storage: AniListStorage, + private val db: MangaDatabase, +) { + + val oauthUrl: String + get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.ANILIST_CLIENT_ID}&" + + "redirect_uri=${REDIRECT_URI}&response_type=code" + + val isAuthorized: Boolean + get() = storage.accessToken != null + + suspend fun authorize(code: String?) { + val body = FormBody.Builder() + body.add("client_id", BuildConfig.ANILIST_CLIENT_ID) + body.add("client_secret", BuildConfig.ANILIST_CLIENT_SECRET) + if (code != null) { + body.add("grant_type", "authorization_code") + body.add("redirect_uri", REDIRECT_URI) + body.add("code", code) + } else { + body.add("grant_type", "refresh_token") + body.add("refresh_token", checkNotNull(storage.refreshToken)) + } + val request = Request.Builder() + .post(body.build()) + .url("${BASE_URL}oauth/token") + val response = okHttp.newCall(request.build()).await().parseJson() + storage.accessToken = response.getString("access_token") + storage.refreshToken = response.getString("refresh_token") + } + + suspend fun loadUser(): AniListUser { + val response = query( + """ + AniChartUser { + user { + id + name + avatar { + medium + } + } + } + """.trimIndent(), + ) + val jo = response.getJSONObject("data").getJSONObject("AniChartUser").getJSONObject("user") + return AniListUser(jo).also { storage.user = it } + } + + fun getCachedUser(): AniListUser? { + return storage.user + } + + suspend fun unregister(mangaId: Long) { + return db.scrobblingDao.delete(ScrobblerService.SHIKIMORI.id, mangaId) + } + + fun logout() { + storage.clear() + } + + suspend fun findManga(query: String, offset: Int): List { + val page = offset / MANGA_PAGE_SIZE + val pageOffset = offset % MANGA_PAGE_SIZE + val url = BASE_URL.toHttpUrl().newBuilder() + .addPathSegment("api") + .addPathSegment("mangas") + .addEncodedQueryParameter("page", (page + 1).toString()) + .addEncodedQueryParameter("limit", MANGA_PAGE_SIZE.toString()) + .addEncodedQueryParameter("censored", false.toString()) + .addQueryParameter("search", query) + .build() + val request = Request.Builder().url(url).get().build() + val response = okHttp.newCall(request).await().parseJsonArray() + val list = response.mapJSON { ScrobblerManga(it) } + return if (pageOffset != 0) list.drop(pageOffset) else list + } + + suspend fun createRate(mangaId: Long, shikiMangaId: Long) { + val user = getCachedUser() ?: loadUser() + val payload = JSONObject() + payload.put( + "user_rate", + JSONObject().apply { + put("target_id", shikiMangaId) + put("target_type", "Manga") + put("user_id", user.id) + }, + ) + val url = BASE_URL.toHttpUrl().newBuilder() + .addPathSegment("api") + .addPathSegment("v2") + .addPathSegment("user_rates") + .build() + val request = Request.Builder().url(url).post(payload.toRequestBody()).build() + val response = okHttp.newCall(request).await().parseJson() + saveRate(response, mangaId) + } + + suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { + val payload = JSONObject() + payload.put( + "user_rate", + JSONObject().apply { + put("chapters", chapter.number) + }, + ) + val url = BASE_URL.toHttpUrl().newBuilder() + .addPathSegment("api") + .addPathSegment("v2") + .addPathSegment("user_rates") + .addPathSegment(rateId.toString()) + .build() + val request = Request.Builder().url(url).patch(payload.toRequestBody()).build() + val response = okHttp.newCall(request).await().parseJson() + saveRate(response, mangaId) + } + + suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { + val payload = JSONObject() + payload.put( + "user_rate", + JSONObject().apply { + put("score", rating.toString()) + if (comment != null) { + put("text", comment) + } + if (status != null) { + put("status", status) + } + }, + ) + val url = BASE_URL.toHttpUrl().newBuilder() + .addPathSegment("api") + .addPathSegment("v2") + .addPathSegment("user_rates") + .addPathSegment(rateId.toString()) + .build() + val request = Request.Builder().url(url).patch(payload.toRequestBody()).build() + val response = okHttp.newCall(request).await().parseJson() + saveRate(response, mangaId) + } + + suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + val request = Request.Builder() + .get() + .url("${BASE_URL}api/mangas/$id") + val response = okHttp.newCall(request.build()).await().parseJson() + return ScrobblerMangaInfo(response) + } + + private suspend fun saveRate(json: JSONObject, mangaId: Long) { + val entity = ScrobblingEntity( + scrobbler = ScrobblerService.SHIKIMORI.id, + id = json.getInt("id"), + mangaId = mangaId, + targetId = json.getLong("target_id"), + status = json.getString("status"), + chapter = json.getInt("chapters"), + comment = json.getString("text"), + rating = json.getDouble("score").toFloat() / 10f, + ) + db.scrobblingDao.insert(entity) + } + + private fun ScrobblerManga(json: JSONObject) = ScrobblerManga( + id = json.getLong("id"), + name = json.getString("name"), + altName = json.getStringOrNull("russian"), + cover = json.getJSONObject("image").getString("preview").toAbsoluteUrl("shikimori.one"), + url = json.getString("url").toAbsoluteUrl("shikimori.one"), + ) + + private fun ScrobblerMangaInfo(json: JSONObject) = ScrobblerMangaInfo( + id = json.getLong("id"), + name = json.getString("name"), + cover = json.getJSONObject("image").getString("preview").toAbsoluteUrl("shikimori.one"), + url = json.getString("url").toAbsoluteUrl("shikimori.one"), + descriptionHtml = json.getString("description_html"), + ) + + private suspend fun query(query: String): JSONObject { + val body = JSONObject() + body.put("query", "{$query}") + body.put("variables", null) + val mediaType = "application/json; charset=utf-8".toMediaType() + val requestBody = body.toString().toRequestBody(mediaType) + val request = Request.Builder() + .post(requestBody) + .url(ENDPOINT) + val json = okHttp.newCall(request.build()).await().parseJson() + json.optJSONArray("errors")?.let { + if (it.length() != 0) { + throw GraphQLException(it) + } + } + return json + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt new file mode 100644 index 000000000..09c918d08 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt @@ -0,0 +1,40 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import android.content.Context +import androidx.core.content.edit +import dagger.hilt.android.qualifiers.ApplicationContext +import org.json.JSONObject +import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import javax.inject.Inject +import javax.inject.Singleton + +private const val PREF_NAME = "anilist" +private const val KEY_ACCESS_TOKEN = "access_token" +private const val KEY_REFRESH_TOKEN = "refresh_token" +private const val KEY_USER = "user" + +@Singleton +class AniListStorage @Inject constructor(@ApplicationContext context: Context) { + + private val prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE) + + var accessToken: String? + get() = prefs.getString(KEY_ACCESS_TOKEN, null) + set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) } + + var refreshToken: String? + get() = prefs.getString(KEY_REFRESH_TOKEN, null) + set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) } + + var user: AniListUser? + get() = prefs.getString(KEY_USER, null)?.let { + AniListUser(JSONObject(it)) + } + set(value) = prefs.edit { + putString(KEY_USER, value?.toJson()?.toString()) + } + + fun clear() = prefs.edit { + clear() + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt new file mode 100644 index 000000000..24897ee3f --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt @@ -0,0 +1,42 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data.model + +import org.json.JSONObject + +class AniListUser( + val id: Long, + val nickname: String, + val avatar: String, +) { + + constructor(json: JSONObject) : this( + id = json.getLong("id"), + nickname = json.getString("name"), + avatar = json.getJSONObject("avatar").getString("medium"), + ) + + fun toJson() = JSONObject().apply { + put("id", id) + put("name", nickname) + put("avatar", JSONObject().apply { put("medium", avatar) }) + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as AniListUser + + if (id != other.id) return false + if (nickname != other.nickname) return false + if (avatar != other.avatar) return false + + return true + } + + override fun hashCode(): Int { + var result = id.hashCode() + result = 31 * result + nickname.hashCode() + result = 31 * result + avatar.hashCode() + return result + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt new file mode 100644 index 000000000..ebb935c52 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt @@ -0,0 +1,71 @@ +package org.koitharu.kotatsu.scrobbling.anilist.domain + +import org.koitharu.kotatsu.core.db.MangaDatabase +import org.koitharu.kotatsu.parsers.model.MangaChapter +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository +import org.koitharu.kotatsu.scrobbling.domain.Scrobbler +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus +import javax.inject.Inject +import javax.inject.Singleton + +private const val RATING_MAX = 10f + +@Singleton +class AniListScrobbler @Inject constructor( + private val repository: AniListRepository, + db: MangaDatabase, +) : Scrobbler(db, ScrobblerService.ANILIST) { + + init { + statuses[ScrobblingStatus.PLANNED] = "planned" + statuses[ScrobblingStatus.READING] = "watching" + statuses[ScrobblingStatus.RE_READING] = "rewatching" + statuses[ScrobblingStatus.COMPLETED] = "completed" + statuses[ScrobblingStatus.ON_HOLD] = "on_hold" + statuses[ScrobblingStatus.DROPPED] = "dropped" + } + + override val isAvailable: Boolean + get() = repository.isAuthorized + + override suspend fun findManga(query: String, offset: Int): List { + return repository.findManga(query, offset) + } + + override suspend fun linkManga(mangaId: Long, targetId: Long) { + repository.createRate(mangaId, targetId) + } + + override suspend fun scrobble(mangaId: Long, chapter: MangaChapter) { + val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return + repository.updateRate(entity.id, entity.mangaId, chapter) + } + + override suspend fun updateScrobblingInfo( + mangaId: Long, + rating: Float, + status: ScrobblingStatus?, + comment: String?, + ) { + val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) + requireNotNull(entity) { "Scrobbling info for manga $mangaId not found" } + repository.updateRate( + rateId = entity.id, + mangaId = entity.mangaId, + rating = rating * RATING_MAX, + status = statuses[status], + comment = comment, + ) + } + + override suspend fun unregisterScrobbling(mangaId: Long) { + repository.unregister(mangaId) + } + + override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + return repository.getMangaInfo(id) + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt new file mode 100644 index 000000000..a062fddc5 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt @@ -0,0 +1,86 @@ +package org.koitharu.kotatsu.scrobbling.anilist.ui + +import android.content.Intent +import android.net.Uri +import android.os.Bundle +import android.view.View +import androidx.preference.Preference +import coil.ImageLoader +import coil.request.ImageRequest +import coil.transform.CircleCropTransformation +import dagger.hilt.android.AndroidEntryPoint +import org.koitharu.kotatsu.R +import org.koitharu.kotatsu.base.ui.BasePreferenceFragment +import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import org.koitharu.kotatsu.utils.PreferenceIconTarget +import org.koitharu.kotatsu.utils.ext.assistedViewModels +import org.koitharu.kotatsu.utils.ext.enqueueWith +import org.koitharu.kotatsu.utils.ext.withArgs +import javax.inject.Inject + +@AndroidEntryPoint +class AniListSettingsFragment : BasePreferenceFragment(R.string.anilist) { + + @Inject + lateinit var coil: ImageLoader + + @Inject + lateinit var viewModelFactory: AniListSettingsViewModel.Factory + + private val viewModel by assistedViewModels { + viewModelFactory.create(arguments?.getString(ARG_AUTH_CODE)) + } + + override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) { + addPreferencesFromResource(R.xml.pref_anilist) + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + super.onViewCreated(view, savedInstanceState) + viewModel.user.observe(viewLifecycleOwner, this::onUserChanged) + } + + override fun onPreferenceTreeClick(preference: Preference): Boolean { + return when (preference.key) { + KEY_USER -> openAuthorization() + KEY_LOGOUT -> { + viewModel.logout() + true + } + + else -> super.onPreferenceTreeClick(preference) + } + } + + private fun onUserChanged(user: AniListUser?) { + val pref = findPreference(KEY_USER) ?: return + pref.isSelectable = user == null + pref.title = user?.nickname ?: getString(R.string.sign_in) + ImageRequest.Builder(requireContext()) + .data(user?.avatar) + .transformations(CircleCropTransformation()) + .target(PreferenceIconTarget(pref)) + .enqueueWith(coil) + findPreference(KEY_LOGOUT)?.isVisible = user != null + } + + private fun openAuthorization(): Boolean { + return runCatching { + val intent = Intent(Intent.ACTION_VIEW) + intent.data = Uri.parse(viewModel.authorizationUrl) + startActivity(intent) + }.isSuccess + } + + companion object { + + private const val KEY_USER = "al_user" + private const val KEY_LOGOUT = "al_logout" + + private const val ARG_AUTH_CODE = "auth_code" + + fun newInstance(authCode: String?) = AniListSettingsFragment().withArgs(1) { + putString(ARG_AUTH_CODE, authCode) + } + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt new file mode 100644 index 000000000..9bec3f34d --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt @@ -0,0 +1,57 @@ +package org.koitharu.kotatsu.scrobbling.anilist.ui + +import androidx.lifecycle.MutableLiveData +import dagger.assisted.Assisted +import dagger.assisted.AssistedFactory +import dagger.assisted.AssistedInject +import kotlinx.coroutines.Dispatchers +import org.koitharu.kotatsu.base.ui.BaseViewModel +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository +import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser + +class AniListSettingsViewModel @AssistedInject constructor( + private val repository: AniListRepository, + @Assisted authCode: String?, +) : BaseViewModel() { + + val authorizationUrl: String + get() = repository.oauthUrl + + val user = MutableLiveData() + + init { + if (authCode != null) { + authorize(authCode) + } else { + loadUser() + } + } + + fun logout() { + launchJob(Dispatchers.Default) { + repository.logout() + user.postValue(null) + } + } + + private fun loadUser() = launchJob(Dispatchers.Default) { + val userModel = if (repository.isAuthorized) { + repository.getCachedUser()?.let(user::postValue) + repository.loadUser() + } else { + null + } + user.postValue(userModel) + } + + private fun authorize(code: String) = launchJob(Dispatchers.Default) { + repository.authorize(code) + user.postValue(repository.loadUser()) + } + + @AssistedFactory + interface Factory { + + fun create(authCode: String?): AniListSettingsViewModel + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt index 45038ed12..3679b8118 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt @@ -10,5 +10,6 @@ enum class ScrobblerService( @DrawableRes val iconResId: Int, ) { - SHIKIMORI(1, R.string.shikimori, R.drawable.ic_shikimori) -} \ No newline at end of file + SHIKIMORI(1, R.string.shikimori, R.drawable.ic_shikimori), + ANILIST(2, R.string.anilist, R.drawable.ic_anilist), +} diff --git a/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt b/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt index 595d47caa..936aa2028 100644 --- a/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt +++ b/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt @@ -17,6 +17,7 @@ import org.koitharu.kotatsu.core.os.ShortcutsUpdater import org.koitharu.kotatsu.core.prefs.AppSettings import org.koitharu.kotatsu.local.data.CacheDir import org.koitharu.kotatsu.local.data.LocalStorageManager +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository import org.koitharu.kotatsu.search.domain.MangaSearchRepository import org.koitharu.kotatsu.tracker.domain.TrackingRepository @@ -40,6 +41,9 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach @Inject lateinit var shikimoriRepository: ShikimoriRepository + @Inject + lateinit var aniListRepository: AniListRepository + @Inject lateinit var cookieJar: AndroidCookieJar @@ -75,6 +79,7 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach override fun onResume() { super.onResume() bindShikimoriSummary() + bindAniListSummary() } override fun onPreferenceTreeClick(preference: Preference): Boolean { @@ -122,6 +127,15 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach } } + AppSettings.KEY_ANILIST -> { + if (!aniListRepository.isAuthorized) { + launchAniListAuth() + true + } else { + super.onPreferenceTreeClick(preference) + } + } + else -> super.onPreferenceTreeClick(preference) } } @@ -193,6 +207,14 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach } } + private fun bindAniListSummary() { + findPreference(AppSettings.KEY_ANILIST)?.summary = if (aniListRepository.isAuthorized) { + getString(R.string.logged_in_as, aniListRepository.getCachedUser()?.nickname) + } else { + getString(R.string.disabled) + } + } + private fun launchShikimoriAuth() { runCatching { val intent = Intent(Intent.ACTION_VIEW) @@ -202,4 +224,14 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach Snackbar.make(listView, it.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show() } } + + private fun launchAniListAuth() { + runCatching { + val intent = Intent(Intent.ACTION_VIEW) + intent.data = Uri.parse(aniListRepository.oauthUrl) + startActivity(intent) + }.onFailure { + Snackbar.make(listView, it.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show() + } + } } diff --git a/app/src/main/java/org/koitharu/kotatsu/settings/SettingsActivity.kt b/app/src/main/java/org/koitharu/kotatsu/settings/SettingsActivity.kt index f00be0080..e6f8880aa 100644 --- a/app/src/main/java/org/koitharu/kotatsu/settings/SettingsActivity.kt +++ b/app/src/main/java/org/koitharu/kotatsu/settings/SettingsActivity.kt @@ -24,6 +24,7 @@ import org.koitharu.kotatsu.base.ui.util.RecyclerViewOwner import org.koitharu.kotatsu.databinding.ActivitySettingsBinding import org.koitharu.kotatsu.main.ui.owners.AppBarOwner import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.scrobbling.anilist.ui.AniListSettingsFragment import org.koitharu.kotatsu.scrobbling.shikimori.ui.ShikimoriSettingsFragment import org.koitharu.kotatsu.settings.sources.SourcesSettingsFragment import org.koitharu.kotatsu.settings.tracker.TrackerSettingsFragment @@ -78,6 +79,7 @@ class SettingsActivity : startActivity(intent) true } + else -> super.onOptionsItemSelected(item) } @@ -132,6 +134,7 @@ class SettingsActivity : ACTION_SOURCE -> SourceSettingsFragment.newInstance( intent.getSerializableExtra(EXTRA_SOURCE) as? MangaSource ?: MangaSource.LOCAL, ) + ACTION_MANAGE_SOURCES -> SourcesSettingsFragment() else -> SettingsHeadersFragment() } @@ -145,6 +148,9 @@ class SettingsActivity : when (uri?.host) { HOST_SHIKIMORI_AUTH -> return ShikimoriSettingsFragment.newInstance(authCode = uri.getQueryParameter("code")) + + HOST_ANILIST_AUTH -> + return AniListSettingsFragment.newInstance(authCode = uri.getQueryParameter("code")) } finishAfterTransition() return null @@ -162,6 +168,7 @@ class SettingsActivity : private const val EXTRA_SOURCE = "source" private const val HOST_SHIKIMORI_AUTH = "shikimori-auth" + private const val HOST_ANILIST_AUTH = "anilist-auth" fun newIntent(context: Context) = Intent(context, SettingsActivity::class.java) diff --git a/app/src/main/res/drawable/ic_anilist.xml b/app/src/main/res/drawable/ic_anilist.xml new file mode 100644 index 000000000..e9fa65813 --- /dev/null +++ b/app/src/main/res/drawable/ic_anilist.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index b078c48ca..789436f9f 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -273,6 +273,7 @@ Removal completed Download all selected manga and its chapters\? This can consume a lot of traffic and storage. Shikimori + AniList Parallel downloads Download slowdown Helps avoid blocking your IP address diff --git a/app/src/main/res/xml/pref_anilist.xml b/app/src/main/res/xml/pref_anilist.xml new file mode 100644 index 000000000..7cd04cada --- /dev/null +++ b/app/src/main/res/xml/pref_anilist.xml @@ -0,0 +1,19 @@ + + + + + + + + diff --git a/app/src/main/res/xml/pref_history.xml b/app/src/main/res/xml/pref_history.xml index 439694206..0f0549516 100644 --- a/app/src/main/res/xml/pref_history.xml +++ b/app/src/main/res/xml/pref_history.xml @@ -23,9 +23,16 @@ + + -- 2.54.0 From 0c4c7489e911886a95b5685b667212a081d0d800 Mon Sep 17 00:00:00 2001 From: Koitharu Date: Sun, 30 Oct 2022 11:10:38 +0200 Subject: [PATCH 2/3] Unify scrobblers implementation --- .../kotatsu/scrobbling/ScrobblingModule.kt | 25 ++- .../anilist/data/AniListAuthenticator.kt | 5 +- .../anilist/data/AniListInterceptor.kt | 3 +- .../anilist/data/AniListRepository.kt | 161 ++++++++++-------- .../scrobbling/anilist/data/AniListStorage.kt | 40 ----- .../anilist/data/model/AniListUser.kt | 42 ----- .../anilist/domain/AniListScrobbler.kt | 29 +--- .../anilist/ui/AniListSettingsFragment.kt | 4 +- .../anilist/ui/AniListSettingsViewModel.kt | 6 +- .../scrobbling/data/ScrobblerRepository.kt | 33 ++++ .../scrobbling/data/ScrobblerStorage.kt | 54 ++++++ .../kotatsu/scrobbling/domain/Scrobbler.kt | 26 ++- .../scrobbling/domain/model/ScrobblerType.kt | 8 + .../model/ScrobblerUser.kt} | 25 +-- .../shikimori/data/ShikimoriAuthenticator.kt | 9 +- .../shikimori/data/ShikimoriInterceptor.kt | 3 +- .../shikimori/data/ShikimoriRepository.kt | 46 +++-- .../shikimori/data/ShikimoriStorage.kt | 40 ----- .../shikimori/domain/ShikimoriScrobbler.kt | 33 +--- .../shikimori/ui/ShikimoriSettingsFragment.kt | 7 +- .../ui/ShikimoriSettingsViewModel.kt | 6 +- .../settings/HistorySettingsFragment.kt | 4 +- 22 files changed, 296 insertions(+), 313 deletions(-) delete mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt delete mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerRepository.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerType.kt rename app/src/main/java/org/koitharu/kotatsu/scrobbling/{shikimori/data/model/ShikimoriUser.kt => domain/model/ScrobblerUser.kt} (56%) delete mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriStorage.kt diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt index 9afbf1854..87f75e515 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt @@ -1,8 +1,10 @@ package org.koitharu.kotatsu.scrobbling +import android.content.Context import dagger.Module import dagger.Provides import dagger.hilt.InstallIn +import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.components.SingletonComponent import dagger.multibindings.ElementsIntoSet import okhttp3.OkHttpClient @@ -10,13 +12,14 @@ import org.koitharu.kotatsu.core.db.MangaDatabase import org.koitharu.kotatsu.scrobbling.anilist.data.AniListAuthenticator import org.koitharu.kotatsu.scrobbling.anilist.data.AniListInterceptor import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository -import org.koitharu.kotatsu.scrobbling.anilist.data.AniListStorage import org.koitharu.kotatsu.scrobbling.anilist.domain.AniListScrobbler +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage import org.koitharu.kotatsu.scrobbling.domain.Scrobbler +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriAuthenticator import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriInterceptor import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository -import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriStorage import org.koitharu.kotatsu.scrobbling.shikimori.domain.ShikimoriScrobbler import javax.inject.Singleton @@ -27,7 +30,7 @@ object ScrobblingModule { @Provides @Singleton fun provideShikimoriRepository( - storage: ShikimoriStorage, + @ScrobblerType(ScrobblerService.SHIKIMORI) storage: ScrobblerStorage, database: MangaDatabase, authenticator: ShikimoriAuthenticator, ): ShikimoriRepository { @@ -41,7 +44,7 @@ object ScrobblingModule { @Provides @Singleton fun provideAniListRepository( - storage: AniListStorage, + @ScrobblerType(ScrobblerService.ANILIST) storage: ScrobblerStorage, database: MangaDatabase, authenticator: AniListAuthenticator, ): AniListRepository { @@ -52,6 +55,20 @@ object ScrobblingModule { return AniListRepository(okHttp, storage, database) } + @Provides + @Singleton + @ScrobblerType(ScrobblerService.ANILIST) + fun provideAniListStorage( + @ApplicationContext context: Context, + ): ScrobblerStorage = ScrobblerStorage(context, ScrobblerService.ANILIST) + + @Provides + @Singleton + @ScrobblerType(ScrobblerService.SHIKIMORI) + fun provideShikimoriStorage( + @ApplicationContext context: Context, + ): ScrobblerStorage = ScrobblerStorage(context, ScrobblerService.SHIKIMORI) + @Provides @ElementsIntoSet fun provideScrobblers( diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt index 5a32ee6e7..5fb3040d5 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt @@ -7,11 +7,14 @@ import okhttp3.Response import okhttp3.Route import org.koitharu.kotatsu.BuildConfig import org.koitharu.kotatsu.core.network.CommonHeaders +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType import javax.inject.Inject import javax.inject.Provider class AniListAuthenticator @Inject constructor( - private val storage: AniListStorage, + @ScrobblerType(ScrobblerService.ANILIST) private val storage: ScrobblerStorage, private val repositoryProvider: Provider, ) : Authenticator { diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt index 70f124ee6..9812283fb 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt @@ -3,10 +3,11 @@ package org.koitharu.kotatsu.scrobbling.anilist.data import okhttp3.Interceptor import okhttp3.Response import org.koitharu.kotatsu.core.network.CommonHeaders +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage private const val JSON = "application/json" -class AniListInterceptor(private val storage: AniListStorage) : Interceptor { +class AniListInterceptor(private val storage: ScrobblerStorage) : Interceptor { override fun intercept(chain: Interceptor.Chain): Response { val sourceRequest = chain.request() diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt index 320fba9a8..2bff9c655 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt @@ -15,13 +15,13 @@ import org.koitharu.kotatsu.parsers.util.await import org.koitharu.kotatsu.parsers.util.json.getStringOrNull import org.koitharu.kotatsu.parsers.util.json.mapJSON import org.koitharu.kotatsu.parsers.util.parseJson -import org.koitharu.kotatsu.parsers.util.parseJsonArray -import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl -import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser import org.koitharu.kotatsu.utils.ext.toRequestBody private const val REDIRECT_URI = "kotatsu://anilist-auth" @@ -31,18 +31,18 @@ private const val MANGA_PAGE_SIZE = 10 class AniListRepository( private val okHttp: OkHttpClient, - private val storage: AniListStorage, + private val storage: ScrobblerStorage, private val db: MangaDatabase, -) { +) : ScrobblerRepository { - val oauthUrl: String + override val oauthUrl: String get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.ANILIST_CLIENT_ID}&" + "redirect_uri=${REDIRECT_URI}&response_type=code" - val isAuthorized: Boolean + override val isAuthorized: Boolean get() = storage.accessToken != null - suspend fun authorize(code: String?) { + override suspend fun authorize(code: String?) { val body = FormBody.Builder() body.add("client_id", BuildConfig.ANILIST_CLIENT_ID) body.add("client_secret", BuildConfig.ANILIST_CLIENT_SECRET) @@ -62,7 +62,7 @@ class AniListRepository( storage.refreshToken = response.getString("refresh_token") } - suspend fun loadUser(): AniListUser { + override suspend fun loadUser(): ScrobblerUser { val response = query( """ AniChartUser { @@ -80,57 +80,61 @@ class AniListRepository( return AniListUser(jo).also { storage.user = it } } - fun getCachedUser(): AniListUser? { - return storage.user - } + override val cachedUser: ScrobblerUser? + get() { + return storage.user + } - suspend fun unregister(mangaId: Long) { + override suspend fun unregister(mangaId: Long) { return db.scrobblingDao.delete(ScrobblerService.SHIKIMORI.id, mangaId) } - fun logout() { + override fun logout() { storage.clear() } - suspend fun findManga(query: String, offset: Int): List { + override suspend fun findManga(query: String, offset: Int): List { val page = offset / MANGA_PAGE_SIZE - val pageOffset = offset % MANGA_PAGE_SIZE - val url = BASE_URL.toHttpUrl().newBuilder() - .addPathSegment("api") - .addPathSegment("mangas") - .addEncodedQueryParameter("page", (page + 1).toString()) - .addEncodedQueryParameter("limit", MANGA_PAGE_SIZE.toString()) - .addEncodedQueryParameter("censored", false.toString()) - .addQueryParameter("search", query) - .build() - val request = Request.Builder().url(url).get().build() - val response = okHttp.newCall(request).await().parseJsonArray() - val list = response.mapJSON { ScrobblerManga(it) } - return if (pageOffset != 0) list.drop(pageOffset) else list + val response = query( + """ + Page(page: $page, perPage: ${MANGA_PAGE_SIZE}) { + media(type: MANGA, isAdult: true, sort: SEARCH_MATCH, search: "${JSONObject.quote(query)}") { + id + title { + userPreferred + native + } + coverImage { + medium + } + siteUrl + } + } + """.trimIndent(), + ) + val data = response.getJSONObject("data").getJSONObject("Page").getJSONArray("media") + return data.mapJSON { ScrobblerManga(it) } } - suspend fun createRate(mangaId: Long, shikiMangaId: Long) { - val user = getCachedUser() ?: loadUser() - val payload = JSONObject() - payload.put( - "user_rate", - JSONObject().apply { - put("target_id", shikiMangaId) - put("target_type", "Manga") - put("user_id", user.id) - }, + override suspend fun createRate(mangaId: Long, scrobblerMangaId: Long) { + val response = query( + """ + mutation { + SaveMediaListEntry(mediaId: $scrobblerMangaId) { + id + mediaId + status + notes + scoreRaw + progress + } + } + """.trimIndent(), ) - val url = BASE_URL.toHttpUrl().newBuilder() - .addPathSegment("api") - .addPathSegment("v2") - .addPathSegment("user_rates") - .build() - val request = Request.Builder().url(url).post(payload.toRequestBody()).build() - val response = okHttp.newCall(request).await().parseJson() saveRate(response, mangaId) } - suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { + override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { val payload = JSONObject() payload.put( "user_rate", @@ -149,7 +153,7 @@ class AniListRepository( saveRate(response, mangaId) } - suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { + override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { val payload = JSONObject() payload.put( "user_rate", @@ -174,12 +178,23 @@ class AniListRepository( saveRate(response, mangaId) } - suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { - val request = Request.Builder() - .get() - .url("${BASE_URL}api/mangas/$id") - val response = okHttp.newCall(request.build()).await().parseJson() - return ScrobblerMangaInfo(response) + override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + val response = query( + """ + Media(id: $id) { + id + title { + userPreferred + } + coverImage { + large + } + description + siteUrl + } + """.trimIndent(), + ) + return ScrobblerMangaInfo(response.getJSONObject("data").getJSONObject("Media")) } private suspend fun saveRate(json: JSONObject, mangaId: Long) { @@ -187,29 +202,39 @@ class AniListRepository( scrobbler = ScrobblerService.SHIKIMORI.id, id = json.getInt("id"), mangaId = mangaId, - targetId = json.getLong("target_id"), + targetId = json.getLong("mediaId"), status = json.getString("status"), - chapter = json.getInt("chapters"), - comment = json.getString("text"), - rating = json.getDouble("score").toFloat() / 10f, + chapter = json.getInt("progress"), + comment = json.getString("notes"), + rating = json.getDouble("scoreRaw").toFloat() / 100f, ) db.scrobblingDao.insert(entity) } - private fun ScrobblerManga(json: JSONObject) = ScrobblerManga( - id = json.getLong("id"), - name = json.getString("name"), - altName = json.getStringOrNull("russian"), - cover = json.getJSONObject("image").getString("preview").toAbsoluteUrl("shikimori.one"), - url = json.getString("url").toAbsoluteUrl("shikimori.one"), - ) + private fun ScrobblerManga(json: JSONObject): ScrobblerManga { + val title = json.getJSONObject("title") + return ScrobblerManga( + id = json.getLong("id"), + name = title.getString("userPreferred"), + altName = title.getStringOrNull("native"), + cover = json.getJSONObject("coverImage").getString("medium"), + url = json.getString("siteUrl"), + ) + } private fun ScrobblerMangaInfo(json: JSONObject) = ScrobblerMangaInfo( id = json.getLong("id"), - name = json.getString("name"), - cover = json.getJSONObject("image").getString("preview").toAbsoluteUrl("shikimori.one"), - url = json.getString("url").toAbsoluteUrl("shikimori.one"), - descriptionHtml = json.getString("description_html"), + name = json.getJSONObject("title").getString("userPreferred"), + cover = json.getJSONObject("coverImage").getString("large"), + url = json.getString("siteUrl"), + descriptionHtml = json.getString("description"), + ) + + private fun AniListUser(json: JSONObject) = ScrobblerUser( + id = json.getLong("id"), + nickname = json.getString("name"), + avatar = json.getJSONObject("avatar").getString("medium"), + service = ScrobblerService.ANILIST, ) private suspend fun query(query: String): JSONObject { diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt deleted file mode 100644 index 09c918d08..000000000 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListStorage.kt +++ /dev/null @@ -1,40 +0,0 @@ -package org.koitharu.kotatsu.scrobbling.anilist.data - -import android.content.Context -import androidx.core.content.edit -import dagger.hilt.android.qualifiers.ApplicationContext -import org.json.JSONObject -import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser -import javax.inject.Inject -import javax.inject.Singleton - -private const val PREF_NAME = "anilist" -private const val KEY_ACCESS_TOKEN = "access_token" -private const val KEY_REFRESH_TOKEN = "refresh_token" -private const val KEY_USER = "user" - -@Singleton -class AniListStorage @Inject constructor(@ApplicationContext context: Context) { - - private val prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE) - - var accessToken: String? - get() = prefs.getString(KEY_ACCESS_TOKEN, null) - set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) } - - var refreshToken: String? - get() = prefs.getString(KEY_REFRESH_TOKEN, null) - set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) } - - var user: AniListUser? - get() = prefs.getString(KEY_USER, null)?.let { - AniListUser(JSONObject(it)) - } - set(value) = prefs.edit { - putString(KEY_USER, value?.toJson()?.toString()) - } - - fun clear() = prefs.edit { - clear() - } -} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt deleted file mode 100644 index 24897ee3f..000000000 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/model/AniListUser.kt +++ /dev/null @@ -1,42 +0,0 @@ -package org.koitharu.kotatsu.scrobbling.anilist.data.model - -import org.json.JSONObject - -class AniListUser( - val id: Long, - val nickname: String, - val avatar: String, -) { - - constructor(json: JSONObject) : this( - id = json.getLong("id"), - nickname = json.getString("name"), - avatar = json.getJSONObject("avatar").getString("medium"), - ) - - fun toJson() = JSONObject().apply { - put("id", id) - put("name", nickname) - put("avatar", JSONObject().apply { put("medium", avatar) }) - } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as AniListUser - - if (id != other.id) return false - if (nickname != other.nickname) return false - if (avatar != other.avatar) return false - - return true - } - - override fun hashCode(): Int { - var result = id.hashCode() - result = 31 * result + nickname.hashCode() - result = 31 * result + avatar.hashCode() - return result - } -} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt index ebb935c52..4c5da448f 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt @@ -1,11 +1,8 @@ package org.koitharu.kotatsu.scrobbling.anilist.domain import org.koitharu.kotatsu.core.db.MangaDatabase -import org.koitharu.kotatsu.parsers.model.MangaChapter import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository import org.koitharu.kotatsu.scrobbling.domain.Scrobbler -import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga -import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus import javax.inject.Inject @@ -17,7 +14,7 @@ private const val RATING_MAX = 10f class AniListScrobbler @Inject constructor( private val repository: AniListRepository, db: MangaDatabase, -) : Scrobbler(db, ScrobblerService.ANILIST) { +) : Scrobbler(db, ScrobblerService.ANILIST, repository) { init { statuses[ScrobblingStatus.PLANNED] = "planned" @@ -28,22 +25,6 @@ class AniListScrobbler @Inject constructor( statuses[ScrobblingStatus.DROPPED] = "dropped" } - override val isAvailable: Boolean - get() = repository.isAuthorized - - override suspend fun findManga(query: String, offset: Int): List { - return repository.findManga(query, offset) - } - - override suspend fun linkManga(mangaId: Long, targetId: Long) { - repository.createRate(mangaId, targetId) - } - - override suspend fun scrobble(mangaId: Long, chapter: MangaChapter) { - val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return - repository.updateRate(entity.id, entity.mangaId, chapter) - } - override suspend fun updateScrobblingInfo( mangaId: Long, rating: Float, @@ -60,12 +41,4 @@ class AniListScrobbler @Inject constructor( comment = comment, ) } - - override suspend fun unregisterScrobbling(mangaId: Long) { - repository.unregister(mangaId) - } - - override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { - return repository.getMangaInfo(id) - } } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt index a062fddc5..5a98b7a81 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt @@ -11,7 +11,7 @@ import coil.transform.CircleCropTransformation import dagger.hilt.android.AndroidEntryPoint import org.koitharu.kotatsu.R import org.koitharu.kotatsu.base.ui.BasePreferenceFragment -import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser import org.koitharu.kotatsu.utils.PreferenceIconTarget import org.koitharu.kotatsu.utils.ext.assistedViewModels import org.koitharu.kotatsu.utils.ext.enqueueWith @@ -52,7 +52,7 @@ class AniListSettingsFragment : BasePreferenceFragment(R.string.anilist) { } } - private fun onUserChanged(user: AniListUser?) { + private fun onUserChanged(user: ScrobblerUser?) { val pref = findPreference(KEY_USER) ?: return pref.isSelectable = user == null pref.title = user?.nickname ?: getString(R.string.sign_in) diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt index 9bec3f34d..554e5a219 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt @@ -7,7 +7,7 @@ import dagger.assisted.AssistedInject import kotlinx.coroutines.Dispatchers import org.koitharu.kotatsu.base.ui.BaseViewModel import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository -import org.koitharu.kotatsu.scrobbling.anilist.data.model.AniListUser +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser class AniListSettingsViewModel @AssistedInject constructor( private val repository: AniListRepository, @@ -17,7 +17,7 @@ class AniListSettingsViewModel @AssistedInject constructor( val authorizationUrl: String get() = repository.oauthUrl - val user = MutableLiveData() + val user = MutableLiveData() init { if (authCode != null) { @@ -36,7 +36,7 @@ class AniListSettingsViewModel @AssistedInject constructor( private fun loadUser() = launchJob(Dispatchers.Default) { val userModel = if (repository.isAuthorized) { - repository.getCachedUser()?.let(user::postValue) + repository.cachedUser?.let(user::postValue) repository.loadUser() } else { null diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerRepository.kt new file mode 100644 index 000000000..08310ae25 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerRepository.kt @@ -0,0 +1,33 @@ +package org.koitharu.kotatsu.scrobbling.data + +import org.koitharu.kotatsu.parsers.model.MangaChapter +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser + +interface ScrobblerRepository { + + val oauthUrl: String + + val isAuthorized: Boolean + + val cachedUser: ScrobblerUser? + + suspend fun authorize(code: String?) + + suspend fun loadUser(): ScrobblerUser + + fun logout() + + suspend fun unregister(mangaId: Long) + + suspend fun findManga(query: String, offset: Int): List + + suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo + + suspend fun createRate(mangaId: Long, scrobblerMangaId: Long) + + suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) + + suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt new file mode 100644 index 000000000..68b1c4efc --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt @@ -0,0 +1,54 @@ +package org.koitharu.kotatsu.scrobbling.data + +import android.content.Context +import androidx.core.content.edit +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser + +private const val KEY_ACCESS_TOKEN = "access_token" +private const val KEY_REFRESH_TOKEN = "refresh_token" +private const val KEY_USER = "user" + +class ScrobblerStorage(context: Context, service: ScrobblerService) { + + private val prefs = context.getSharedPreferences(service.name, Context.MODE_PRIVATE) + + var accessToken: String? + get() = prefs.getString(KEY_ACCESS_TOKEN, null) + set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) } + + var refreshToken: String? + get() = prefs.getString(KEY_REFRESH_TOKEN, null) + set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) } + + var user: ScrobblerUser? + get() = prefs.getString(KEY_USER, null)?.let { + val lines = it.lines() + if (lines.size != 4) { + return@let null + } + ScrobblerUser( + id = lines[0].toLong(), + nickname = lines[1], + avatar = lines[2], + service = ScrobblerService.valueOf(lines[3]), + ) + } + set(value) = prefs.edit { + if (value == null) { + remove(KEY_USER) + return@edit + } + val str = buildString { + appendLine(value.id) + appendLine(value.nickname) + appendLine(value.avatar) + appendLine(value.service.name) + } + putString(KEY_USER, str) + } + + fun clear() = prefs.edit { + clear() + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/Scrobbler.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/Scrobbler.kt index 1db58e204..54f9ac504 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/Scrobbler.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/Scrobbler.kt @@ -7,6 +7,7 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.map import org.koitharu.kotatsu.core.db.MangaDatabase import org.koitharu.kotatsu.parsers.model.MangaChapter +import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo @@ -21,18 +22,27 @@ import java.util.EnumMap abstract class Scrobbler( protected val db: MangaDatabase, val scrobblerService: ScrobblerService, + private val repository: ScrobblerRepository, ) { private val infoCache = LongSparseArray() protected val statuses = EnumMap(ScrobblingStatus::class.java) - abstract val isAvailable: Boolean + val isAvailable: Boolean + get() = repository.isAuthorized - abstract suspend fun findManga(query: String, offset: Int): List + suspend fun findManga(query: String, offset: Int): List { + return repository.findManga(query, offset) + } - abstract suspend fun linkManga(mangaId: Long, targetId: Long) + suspend fun linkManga(mangaId: Long, targetId: Long) { + repository.createRate(mangaId, targetId) + } - abstract suspend fun scrobble(mangaId: Long, chapter: MangaChapter) + suspend fun scrobble(mangaId: Long, chapter: MangaChapter) { + val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return + repository.updateRate(entity.id, entity.mangaId, chapter) + } suspend fun getScrobblingInfoOrNull(mangaId: Long): ScrobblingInfo? { val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return null @@ -46,9 +56,13 @@ abstract class Scrobbler( .map { it?.toScrobblingInfo(mangaId) } } - abstract suspend fun unregisterScrobbling(mangaId: Long) + suspend fun unregisterScrobbling(mangaId: Long) { + repository.unregister(mangaId) + } - protected abstract suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo + protected suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + return repository.getMangaInfo(id) + } private suspend fun ScrobblingEntity.toScrobblingInfo(mangaId: Long): ScrobblingInfo? { val mangaInfo = infoCache.getOrElse(targetId) { diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerType.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerType.kt new file mode 100644 index 000000000..e2d372edb --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerType.kt @@ -0,0 +1,8 @@ +package org.koitharu.kotatsu.scrobbling.domain.model + +import javax.inject.Qualifier + +@Qualifier +annotation class ScrobblerType( + val service: ScrobblerService +) diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/model/ShikimoriUser.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerUser.kt similarity index 56% rename from app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/model/ShikimoriUser.kt rename to app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerUser.kt index 79ecfa6c5..92ecce0df 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/model/ShikimoriUser.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerUser.kt @@ -1,34 +1,22 @@ -package org.koitharu.kotatsu.scrobbling.shikimori.data.model +package org.koitharu.kotatsu.scrobbling.domain.model -import org.json.JSONObject - -class ShikimoriUser( +class ScrobblerUser( val id: Long, val nickname: String, val avatar: String, + val service: ScrobblerService, ) { - constructor(json: JSONObject) : this( - id = json.getLong("id"), - nickname = json.getString("nickname"), - avatar = json.getString("avatar"), - ) - - fun toJson() = JSONObject().apply { - put("id", id) - put("nickname", nickname) - put("avatar", avatar) - } - override fun equals(other: Any?): Boolean { if (this === other) return true if (javaClass != other?.javaClass) return false - other as ShikimoriUser + other as ScrobblerUser if (id != other.id) return false if (nickname != other.nickname) return false if (avatar != other.avatar) return false + if (service != other.service) return false return true } @@ -37,6 +25,7 @@ class ShikimoriUser( var result = id.hashCode() result = 31 * result + nickname.hashCode() result = 31 * result + avatar.hashCode() + result = 31 * result + service.hashCode() return result } -} \ No newline at end of file +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriAuthenticator.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriAuthenticator.kt index 7b683cf1d..dbaad2cc7 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriAuthenticator.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriAuthenticator.kt @@ -1,7 +1,5 @@ package org.koitharu.kotatsu.scrobbling.shikimori.data -import javax.inject.Inject -import javax.inject.Provider import kotlinx.coroutines.runBlocking import okhttp3.Authenticator import okhttp3.Request @@ -9,9 +7,14 @@ import okhttp3.Response import okhttp3.Route import org.koitharu.kotatsu.BuildConfig import org.koitharu.kotatsu.core.network.CommonHeaders +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType +import javax.inject.Inject +import javax.inject.Provider class ShikimoriAuthenticator @Inject constructor( - private val storage: ShikimoriStorage, + @ScrobblerType(ScrobblerService.SHIKIMORI) private val storage: ScrobblerStorage, private val repositoryProvider: Provider, ) : Authenticator { diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriInterceptor.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriInterceptor.kt index d0be7d23c..466382960 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriInterceptor.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriInterceptor.kt @@ -4,10 +4,11 @@ import okhttp3.Interceptor import okhttp3.Response import okio.IOException import org.koitharu.kotatsu.core.network.CommonHeaders +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage private const val USER_AGENT_SHIKIMORI = "Kotatsu" -class ShikimoriInterceptor(private val storage: ShikimoriStorage) : Interceptor { +class ShikimoriInterceptor(private val storage: ScrobblerStorage) : Interceptor { override fun intercept(chain: Interceptor.Chain): Response { val sourceRequest = chain.request() diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt index 2267994ec..66de790c2 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt @@ -14,11 +14,13 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSON import org.koitharu.kotatsu.parsers.util.parseJson import org.koitharu.kotatsu.parsers.util.parseJsonArray import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl +import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository +import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService -import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser import org.koitharu.kotatsu.utils.ext.toRequestBody private const val REDIRECT_URI = "kotatsu://shikimori-auth" @@ -27,18 +29,18 @@ private const val MANGA_PAGE_SIZE = 10 class ShikimoriRepository( private val okHttp: OkHttpClient, - private val storage: ShikimoriStorage, + private val storage: ScrobblerStorage, private val db: MangaDatabase, -) { +) : ScrobblerRepository { - val oauthUrl: String + override val oauthUrl: String get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.SHIKIMORI_CLIENT_ID}&" + "redirect_uri=$REDIRECT_URI&response_type=code&scope=" - val isAuthorized: Boolean + override val isAuthorized: Boolean get() = storage.accessToken != null - suspend fun authorize(code: String?) { + override suspend fun authorize(code: String?) { val body = FormBody.Builder() body.add("client_id", BuildConfig.SHIKIMORI_CLIENT_ID) body.add("client_secret", BuildConfig.SHIKIMORI_CLIENT_SECRET) @@ -58,7 +60,7 @@ class ShikimoriRepository( storage.refreshToken = response.getString("refresh_token") } - suspend fun loadUser(): ShikimoriUser { + override suspend fun loadUser(): ScrobblerUser { val request = Request.Builder() .get() .url("${BASE_URL}api/users/whoami") @@ -66,19 +68,20 @@ class ShikimoriRepository( return ShikimoriUser(response).also { storage.user = it } } - fun getCachedUser(): ShikimoriUser? { - return storage.user - } + override val cachedUser: ScrobblerUser? + get() { + return storage.user + } - suspend fun unregister(mangaId: Long) { + override suspend fun unregister(mangaId: Long) { return db.scrobblingDao.delete(ScrobblerService.SHIKIMORI.id, mangaId) } - fun logout() { + override fun logout() { storage.clear() } - suspend fun findManga(query: String, offset: Int): List { + override suspend fun findManga(query: String, offset: Int): List { val page = offset / MANGA_PAGE_SIZE val pageOffset = offset % MANGA_PAGE_SIZE val url = BASE_URL.toHttpUrl().newBuilder() @@ -95,8 +98,8 @@ class ShikimoriRepository( return if (pageOffset != 0) list.drop(pageOffset) else list } - suspend fun createRate(mangaId: Long, shikiMangaId: Long) { - val user = getCachedUser() ?: loadUser() + override suspend fun createRate(mangaId: Long, shikiMangaId: Long) { + val user = cachedUser ?: loadUser() val payload = JSONObject() payload.put( "user_rate", @@ -116,7 +119,7 @@ class ShikimoriRepository( saveRate(response, mangaId) } - suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { + override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { val payload = JSONObject() payload.put( "user_rate", @@ -135,7 +138,7 @@ class ShikimoriRepository( saveRate(response, mangaId) } - suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { + override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { val payload = JSONObject() payload.put( "user_rate", @@ -160,7 +163,7 @@ class ShikimoriRepository( saveRate(response, mangaId) } - suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { val request = Request.Builder() .get() .url("${BASE_URL}api/mangas/$id") @@ -197,4 +200,11 @@ class ShikimoriRepository( url = json.getString("url").toAbsoluteUrl("shikimori.one"), descriptionHtml = json.getString("description_html"), ) + + private fun ShikimoriUser(json: JSONObject) = ScrobblerUser( + id = json.getLong("id"), + nickname = json.getString("nickname"), + avatar = json.getString("avatar"), + service = ScrobblerService.SHIKIMORI, + ) } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriStorage.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriStorage.kt deleted file mode 100644 index a3cd84e85..000000000 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriStorage.kt +++ /dev/null @@ -1,40 +0,0 @@ -package org.koitharu.kotatsu.scrobbling.shikimori.data - -import android.content.Context -import androidx.core.content.edit -import dagger.hilt.android.qualifiers.ApplicationContext -import org.json.JSONObject -import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser -import javax.inject.Inject -import javax.inject.Singleton - -private const val PREF_NAME = "shikimori" -private const val KEY_ACCESS_TOKEN = "access_token" -private const val KEY_REFRESH_TOKEN = "refresh_token" -private const val KEY_USER = "user" - -@Singleton -class ShikimoriStorage @Inject constructor(@ApplicationContext context: Context) { - - private val prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE) - - var accessToken: String? - get() = prefs.getString(KEY_ACCESS_TOKEN, null) - set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) } - - var refreshToken: String? - get() = prefs.getString(KEY_REFRESH_TOKEN, null) - set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) } - - var user: ShikimoriUser? - get() = prefs.getString(KEY_USER, null)?.let { - ShikimoriUser(JSONObject(it)) - } - set(value) = prefs.edit { - putString(KEY_USER, value?.toJson()?.toString()) - } - - fun clear() = prefs.edit { - clear() - } -} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/domain/ShikimoriScrobbler.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/domain/ShikimoriScrobbler.kt index bf69e3fa4..5c73c0532 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/domain/ShikimoriScrobbler.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/domain/ShikimoriScrobbler.kt @@ -1,15 +1,12 @@ package org.koitharu.kotatsu.scrobbling.shikimori.domain -import javax.inject.Inject -import javax.inject.Singleton import org.koitharu.kotatsu.core.db.MangaDatabase -import org.koitharu.kotatsu.parsers.model.MangaChapter import org.koitharu.kotatsu.scrobbling.domain.Scrobbler -import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga -import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository +import javax.inject.Inject +import javax.inject.Singleton private const val RATING_MAX = 10f @@ -17,7 +14,7 @@ private const val RATING_MAX = 10f class ShikimoriScrobbler @Inject constructor( private val repository: ShikimoriRepository, db: MangaDatabase, -) : Scrobbler(db, ScrobblerService.SHIKIMORI) { +) : Scrobbler(db, ScrobblerService.SHIKIMORI, repository) { init { statuses[ScrobblingStatus.PLANNED] = "planned" @@ -28,22 +25,6 @@ class ShikimoriScrobbler @Inject constructor( statuses[ScrobblingStatus.DROPPED] = "dropped" } - override val isAvailable: Boolean - get() = repository.isAuthorized - - override suspend fun findManga(query: String, offset: Int): List { - return repository.findManga(query, offset) - } - - override suspend fun linkManga(mangaId: Long, targetId: Long) { - repository.createRate(mangaId, targetId) - } - - override suspend fun scrobble(mangaId: Long, chapter: MangaChapter) { - val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return - repository.updateRate(entity.id, entity.mangaId, chapter) - } - override suspend fun updateScrobblingInfo( mangaId: Long, rating: Float, @@ -60,12 +41,4 @@ class ShikimoriScrobbler @Inject constructor( comment = comment, ) } - - override suspend fun unregisterScrobbling(mangaId: Long) { - repository.unregister(mangaId) - } - - override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { - return repository.getMangaInfo(id) - } } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsFragment.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsFragment.kt index 03fd7d882..da45cf4ed 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsFragment.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsFragment.kt @@ -9,14 +9,14 @@ import coil.ImageLoader import coil.request.ImageRequest import coil.transform.CircleCropTransformation import dagger.hilt.android.AndroidEntryPoint -import javax.inject.Inject import org.koitharu.kotatsu.R import org.koitharu.kotatsu.base.ui.BasePreferenceFragment -import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser import org.koitharu.kotatsu.utils.PreferenceIconTarget import org.koitharu.kotatsu.utils.ext.assistedViewModels import org.koitharu.kotatsu.utils.ext.enqueueWith import org.koitharu.kotatsu.utils.ext.withArgs +import javax.inject.Inject @AndroidEntryPoint class ShikimoriSettingsFragment : BasePreferenceFragment(R.string.shikimori) { @@ -47,11 +47,12 @@ class ShikimoriSettingsFragment : BasePreferenceFragment(R.string.shikimori) { viewModel.logout() true } + else -> super.onPreferenceTreeClick(preference) } } - private fun onUserChanged(user: ShikimoriUser?) { + private fun onUserChanged(user: ScrobblerUser?) { val pref = findPreference(KEY_USER) ?: return pref.isSelectable = user == null pref.title = user?.nickname ?: getString(R.string.sign_in) diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsViewModel.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsViewModel.kt index 091bdcea3..2e689e673 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsViewModel.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsViewModel.kt @@ -6,8 +6,8 @@ import dagger.assisted.AssistedFactory import dagger.assisted.AssistedInject import kotlinx.coroutines.Dispatchers import org.koitharu.kotatsu.base.ui.BaseViewModel +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository -import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser class ShikimoriSettingsViewModel @AssistedInject constructor( private val repository: ShikimoriRepository, @@ -17,7 +17,7 @@ class ShikimoriSettingsViewModel @AssistedInject constructor( val authorizationUrl: String get() = repository.oauthUrl - val user = MutableLiveData() + val user = MutableLiveData() init { if (authCode != null) { @@ -36,7 +36,7 @@ class ShikimoriSettingsViewModel @AssistedInject constructor( private fun loadUser() = launchJob(Dispatchers.Default) { val userModel = if (repository.isAuthorized) { - repository.getCachedUser()?.let(user::postValue) + repository.cachedUser?.let(user::postValue) repository.loadUser() } else { null diff --git a/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt b/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt index 936aa2028..d625be3ea 100644 --- a/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt +++ b/app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt @@ -201,7 +201,7 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach private fun bindShikimoriSummary() { findPreference(AppSettings.KEY_SHIKIMORI)?.summary = if (shikimoriRepository.isAuthorized) { - getString(R.string.logged_in_as, shikimoriRepository.getCachedUser()?.nickname) + getString(R.string.logged_in_as, shikimoriRepository.cachedUser?.nickname) } else { getString(R.string.disabled) } @@ -209,7 +209,7 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach private fun bindAniListSummary() { findPreference(AppSettings.KEY_ANILIST)?.summary = if (aniListRepository.isAuthorized) { - getString(R.string.logged_in_as, aniListRepository.getCachedUser()?.nickname) + getString(R.string.logged_in_as, aniListRepository.cachedUser?.nickname) } else { getString(R.string.disabled) } -- 2.54.0 From 6ca6ec28aca6fb33455758b9ef87a9ee8f852c3b Mon Sep 17 00:00:00 2001 From: Koitharu Date: Sat, 28 Jan 2023 20:35:22 +0200 Subject: [PATCH 3/3] Complete AniList api integration #208 --- .../core/network/CurlLoggingInterceptor.kt | 56 ++++++++ .../org/koitharu/kotatsu/core/AppModule.kt | 3 + .../kotatsu/core/network/CommonHeaders.kt | 1 + .../kotatsu/details/ui/DetailsViewModel.kt | 3 +- .../koitharu/kotatsu/main/ui/MainActivity.kt | 5 +- .../kotatsu/scrobbling/ScrobblingModule.kt | 8 ++ .../anilist/data/AniListRepository.kt | 122 +++++++++--------- .../scrobbling/anilist/data/ScoreFormat.kt | 27 ++++ .../anilist/domain/AniListScrobbler.kt | 16 +-- .../scrobbling/data/ScrobblerStorage.kt | 4 + .../kotatsu/scrobbling/data/ScrobblingDao.kt | 9 +- .../shikimori/data/ShikimoriRepository.kt | 2 +- .../core/network/CurlLoggingInterceptor.kt | 11 ++ 13 files changed, 190 insertions(+), 77 deletions(-) create mode 100644 app/src/debug/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt create mode 100644 app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/ScoreFormat.kt create mode 100644 app/src/release/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt diff --git a/app/src/debug/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt b/app/src/debug/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt new file mode 100644 index 000000000..cc6f6a0a7 --- /dev/null +++ b/app/src/debug/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt @@ -0,0 +1,56 @@ +package org.koitharu.kotatsu.core.network + +import android.util.Log +import okhttp3.Interceptor +import okhttp3.Response +import okio.Buffer +import org.koitharu.kotatsu.core.network.CommonHeaders.ACCEPT_ENCODING + +class CurlLoggingInterceptor( + private val curlOptions: String? = null +) : Interceptor { + + override fun intercept(chain: Interceptor.Chain): Response { + val request = chain.request() + var isCompressed = false + + val curlCmd = StringBuilder() + curlCmd.append("curl") + if (curlOptions != null) { + curlCmd.append(' ').append(curlOptions) + } + curlCmd.append(" -X ").append(request.method) + + for ((name, value) in request.headers) { + if (name.equals(ACCEPT_ENCODING, ignoreCase = true) && value.equals("gzip", ignoreCase = true)) { + isCompressed = true + } + curlCmd.append(" -H \"").append(name).append(": ").append(value.escape()).append('\"') + } + + val body = request.body + if (body != null) { + val buffer = Buffer() + body.writeTo(buffer) + val charset = body.contentType()?.charset() ?: Charsets.UTF_8 + curlCmd.append(" --data-raw '") + .append(buffer.readString(charset).replace("\n", "\\n")) + .append("'") + } + if (isCompressed) { + curlCmd.append(" --compressed") + } + curlCmd.append(" \"").append(request.url).append('"') + + log("---cURL (" + request.url + ")") + log(curlCmd.toString()) + + return chain.proceed(request) + } + + private fun String.escape() = replace("\"", "\\\"") + + private fun log(msg: String) { + Log.d("CURL", msg) + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt b/app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt index 4ee31403a..bf4c98354 100644 --- a/app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt +++ b/app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt @@ -99,6 +99,9 @@ interface AppModule { addInterceptor(GZipInterceptor()) addInterceptor(UserAgentInterceptor()) addInterceptor(CloudFlareInterceptor()) + if (BuildConfig.DEBUG) { + addInterceptor(CurlLoggingInterceptor()) + } }.build() } diff --git a/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt b/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt index dd0124f01..b7608a9c8 100644 --- a/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt +++ b/app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt @@ -11,6 +11,7 @@ object CommonHeaders { const val CONTENT_DISPOSITION = "Content-Disposition" const val COOKIE = "Cookie" const val CONTENT_ENCODING = "Content-Encoding" + const val ACCEPT_ENCODING = "Accept-Encoding" const val AUTHORIZATION = "Authorization" val CACHE_CONTROL_DISABLED: CacheControl diff --git a/app/src/main/java/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt b/app/src/main/java/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt index a47290ad0..d53e12f7a 100644 --- a/app/src/main/java/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt +++ b/app/src/main/java/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt @@ -257,7 +257,8 @@ class DetailsViewModel @AssistedInject constructor( } fun updateScrobbling(rating: Float, status: ScrobblingStatus?) { - for (scrobbler in scrobblers) { + for (info in scrobblingInfo.value ?: return) { + val scrobbler = scrobblers.first { it.scrobblerService == info.scrobbler } if (!scrobbler.isAvailable) continue launchJob(Dispatchers.Default) { scrobbler.updateScrobblingInfo( diff --git a/app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt b/app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt index b3552e6f5..06160ea3b 100644 --- a/app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt +++ b/app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt @@ -117,12 +117,13 @@ class MainActivity : binding.navRail?.headerView?.setOnClickListener(this) binding.searchView.isVoiceSearchEnabled = voiceInputLauncher.resolve(this, null) != null - onBackPressedDispatcher.addCallback(navigationDelegate) - onBackPressedDispatcher.addCallback(ExitCallback(this, binding.container)) navigationDelegate = MainNavigationDelegate(checkNotNull(bottomNav ?: binding.navRail), supportFragmentManager) navigationDelegate.addOnFragmentChangedListener(this) navigationDelegate.onCreate(savedInstanceState) + onBackPressedDispatcher.addCallback(navigationDelegate) + onBackPressedDispatcher.addCallback(ExitCallback(this, binding.container)) + if (savedInstanceState == null) { onFirstStart() } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt index 87f75e515..2aaec408c 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt @@ -8,7 +8,9 @@ import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.components.SingletonComponent import dagger.multibindings.ElementsIntoSet import okhttp3.OkHttpClient +import org.koitharu.kotatsu.BuildConfig import org.koitharu.kotatsu.core.db.MangaDatabase +import org.koitharu.kotatsu.core.network.CurlLoggingInterceptor import org.koitharu.kotatsu.scrobbling.anilist.data.AniListAuthenticator import org.koitharu.kotatsu.scrobbling.anilist.data.AniListInterceptor import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository @@ -37,6 +39,9 @@ object ScrobblingModule { val okHttp = OkHttpClient.Builder().apply { authenticator(authenticator) addInterceptor(ShikimoriInterceptor(storage)) + if (BuildConfig.DEBUG) { + addInterceptor(CurlLoggingInterceptor()) + } }.build() return ShikimoriRepository(okHttp, storage, database) } @@ -51,6 +56,9 @@ object ScrobblingModule { val okHttp = OkHttpClient.Builder().apply { authenticator(authenticator) addInterceptor(AniListInterceptor(storage)) + if (BuildConfig.DEBUG) { + addInterceptor(CurlLoggingInterceptor()) + } }.build() return AniListRepository(okHttp, storage, database) } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt index 2bff9c655..b1a12c51c 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt @@ -1,7 +1,6 @@ package org.koitharu.kotatsu.scrobbling.anilist.data import okhttp3.FormBody -import okhttp3.HttpUrl.Companion.toHttpUrl import okhttp3.MediaType.Companion.toMediaType import okhttp3.OkHttpClient import okhttp3.Request @@ -15,6 +14,7 @@ import org.koitharu.kotatsu.parsers.util.await import org.koitharu.kotatsu.parsers.util.json.getStringOrNull import org.koitharu.kotatsu.parsers.util.json.mapJSON import org.koitharu.kotatsu.parsers.util.parseJson +import org.koitharu.kotatsu.parsers.util.toIntUp import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity @@ -22,12 +22,15 @@ import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser -import org.koitharu.kotatsu.utils.ext.toRequestBody +import kotlin.math.roundToInt private const val REDIRECT_URI = "kotatsu://anilist-auth" private const val BASE_URL = "https://anilist.co/api/v2/" private const val ENDPOINT = "https://graphql.anilist.co" private const val MANGA_PAGE_SIZE = 10 +private const val REQUEST_QUERY = "query" +private const val REQUEST_MUTATION = "mutation" +private const val KEY_SCORE_FORMAT = "score_format" class AniListRepository( private val okHttp: OkHttpClient, @@ -42,6 +45,8 @@ class AniListRepository( override val isAuthorized: Boolean get() = storage.accessToken != null + private val shrinkRegex = Regex("\\t+") + override suspend fun authorize(code: String?) { val body = FormBody.Builder() body.add("client_id", BuildConfig.ANILIST_CLIENT_ID) @@ -63,7 +68,8 @@ class AniListRepository( } override suspend fun loadUser(): ScrobblerUser { - val response = query( + val response = doRequest( + REQUEST_QUERY, """ AniChartUser { user { @@ -72,11 +78,15 @@ class AniListRepository( avatar { medium } + mediaListOptions { + scoreFormat + } } } - """.trimIndent(), + """, ) val jo = response.getJSONObject("data").getJSONObject("AniChartUser").getJSONObject("user") + storage[KEY_SCORE_FORMAT] = jo.getJSONObject("mediaListOptions").getString("scoreFormat") return AniListUser(jo).also { storage.user = it } } @@ -86,7 +96,7 @@ class AniListRepository( } override suspend fun unregister(mangaId: Long) { - return db.scrobblingDao.delete(ScrobblerService.SHIKIMORI.id, mangaId) + return db.scrobblingDao.delete(ScrobblerService.ANILIST.id, mangaId) } override fun logout() { @@ -94,11 +104,12 @@ class AniListRepository( } override suspend fun findManga(query: String, offset: Int): List { - val page = offset / MANGA_PAGE_SIZE - val response = query( + val page = (offset / MANGA_PAGE_SIZE.toFloat()).toIntUp() + 1 + val response = doRequest( + REQUEST_QUERY, """ Page(page: $page, perPage: ${MANGA_PAGE_SIZE}) { - media(type: MANGA, isAdult: true, sort: SEARCH_MATCH, search: "${JSONObject.quote(query)}") { + media(type: MANGA, sort: SEARCH_MATCH, search: ${JSONObject.quote(query)}) { id title { userPreferred @@ -110,76 +121,69 @@ class AniListRepository( siteUrl } } - """.trimIndent(), + """, ) val data = response.getJSONObject("data").getJSONObject("Page").getJSONArray("media") return data.mapJSON { ScrobblerManga(it) } } override suspend fun createRate(mangaId: Long, scrobblerMangaId: Long) { - val response = query( + val response = doRequest( + REQUEST_MUTATION, """ - mutation { SaveMediaListEntry(mediaId: $scrobblerMangaId) { id mediaId status notes - scoreRaw + score progress } - } - """.trimIndent(), + """, ) - saveRate(response, mangaId) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) } override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { - val payload = JSONObject() - payload.put( - "user_rate", - JSONObject().apply { - put("chapters", chapter.number) - }, + val response = doRequest( + REQUEST_MUTATION, + """ + SaveMediaListEntry(id: $rateId, progress: ${chapter.number}) { + id + mediaId + status + notes + score + progress + } + """, ) - val url = BASE_URL.toHttpUrl().newBuilder() - .addPathSegment("api") - .addPathSegment("v2") - .addPathSegment("user_rates") - .addPathSegment(rateId.toString()) - .build() - val request = Request.Builder().url(url).patch(payload.toRequestBody()).build() - val response = okHttp.newCall(request).await().parseJson() - saveRate(response, mangaId) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) } override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { - val payload = JSONObject() - payload.put( - "user_rate", - JSONObject().apply { - put("score", rating.toString()) - if (comment != null) { - put("text", comment) + val scoreRaw = (rating * 100f).roundToInt() + val statusString = status?.let { ", status: $it" }.orEmpty() + val notesString = comment?.let { ", notes: ${JSONObject.quote(it)}" }.orEmpty() + val response = doRequest( + REQUEST_MUTATION, + """ + SaveMediaListEntry(id: $rateId, scoreRaw: $scoreRaw$statusString$notesString) { + id + mediaId + status + notes + score + progress } - if (status != null) { - put("status", status) - } - }, + """, ) - val url = BASE_URL.toHttpUrl().newBuilder() - .addPathSegment("api") - .addPathSegment("v2") - .addPathSegment("user_rates") - .addPathSegment(rateId.toString()) - .build() - val request = Request.Builder().url(url).patch(payload.toRequestBody()).build() - val response = okHttp.newCall(request).await().parseJson() - saveRate(response, mangaId) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) } override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { - val response = query( + val response = doRequest( + REQUEST_QUERY, """ Media(id: $id) { id @@ -192,23 +196,24 @@ class AniListRepository( description siteUrl } - """.trimIndent(), + """, ) return ScrobblerMangaInfo(response.getJSONObject("data").getJSONObject("Media")) } private suspend fun saveRate(json: JSONObject, mangaId: Long) { + val scoreFormat = ScoreFormat.of(storage[KEY_SCORE_FORMAT]) val entity = ScrobblingEntity( - scrobbler = ScrobblerService.SHIKIMORI.id, + scrobbler = ScrobblerService.ANILIST.id, id = json.getInt("id"), mangaId = mangaId, targetId = json.getLong("mediaId"), status = json.getString("status"), chapter = json.getInt("progress"), comment = json.getString("notes"), - rating = json.getDouble("scoreRaw").toFloat() / 100f, + rating = scoreFormat.normalize(json.getDouble("score").toFloat()), ) - db.scrobblingDao.insert(entity) + db.scrobblingDao.upsert(entity) } private fun ScrobblerManga(json: JSONObject): ScrobblerManga { @@ -237,10 +242,9 @@ class AniListRepository( service = ScrobblerService.ANILIST, ) - private suspend fun query(query: String): JSONObject { + private suspend fun doRequest(type: String, payload: String): JSONObject { val body = JSONObject() - body.put("query", "{$query}") - body.put("variables", null) + body.put("query", "$type { ${payload.shrink()} }") val mediaType = "application/json; charset=utf-8".toMediaType() val requestBody = body.toString().toRequestBody(mediaType) val request = Request.Builder() @@ -254,4 +258,6 @@ class AniListRepository( } return json } + + private fun String.shrink() = replace(shrinkRegex, " ") } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/ScoreFormat.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/ScoreFormat.kt new file mode 100644 index 000000000..2683d01b4 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/ScoreFormat.kt @@ -0,0 +1,27 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import org.koitharu.kotatsu.utils.ext.printStackTraceDebug + +enum class ScoreFormat { + + POINT_100, POINT_10_DECIMAL, POINT_10, POINT_5, POINT_3; + + fun normalize(score: Float): Float = when (this) { + POINT_100 -> score / 100f + POINT_10_DECIMAL, + POINT_10 -> score / 10f + + POINT_5 -> score / 5f + POINT_3 -> score / 3f + } + + companion object { + + fun of(rawValue: String?): ScoreFormat { + rawValue ?: return POINT_10_DECIMAL + return runCatching { valueOf(rawValue) } + .onFailure { it.printStackTraceDebug() } + .getOrDefault(POINT_10_DECIMAL) + } + } +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt index 4c5da448f..967a0dc3b 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt @@ -8,8 +8,6 @@ import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus import javax.inject.Inject import javax.inject.Singleton -private const val RATING_MAX = 10f - @Singleton class AniListScrobbler @Inject constructor( private val repository: AniListRepository, @@ -17,12 +15,12 @@ class AniListScrobbler @Inject constructor( ) : Scrobbler(db, ScrobblerService.ANILIST, repository) { init { - statuses[ScrobblingStatus.PLANNED] = "planned" - statuses[ScrobblingStatus.READING] = "watching" - statuses[ScrobblingStatus.RE_READING] = "rewatching" - statuses[ScrobblingStatus.COMPLETED] = "completed" - statuses[ScrobblingStatus.ON_HOLD] = "on_hold" - statuses[ScrobblingStatus.DROPPED] = "dropped" + statuses[ScrobblingStatus.PLANNED] = "PLANNING" + statuses[ScrobblingStatus.READING] = "CURRENT" + statuses[ScrobblingStatus.RE_READING] = "REPEATING" + statuses[ScrobblingStatus.COMPLETED] = "COMPLETED" + statuses[ScrobblingStatus.ON_HOLD] = "PAUSED" + statuses[ScrobblingStatus.DROPPED] = "DROPPED" } override suspend fun updateScrobblingInfo( @@ -36,7 +34,7 @@ class AniListScrobbler @Inject constructor( repository.updateRate( rateId = entity.id, mangaId = entity.mangaId, - rating = rating * RATING_MAX, + rating = rating, status = statuses[status], comment = comment, ) diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt index 68b1c4efc..953f6eec9 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt @@ -48,6 +48,10 @@ class ScrobblerStorage(context: Context, service: ScrobblerService) { putString(KEY_USER, str) } + operator fun get(key: String): String? = prefs.getString(key, null) + + operator fun set(key: String, value: String?) = prefs.edit { putString(key, value) } + fun clear() = prefs.edit { clear() } diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblingDao.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblingDao.kt index 72cf83031..812393dee 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblingDao.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblingDao.kt @@ -12,12 +12,9 @@ abstract class ScrobblingDao { @Query("SELECT * FROM scrobblings WHERE scrobbler = :scrobbler AND manga_id = :mangaId") abstract fun observe(scrobbler: Int, mangaId: Long): Flow - @Insert(onConflict = OnConflictStrategy.REPLACE) - abstract suspend fun insert(entity: ScrobblingEntity) - - @Update - abstract suspend fun update(entity: ScrobblingEntity) + @Upsert + abstract suspend fun upsert(entity: ScrobblingEntity) @Query("DELETE FROM scrobblings WHERE scrobbler = :scrobbler AND manga_id = :mangaId") abstract suspend fun delete(scrobbler: Int, mangaId: Long) -} \ No newline at end of file +} diff --git a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt index 66de790c2..5b86c937b 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt @@ -182,7 +182,7 @@ class ShikimoriRepository( comment = json.getString("text"), rating = json.getDouble("score").toFloat() / 10f, ) - db.scrobblingDao.insert(entity) + db.scrobblingDao.upsert(entity) } private fun ScrobblerManga(json: JSONObject) = ScrobblerManga( diff --git a/app/src/release/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt b/app/src/release/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt new file mode 100644 index 000000000..28441f840 --- /dev/null +++ b/app/src/release/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt @@ -0,0 +1,11 @@ +package org.koitharu.kotatsu.core.network + +import okhttp3.Interceptor +import okhttp3.Response + +class CurlLoggingInterceptor : Interceptor { + + override fun intercept(chain: Interceptor.Chain): Response { + return chain.proceed(chain.request()) // no-op implementation + } +} -- 2.54.0