feat(data): initialize ClipboardHelper to enhance management of clipboard

Author: WhiredPlanck

app/src/main/java/com/osfans/trime/data/db/DatabaseBean.kt

@@ -1,5 +1,6 @@
 package com.osfans.trime.data.db
 
+import android.content.ClipData
 import androidx.room.Entity
 import androidx.room.PrimaryKey
 import androidx.room.TypeConverter
@@ -10,11 +11,16 @@ data class DatabaseBean(
     val id: Int = 0,
     val text: String?,
     val html: String? = null,
-    val type: BeanType,
+    val type: BeanType = BeanType.TEXT,
     val time: Long = System.currentTimeMillis()
 ) {
     companion object {
         const val TABLE_NAME = "t_data"
+
+        fun fromClipData(clipData: ClipData): DatabaseBean? {
+            val str = clipData.getItemAt(0).text?.toString() ?: return null
+            return DatabaseBean(text = str)
+        }
     }
 
     enum class BeanType {

app/src/main/java/com/osfans/trime/data/db/DatabaseDao.kt

@@ -23,6 +23,9 @@ interface DatabaseDao {
     @Query("DELETE FROM ${DatabaseBean.TABLE_NAME} WHERE id=:id")
     fun delete(id: Int)
 
+    @Delete
+    fun delete(beans: List<DatabaseBean>)
+
     @Query("DELETE FROM ${DatabaseBean.TABLE_NAME}")
     fun deleteAll()
 

app/src/main/java/com/osfans/trime/data/db/clipboard/ClipboardHelper.kt

@@ -0,0 +1,94 @@
+package com.osfans.trime.data.db.clipboard
+
+import android.content.ClipboardManager
+import android.content.Context
+import androidx.room.Room
+import com.osfans.trime.data.AppPrefs
+import com.osfans.trime.data.db.Database
+import com.osfans.trime.data.db.DatabaseBean
+import com.osfans.trime.data.db.DatabaseDao
+import com.osfans.trime.util.StringUtils.mismatch
+import com.osfans.trime.util.StringUtils.replace
+import com.osfans.trime.util.WeakHashSet
+import com.osfans.trime.util.clipboardManager
+import timber.log.Timber
+
+object ClipboardHelper : ClipboardManager.OnPrimaryClipChangedListener {
+    private lateinit var clbDb: Database
+    private lateinit var clbDao: DatabaseDao
+
+    fun interface OnClipboardUpdateListener {
+        fun onUpdate(text: String)
+    }
+
+    private val onUpdateListeners = WeakHashSet<OnClipboardUpdateListener>()
+
+    fun addOnUpdateListener(listener: OnClipboardUpdateListener) {
+        onUpdateListeners.add(listener)
+    }
+
+    fun removeOnUpdateListener(listener: OnClipboardUpdateListener) {
+        onUpdateListeners.remove(listener)
+    }
+
+    private val limit get() = AppPrefs.defaultInstance().other.clipboardLimit.toInt()
+    private val compare get() = AppPrefs.defaultInstance().other.clipboardCompareRules
+        .trim().split('\n')
+    private val output get() = AppPrefs.defaultInstance().other.clipboardOutputRules
+        .trim().split('\n')
+
+    fun init(context: Context) {
+        clipboardManager.addPrimaryClipChangedListener(this)
+        clbDb = Room
+            .databaseBuilder(context, Database::class.java, "clipboard")
+            .fallbackToDestructiveMigration()
+            .build()
+        clbDao = clbDb.databaseDao()
+    }
+
+    fun getAll() = clbDao.getAll()
+
+    fun delete(id: Int) {
+        clbDao.delete(id)
+    }
+
+    fun deleteAll() {
+        clbDao.deleteAll()
+    }
+
+    override fun onPrimaryClipChanged() {
+        if (!(limit != 0 && this::clbDao.isInitialized)) {
+            return
+        }
+        clipboardManager
+            .primaryClip
+            ?.let { DatabaseBean.fromClipData(it) }
+            ?.takeIf {
+                it.text!!.isNotBlank()
+                it.text.mismatch(output.toTypedArray())
+            }
+            ?.let { b ->
+                if (b.text!!.replace(compare.toTypedArray()).isEmpty()) return
+                Timber.d("Accept $b")
+                val all = clbDao.getAll()
+                all.find { b.text == it.text }?.let {
+                    clbDao.delete(it.id)
+                }
+                clbDao.insert(b)
+                removeOutdated()
+                onUpdateListeners.forEach { listener ->
+                    listener.onUpdate(b.text)
+                }
+            }
+    }
+
+    private fun removeOutdated() {
+        val all = clbDao.getAll()
+        if (all.size > limit) {
+            val outdated = all
+                .sortedBy { it.id }
+                .subList(0, all.size - limit)
+            clbDao.delete(outdated)
+        }
+    }
+}

app/src/main/java/com/osfans/trime/util/WeakHashSet.kt

@@ -0,0 +1,30 @@
+package com.osfans.trime.util
+
+import java.util.WeakHashMap
+
+class WeakHashSet<T> : MutableSet<T> {
+
+    private val core = WeakHashMap<T, PlaceHolder>()
+
+    private object PlaceHolder
+
+    val view = object : Set<T> by core.keys {}
+    override val size get() = core.size
+
+    override fun iterator(): MutableIterator<T> = core.keys.iterator()
+
+    override fun add(element: T) = core.put(element, PlaceHolder) != null
+    override fun addAll(elements: Collection<T>) = elements.all(::add)
+
+    override fun remove(element: T) = core.remove(element) != null
+    override fun removeAll(elements: Collection<T>) = elements.all(::remove)
+    override fun clear() = core.clear()
+
+    override fun retainAll(elements: Collection<T>) =
+        removeAll(core.keys.filter { it !in elements })
+
+    override operator fun contains(element: T) = core.containsKey(element)
+    override fun containsAll(elements: Collection<T>) = elements.all(::contains)
+
+    override fun isEmpty() = core.isEmpty()
+}