383 lines
13 KiB
Kotlin
383 lines
13 KiB
Kotlin
package xyz.quaver.pupil.ui
|
|
|
|
import android.content.Intent
|
|
import android.graphics.drawable.Animatable
|
|
import android.graphics.drawable.Drawable
|
|
import android.os.Bundle
|
|
import android.view.*
|
|
import androidx.appcompat.app.AlertDialog
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.preference.PreferenceManager
|
|
import androidx.recyclerview.widget.LinearLayoutManager
|
|
import androidx.recyclerview.widget.PagerSnapHelper
|
|
import androidx.recyclerview.widget.RecyclerView
|
|
import androidx.vectordrawable.graphics.drawable.Animatable2Compat
|
|
import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat
|
|
import com.crashlytics.android.Crashlytics
|
|
import com.google.android.material.snackbar.Snackbar
|
|
import kotlinx.android.synthetic.main.activity_reader.*
|
|
import kotlinx.android.synthetic.main.activity_reader.view.*
|
|
import kotlinx.android.synthetic.main.dialog_numberpicker.view.*
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.coroutines.runBlocking
|
|
import kotlinx.io.IOException
|
|
import kotlinx.serialization.ImplicitReflectionSerializer
|
|
import kotlinx.serialization.json.Json
|
|
import kotlinx.serialization.json.JsonConfiguration
|
|
import xyz.quaver.hitomi.GalleryBlock
|
|
import xyz.quaver.hitomi.getGalleryBlock
|
|
import xyz.quaver.pupil.R
|
|
import xyz.quaver.pupil.adapters.ReaderAdapter
|
|
import xyz.quaver.pupil.util.GalleryDownloader
|
|
import xyz.quaver.pupil.util.Histories
|
|
import xyz.quaver.pupil.util.ItemClickSupport
|
|
|
|
class ReaderActivity : AppCompatActivity() {
|
|
|
|
private val images = ArrayList<String>()
|
|
private lateinit var galleryBlock: GalleryBlock
|
|
private var gallerySize = 0
|
|
private var currentPage = 0
|
|
|
|
private var isScroll = true
|
|
private var isFullscreen = false
|
|
set(value) {
|
|
field = value
|
|
|
|
reader_progressbar.visibility = when {
|
|
value -> View.VISIBLE
|
|
else -> View.GONE
|
|
}
|
|
}
|
|
|
|
private lateinit var downloader: GalleryDownloader
|
|
|
|
private val snapHelper = PagerSnapHelper()
|
|
|
|
private var menu: Menu? = null
|
|
|
|
private lateinit var favorites: Histories
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
|
|
favorites = (application as Pupil).favorites
|
|
|
|
window.setFlags(
|
|
WindowManager.LayoutParams.FLAG_SECURE,
|
|
WindowManager.LayoutParams.FLAG_SECURE)
|
|
|
|
setContentView(R.layout.activity_reader)
|
|
|
|
handleIntent(intent)
|
|
|
|
Crashlytics.setInt("GalleryID", galleryBlock.id)
|
|
|
|
if (!::galleryBlock.isInitialized) {
|
|
onBackPressed()
|
|
return
|
|
}
|
|
|
|
supportActionBar?.title = galleryBlock.title
|
|
supportActionBar?.setDisplayHomeAsUpEnabled(false)
|
|
|
|
initDownloader()
|
|
|
|
initView()
|
|
|
|
if (!downloader.download)
|
|
downloader.start()
|
|
}
|
|
|
|
override fun onNewIntent(intent: Intent) {
|
|
super.onNewIntent(intent)
|
|
handleIntent(intent)
|
|
}
|
|
|
|
private fun handleIntent(intent: Intent) {
|
|
if (intent.action == Intent.ACTION_VIEW) {
|
|
val uri = intent.data
|
|
val lastPathSegment = uri?.lastPathSegment
|
|
if (uri != null && lastPathSegment != null) {
|
|
val nonNumber = Regex("[^-?0-9]+")
|
|
|
|
val galleryID = when (uri.host) {
|
|
"hitomi.la" -> lastPathSegment.replace(nonNumber, "").toInt()
|
|
"히요비.asia" -> lastPathSegment.toInt()
|
|
"xn--9w3b15m8vo.asia" -> lastPathSegment.toInt()
|
|
"e-hentai.org" -> uri.pathSegments[1].toInt()
|
|
else -> return
|
|
}
|
|
|
|
runBlocking {
|
|
CoroutineScope(Dispatchers.IO).launch {
|
|
galleryBlock = getGalleryBlock(galleryID) ?: return@launch
|
|
}.join()
|
|
}
|
|
}
|
|
} else {
|
|
galleryBlock = Json(JsonConfiguration.Stable).parse(
|
|
GalleryBlock.serializer(),
|
|
intent.getStringExtra("galleryblock")!!
|
|
)
|
|
}
|
|
}
|
|
|
|
override fun onResume() {
|
|
val preferences = PreferenceManager.getDefaultSharedPreferences(this)
|
|
|
|
if (preferences.getBoolean("security_mode", false))
|
|
window.setFlags(
|
|
WindowManager.LayoutParams.FLAG_SECURE,
|
|
WindowManager.LayoutParams.FLAG_SECURE)
|
|
else
|
|
window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
|
|
|
|
super.onResume()
|
|
}
|
|
|
|
@UseExperimental(ImplicitReflectionSerializer::class)
|
|
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
|
|
menuInflater.inflate(R.menu.reader, menu)
|
|
|
|
with(menu?.findItem(R.id.reader_menu_favorite)) {
|
|
this ?: return@with
|
|
|
|
if (favorites.contains(galleryBlock.id))
|
|
(icon as Animatable).start()
|
|
}
|
|
|
|
this.menu = menu
|
|
return true
|
|
}
|
|
|
|
override fun onOptionsItemSelected(item: MenuItem?): Boolean {
|
|
when(item?.itemId) {
|
|
R.id.reader_menu_page_indicator -> {
|
|
val view = LayoutInflater.from(this).inflate(R.layout.dialog_numberpicker, findViewById(android.R.id.content), false)
|
|
with(view.dialog_number_picker) {
|
|
minValue=1
|
|
maxValue=gallerySize
|
|
value=currentPage
|
|
}
|
|
val dialog = AlertDialog.Builder(this).apply {
|
|
setView(view)
|
|
}.create()
|
|
view.dialog_ok.setOnClickListener {
|
|
(reader_recyclerview.layoutManager as LinearLayoutManager?)?.scrollToPositionWithOffset(view.dialog_number_picker.value-1, 0)
|
|
dialog.dismiss()
|
|
}
|
|
|
|
dialog.show()
|
|
}
|
|
R.id.reader_menu_favorite -> {
|
|
val id = galleryBlock.id
|
|
val favorite = menu?.findItem(R.id.reader_menu_favorite) ?: return true
|
|
|
|
if (favorites.contains(id)) {
|
|
favorites.remove(id)
|
|
favorite.icon = AnimatedVectorDrawableCompat.create(this, R.drawable.avd_star)
|
|
} else {
|
|
favorites.add(id)
|
|
(favorite.icon as Animatable).start()
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
super.onDestroy()
|
|
|
|
if (::downloader.isInitialized && !downloader.download)
|
|
downloader.cancel()
|
|
}
|
|
|
|
override fun onBackPressed() {
|
|
if (isScroll and !isFullscreen)
|
|
super.onBackPressed()
|
|
|
|
if (isFullscreen) {
|
|
isFullscreen = false
|
|
fullscreen(false)
|
|
}
|
|
|
|
if (!isScroll) {
|
|
isScroll = true
|
|
scrollMode(true)
|
|
}
|
|
}
|
|
|
|
private fun initDownloader() {
|
|
var d: GalleryDownloader? = GalleryDownloader.get(galleryBlock.id)
|
|
|
|
if (d == null) {
|
|
try {
|
|
d = GalleryDownloader(this, galleryBlock)
|
|
} catch (e: IOException) {
|
|
Snackbar.make(reader_layout, R.string.unable_to_connect, Snackbar.LENGTH_LONG).show()
|
|
finish()
|
|
return
|
|
}
|
|
}
|
|
|
|
downloader = d.apply {
|
|
onReaderLoadedHandler = {
|
|
CoroutineScope(Dispatchers.Main).launch {
|
|
with(reader_download_progressbar) {
|
|
max = it.size
|
|
progress = 0
|
|
}
|
|
with(reader_progressbar) {
|
|
max = it.size
|
|
progress = 0
|
|
}
|
|
|
|
gallerySize = it.size
|
|
menu?.findItem(R.id.reader_menu_page_indicator)?.title = "$currentPage/${it.size}"
|
|
}
|
|
}
|
|
onProgressHandler = {
|
|
CoroutineScope(Dispatchers.Main).launch {
|
|
reader_download_progressbar.progress = it
|
|
menu?.findItem(R.id.reader_menu_use_hiyobi)?.isVisible = downloader.useHiyobi
|
|
}
|
|
}
|
|
onDownloadedHandler = {
|
|
val item = it.toList()
|
|
CoroutineScope(Dispatchers.Main).launch {
|
|
if (images.isEmpty()) {
|
|
images.addAll(item)
|
|
reader_recyclerview.adapter?.notifyDataSetChanged()
|
|
} else {
|
|
images.add(item.last())
|
|
reader_recyclerview.adapter?.notifyItemInserted(images.size-1)
|
|
}
|
|
}
|
|
}
|
|
onErrorHandler = {
|
|
if (it is IOException)
|
|
Snackbar.make(reader_layout, R.string.unable_to_connect, Snackbar.LENGTH_LONG).show()
|
|
downloader.download = false
|
|
}
|
|
onCompleteHandler = {
|
|
CoroutineScope(Dispatchers.Main).launch {
|
|
reader_download_progressbar.visibility = View.GONE
|
|
}
|
|
}
|
|
onNotifyChangedHandler = { notify ->
|
|
val fab = reader_fab_download
|
|
|
|
runOnUiThread {
|
|
if (notify) {
|
|
val icon = AnimatedVectorDrawableCompat.create(this, R.drawable.ic_downloading)
|
|
icon?.registerAnimationCallback(object: Animatable2Compat.AnimationCallback() {
|
|
override fun onAnimationEnd(drawable: Drawable?) {
|
|
if (downloader.download)
|
|
fab.post {
|
|
icon.start()
|
|
fab.labelText = getString(R.string.reader_fab_download_cancel)
|
|
}
|
|
else
|
|
fab.post {
|
|
fab.setImageResource(R.drawable.ic_download)
|
|
fab.labelText = getString(R.string.reader_fab_download)
|
|
}
|
|
}
|
|
})
|
|
|
|
fab.setImageDrawable(icon)
|
|
icon?.start()
|
|
} else {
|
|
runOnUiThread {
|
|
fab.setImageResource(R.drawable.ic_download)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (downloader.download) {
|
|
downloader.invokeOnReaderLoaded()
|
|
downloader.invokeOnNotifyChanged()
|
|
}
|
|
}
|
|
|
|
private fun initView() {
|
|
with(reader_recyclerview) {
|
|
adapter = ReaderAdapter(images)
|
|
|
|
addOnScrollListener(object: RecyclerView.OnScrollListener() {
|
|
override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
|
|
super.onScrolled(recyclerView, dx, dy)
|
|
|
|
val layoutManager = recyclerView.layoutManager as LinearLayoutManager
|
|
|
|
if (layoutManager.findFirstVisibleItemPosition() == -1)
|
|
return
|
|
currentPage = layoutManager.findFirstVisibleItemPosition()+1
|
|
menu?.findItem(R.id.reader_menu_page_indicator)?.title = "$currentPage/$gallerySize"
|
|
this@ReaderActivity.reader_progressbar.progress = currentPage
|
|
}
|
|
})
|
|
|
|
ItemClickSupport.addTo(this)
|
|
.setOnItemClickListener { _, _, _ ->
|
|
if (isScroll) {
|
|
isScroll = false
|
|
isFullscreen = true
|
|
|
|
scrollMode(false)
|
|
fullscreen(true)
|
|
} else {
|
|
(reader_recyclerview.layoutManager as LinearLayoutManager?)?.scrollToPosition(currentPage)
|
|
}
|
|
}
|
|
}
|
|
|
|
reader_fab_fullscreen.setOnClickListener {
|
|
isFullscreen = true
|
|
fullscreen(isFullscreen)
|
|
|
|
reader_fab.close(true)
|
|
}
|
|
|
|
reader_fab_download.setOnClickListener {
|
|
downloader.download = !downloader.download
|
|
|
|
if (!downloader.download)
|
|
downloader.clearNotification()
|
|
}
|
|
}
|
|
|
|
private fun fullscreen(isFullscreen: Boolean) {
|
|
with(window.attributes) {
|
|
if (isFullscreen) {
|
|
flags = flags or WindowManager.LayoutParams.FLAG_FULLSCREEN
|
|
supportActionBar?.hide()
|
|
this@ReaderActivity.reader_fab.visibility = View.INVISIBLE
|
|
} else {
|
|
flags = flags and WindowManager.LayoutParams.FLAG_FULLSCREEN.inv()
|
|
supportActionBar?.show()
|
|
this@ReaderActivity.reader_fab.visibility = View.VISIBLE
|
|
}
|
|
|
|
window.attributes = this
|
|
}
|
|
}
|
|
|
|
private fun scrollMode(isScroll: Boolean) {
|
|
if (isScroll) {
|
|
snapHelper.attachToRecyclerView(null)
|
|
reader_recyclerview.layoutManager = LinearLayoutManager(this)
|
|
} else {
|
|
snapHelper.attachToRecyclerView(reader_recyclerview)
|
|
reader_recyclerview.layoutManager = LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false)
|
|
}
|
|
|
|
(reader_recyclerview.layoutManager as LinearLayoutManager).scrollToPositionWithOffset(currentPage-1, 0)
|
|
}
|
|
} |