Migrate to Android 29

Re-Added Cache clear to prevent deleting downloading images

app/src/main/java/xyz/quaver/pupil/ui/LockActivity.kt

@@ -0,0 +1,29 @@
+package xyz.quaver.pupil.ui
+
+import androidx.appcompat.app.AppCompatActivity
+import android.os.Bundle
+import android.widget.Toast
+import kotlinx.android.synthetic.main.activity_lock.*
+import xyz.quaver.pupil.R
+
+class LockActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_lock)
+
+        supportFragmentManager.beginTransaction().add(
+            R.id.lock_content,
+            PatternLockFragment().apply {
+                onPatternDrawn = {
+                    Toast.makeText(context, it, Toast.LENGTH_SHORT).show()
+                }
+            }
+        ).commit()
+
+        lock_pattern.isEnabled = false
+        lock_fingerprint.isEnabled = false
+        lock_password.isEnabled = false
+    }
+
+}

app/src/main/java/xyz/quaver/pupil/ui/PatternLockFragment.kt

@@ -0,0 +1,46 @@
+package xyz.quaver.pupil.ui
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import com.andrognito.patternlockview.PatternLockView
+import com.andrognito.patternlockview.listener.PatternLockViewListener
+import com.andrognito.patternlockview.utils.PatternLockUtils
+import kotlinx.android.synthetic.main.fragment_pattern_lock.*
+import kotlinx.android.synthetic.main.fragment_pattern_lock.view.*
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.util.hash
+
+class PatternLockFragment : Fragment(), PatternLockViewListener {
+
+    var onPatternDrawn: ((String) -> Unit)? = null
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_pattern_lock, container, false).apply {
+            lock_pattern_view.addPatternLockListener(this@PatternLockFragment)
+        }
+    }
+
+    override fun onCleared() {
+
+    }
+
+    override fun onComplete(pattern: MutableList<PatternLockView.Dot>?) {
+        val password = PatternLockUtils.patternToMD5(lock_pattern_view, pattern)
+        onPatternDrawn?.invoke(hash(password))
+    }
+
+    override fun onProgress(progressPattern: MutableList<PatternLockView.Dot>?) {
+
+    }
+
+    override fun onStarted() {
+
+    }
+
+}

app/src/main/java/xyz/quaver/pupil/ui/Pupil.kt

@@ -0,0 +1,46 @@
+package xyz.quaver.pupil.ui
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import androidx.core.content.ContextCompat
+import androidx.multidex.MultiDexApplication
+import androidx.preference.PreferenceManager
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.util.Histories
+import java.io.File
+
+class Pupil : MultiDexApplication() {
+
+    lateinit var histories: Histories
+    lateinit var downloads: Histories
+    lateinit var favorites: Histories
+
+    override fun onCreate() {
+        val preference = PreferenceManager.getDefaultSharedPreferences(this)
+
+        histories = Histories(File(ContextCompat.getDataDir(this), "histories.json"))
+        downloads = Histories(File(ContextCompat.getDataDir(this), "downloads.json"))
+        favorites = Histories(File(ContextCompat.getDataDir(this), "favorites.json"))
+
+        super.onCreate()
+
+        if (!preference.getBoolean("channel_created", false)) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+                val channel = NotificationChannel("download", getString(R.string.channel_download), NotificationManager.IMPORTANCE_LOW).apply {
+                    description = getString(R.string.channel_download_description)
+                    enableLights(false)
+                    enableVibration(false)
+                    lockscreenVisibility = Notification.VISIBILITY_SECRET
+                }
+                manager.createNotificationChannel(channel)
+            }
+
+            preference.edit().putBoolean("channel_created", true).apply()
+        }
+    }
+
+}

app/src/main/java/xyz/quaver/pupil/ui/ReaderActivity.kt

@@ -0,0 +1,383 @@
+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)
+    }
+}

app/src/main/java/xyz/quaver/pupil/ui/SettingsActivity.kt

@@ -0,0 +1,287 @@
+package xyz.quaver.pupil.ui
+
+import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.WindowManager
+import android.widget.ArrayAdapter
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import androidx.preference.Preference
+import androidx.preference.PreferenceFragmentCompat
+import androidx.preference.PreferenceManager
+import io.fabric.sdk.android.BuildConfig
+import kotlinx.android.synthetic.main.dialog_default_query.view.*
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.types.Tags
+import java.io.File
+
+class SettingsActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        window.setFlags(
+            WindowManager.LayoutParams.FLAG_SECURE,
+            WindowManager.LayoutParams.FLAG_SECURE)
+
+        setContentView(R.layout.settings_activity)
+        supportFragmentManager
+            .beginTransaction()
+            .replace(R.id.settings, SettingsFragment())
+            .commit()
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
+    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()
+    }
+
+    class SettingsFragment : PreferenceFragmentCompat() {
+
+        private val suffix = listOf(
+            "B",
+            "kB",
+            "MB",
+            "GB",
+            "TB" //really?
+        )
+
+        private fun getDirSize(dir: File) : String {
+            var size = dir.walk().map { it.length() }.sum()
+            var suffixIndex = 0
+
+            while (size >= 1024) {
+                size /= 1024
+                suffixIndex++
+            }
+
+            return getString(R.string.settings_clear_summary, size, suffix[suffixIndex])
+        }
+
+        override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
+            setPreferencesFromResource(R.xml.root_preferences, rootKey)
+
+            with(findPreference<Preference>("app_version")) {
+                this ?: return@with
+
+                val manager = context.packageManager
+                val info = manager.getPackageInfo(context.packageName, 0)
+
+                summary = info.versionName
+            }
+
+            with(findPreference<Preference>("delete_cache")) {
+                this ?: return@with
+
+                val dir = File(context.cacheDir, "imageCache")
+
+                summary = getDirSize(dir)
+
+                onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                    AlertDialog.Builder(context).apply {
+                        setTitle(R.string.warning)
+                        setMessage(R.string.settings_clear_cache_alert_message)
+                        setPositiveButton(android.R.string.yes) { _, _ ->
+                            if (dir.exists())
+                                dir.deleteRecursively()
+
+                            summary = getDirSize(dir)
+                        }
+                        setNegativeButton(android.R.string.no) { _, _ -> }
+                    }.show()
+
+                    true
+                }
+            }
+
+            with(findPreference<Preference>("delete_downloads")) {
+                this ?: return@with
+
+                val dir = context.getExternalFilesDir("Pupil") ?: return@with
+
+                summary = getDirSize(dir)
+
+                onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                    AlertDialog.Builder(context).apply {
+                        setTitle(R.string.warning)
+                        setMessage(R.string.settings_clear_downloads_alert_message)
+                        setPositiveButton(android.R.string.yes) { _, _ ->
+                            if (dir.exists())
+                                dir.deleteRecursively()
+
+                            val downloads = (activity!!.application as Pupil).downloads
+
+                            downloads.clear()
+
+                            summary = getDirSize(dir)
+                        }
+                        setNegativeButton(android.R.string.no) { _, _ -> }
+                    }.show()
+
+                    true
+                }
+            }
+            with(findPreference<Preference>("clear_history")) {
+                this ?: return@with
+
+                val histories = (activity!!.application as Pupil).histories
+
+                summary = getString(R.string.settings_clear_history_summary, histories.size)
+
+                onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                    AlertDialog.Builder(context).apply {
+                        setTitle(R.string.warning)
+                        setMessage(R.string.settings_clear_history_alert_message)
+                        setPositiveButton(android.R.string.yes) { _, _ ->
+                            histories.clear()
+                            summary = getString(R.string.settings_clear_history_summary, histories.size)
+                        }
+                        setNegativeButton(android.R.string.no) { _, _ -> }
+                    }.show()
+
+                    true
+                }
+            }
+
+            with(findPreference<Preference>("default_query")) {
+                this ?: return@with
+
+                val preferences = PreferenceManager.getDefaultSharedPreferences(context)
+
+                summary = preferences.getString("default_query", "") ?: ""
+
+                val languages = resources.getStringArray(R.array.languages).map {
+                    it.split("|").let { split ->
+                        Pair(split[0], split[1])
+                    }
+                }.toMap()
+                val reverseLanguages = languages.entries.associate { (k, v) -> v to k }
+
+                val excludeBL = "-male:yaoi"
+                val excludeGuro = listOf("-female:guro", "-male:guro")
+
+                onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                    val dialogView = LayoutInflater.from(context).inflate(
+                        R.layout.dialog_default_query,
+                        LinearLayout(context),
+                        false
+                    )
+
+                    val tags = Tags.parse(
+                        preferences.getString("default_query", "") ?: ""
+                    )
+
+                    summary = tags.toString()
+
+                    with(dialogView.default_query_dialog_language_selector) {
+                        adapter =
+                            ArrayAdapter(
+                                context,
+                                android.R.layout.simple_spinner_dropdown_item,
+                                arrayListOf(
+                                    getString(R.string.default_query_dialog_language_selector_none)
+                                ).apply {
+                                    addAll(languages.values)
+                                }
+                            )
+                        if (tags.any { it.area == "language" }) {
+                            val tag = languages[tags.first { it.area == "language" }.tag]
+                            if (tag != null) {
+                                setSelection(
+                                    @Suppress("UNCHECKED_CAST")
+                                    (adapter as ArrayAdapter<String>).getPosition(tag)
+                                )
+                                tags.removeByArea("language")
+                            }
+                        }
+                    }
+
+                    with(dialogView.default_query_dialog_BL_checkbox) {
+                        isChecked = tags.contains(excludeBL)
+                        if (tags.contains(excludeBL))
+                            tags.remove(excludeBL)
+                    }
+
+                    with(dialogView.default_query_dialog_guro_checkbox) {
+                        isChecked = excludeGuro.all { tags.contains(it) }
+                        if (excludeGuro.all { tags.contains(it) })
+                            excludeGuro.forEach {
+                                tags.remove(it)
+                            }
+                    }
+
+                    with(dialogView.default_query_dialog_edittext) {
+                        setText(tags.toString(), TextView.BufferType.EDITABLE)
+                        addTextChangedListener(object : TextWatcher {
+                            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+
+                            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+
+                            override fun afterTextChanged(s: Editable?) {
+                                s ?: return
+
+                                if (s.any { it.isUpperCase() })
+                                    s.replace(0, s.length, s.toString().toLowerCase())
+                            }
+                        })
+                    }
+
+                    val dialog = AlertDialog.Builder(context!!).apply {
+                        setView(dialogView)
+                    }.create()
+
+                    dialogView.default_query_dialog_ok.setOnClickListener {
+                        val newTags = Tags.parse(dialogView.default_query_dialog_edittext.text.toString())
+
+                        with(dialogView.default_query_dialog_language_selector) {
+                            if (selectedItemPosition != 0)
+                                newTags.add("language:${reverseLanguages[selectedItem]}")
+                        }
+
+                        if (dialogView.default_query_dialog_BL_checkbox.isChecked)
+                            newTags.add(excludeBL)
+
+                        if (dialogView.default_query_dialog_guro_checkbox.isChecked)
+                            excludeGuro.forEach { tag ->
+                                newTags.add(tag)
+                            }
+
+                        preferenceManager.sharedPreferences.edit().putString("default_query", newTags.toString()).apply()
+                        summary = preferences.getString("default_query", "") ?: ""
+                        tags.clear()
+                        tags.addAll(newTags)
+                        dialog.dismiss()
+                    }
+
+                    dialog.show()
+
+                    true
+                }
+            }
+            with(findPreference<Preference>("app_lock")) {
+
+            }
+        }
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem?): Boolean {
+        when (item?.itemId) {
+            android.R.id.home -> onBackPressed()
+        }
+
+        return true
+    }
+}