diff --git a/app/build.gradle b/app/build.gradle index be46b5daa..565dbcbc9 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/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 9b27ccfc2..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 @@ -7,9 +7,11 @@ 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" + 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/core/prefs/AppSettings.kt b/app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt index 132080b34..234339a8c 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 @@ -358,6 +358,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/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 0cbd62f4a..2aaec408c 100644 --- a/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt @@ -1,19 +1,29 @@ 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 javax.inject.Singleton 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 +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 @Module @InstallIn(SingletonComponent::class) @@ -22,20 +32,55 @@ object ScrobblingModule { @Provides @Singleton fun provideShikimoriRepository( - storage: ShikimoriStorage, + @ScrobblerType(ScrobblerService.SHIKIMORI) storage: ScrobblerStorage, database: MangaDatabase, authenticator: ShikimoriAuthenticator, ): ShikimoriRepository { val okHttp = OkHttpClient.Builder().apply { authenticator(authenticator) addInterceptor(ShikimoriInterceptor(storage)) + if (BuildConfig.DEBUG) { + addInterceptor(CurlLoggingInterceptor()) + } }.build() return ShikimoriRepository(okHttp, storage, database) } + @Provides + @Singleton + fun provideAniListRepository( + @ScrobblerType(ScrobblerService.ANILIST) storage: ScrobblerStorage, + database: MangaDatabase, + authenticator: AniListAuthenticator, + ): AniListRepository { + val okHttp = OkHttpClient.Builder().apply { + authenticator(authenticator) + addInterceptor(AniListInterceptor(storage)) + if (BuildConfig.DEBUG) { + addInterceptor(CurlLoggingInterceptor()) + } + }.build() + 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( 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..5fb3040d5 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt @@ -0,0 +1,56 @@ +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 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( + @ScrobblerType(ScrobblerService.ANILIST) private val storage: ScrobblerStorage, + 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..9812283fb --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt @@ -0,0 +1,24 @@ +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: ScrobblerStorage) : 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..b1a12c51c --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt @@ -0,0 +1,263 @@ +package org.koitharu.kotatsu.scrobbling.anilist.data + +import okhttp3.FormBody +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.toIntUp +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 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, + private val storage: ScrobblerStorage, + private val db: MangaDatabase, +) : ScrobblerRepository { + + override val oauthUrl: String + get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.ANILIST_CLIENT_ID}&" + + "redirect_uri=${REDIRECT_URI}&response_type=code" + + 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) + 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") + } + + override suspend fun loadUser(): ScrobblerUser { + val response = doRequest( + REQUEST_QUERY, + """ + AniChartUser { + user { + id + name + avatar { + medium + } + mediaListOptions { + scoreFormat + } + } + } + """, + ) + 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 } + } + + override val cachedUser: ScrobblerUser? + get() { + return storage.user + } + + override suspend fun unregister(mangaId: Long) { + return db.scrobblingDao.delete(ScrobblerService.ANILIST.id, mangaId) + } + + override fun logout() { + storage.clear() + } + + override suspend fun findManga(query: String, offset: Int): List { + val page = (offset / MANGA_PAGE_SIZE.toFloat()).toIntUp() + 1 + val response = doRequest( + REQUEST_QUERY, + """ + Page(page: $page, perPage: ${MANGA_PAGE_SIZE}) { + media(type: MANGA, sort: SEARCH_MATCH, search: ${JSONObject.quote(query)}) { + id + title { + userPreferred + native + } + coverImage { + medium + } + siteUrl + } + } + """, + ) + val data = response.getJSONObject("data").getJSONObject("Page").getJSONArray("media") + return data.mapJSON { ScrobblerManga(it) } + } + + override suspend fun createRate(mangaId: Long, scrobblerMangaId: Long) { + val response = doRequest( + REQUEST_MUTATION, + """ + SaveMediaListEntry(mediaId: $scrobblerMangaId) { + id + mediaId + status + notes + score + progress + } + """, + ) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) + } + + override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) { + val response = doRequest( + REQUEST_MUTATION, + """ + SaveMediaListEntry(id: $rateId, progress: ${chapter.number}) { + id + mediaId + status + notes + score + progress + } + """, + ) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) + } + + override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) { + 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 + } + """, + ) + saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId) + } + + override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo { + val response = doRequest( + REQUEST_QUERY, + """ + Media(id: $id) { + id + title { + userPreferred + } + coverImage { + large + } + description + siteUrl + } + """, + ) + 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.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 = scoreFormat.normalize(json.getDouble("score").toFloat()), + ) + db.scrobblingDao.upsert(entity) + } + + 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.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 doRequest(type: String, payload: String): JSONObject { + val body = JSONObject() + body.put("query", "$type { ${payload.shrink()} }") + 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 + } + + 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 new file mode 100644 index 000000000..967a0dc3b --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt @@ -0,0 +1,42 @@ +package org.koitharu.kotatsu.scrobbling.anilist.domain + +import org.koitharu.kotatsu.core.db.MangaDatabase +import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository +import org.koitharu.kotatsu.scrobbling.domain.Scrobbler +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService +import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class AniListScrobbler @Inject constructor( + private val repository: AniListRepository, + db: MangaDatabase, +) : Scrobbler(db, ScrobblerService.ANILIST, repository) { + + init { + 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( + 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, + status = statuses[status], + comment = comment, + ) + } +} 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..5a98b7a81 --- /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.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 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: ScrobblerUser?) { + 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..554e5a219 --- /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.domain.model.ScrobblerUser + +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.cachedUser?.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/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..953f6eec9 --- /dev/null +++ b/app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt @@ -0,0 +1,58 @@ +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) + } + + 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/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/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/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..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 @@ -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") @@ -179,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( @@ -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 a51e26271..87c02453b 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: MutableCookieJar @@ -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) } } @@ -187,7 +201,15 @@ 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) + } + } + + private fun bindAniListSummary() { + findPreference(AppSettings.KEY_ANILIST)?.summary = if (aniListRepository.isAuthorized) { + getString(R.string.logged_in_as, aniListRepository.cachedUser?.nickname) } else { getString(R.string.disabled) } @@ -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 c648d9626..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 @@ -147,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 @@ -164,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 930c4f268..6c2fd2a42 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 @@ + + 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 + } +}