873 lines
33 KiB
Kotlin
873 lines
33 KiB
Kotlin
package jp.juggler.subwaytooter.dialog
|
|
|
|
import android.app.Dialog
|
|
import android.content.Context
|
|
import android.graphics.drawable.PictureDrawable
|
|
import android.text.Editable
|
|
import android.text.TextWatcher
|
|
import android.util.TypedValue
|
|
import android.view.*
|
|
import android.widget.FrameLayout
|
|
import android.widget.ImageButton
|
|
import android.widget.ImageView
|
|
import android.widget.LinearLayout
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.appcompat.widget.AppCompatButton
|
|
import androidx.appcompat.widget.AppCompatImageButton
|
|
import androidx.appcompat.widget.AppCompatImageView
|
|
import androidx.appcompat.widget.AppCompatTextView
|
|
import androidx.core.content.ContextCompat
|
|
import androidx.core.view.children
|
|
import androidx.recyclerview.widget.RecyclerView
|
|
import com.bumptech.glide.Glide
|
|
import com.google.android.flexbox.*
|
|
import jp.juggler.subwaytooter.App1
|
|
import jp.juggler.subwaytooter.R
|
|
import jp.juggler.subwaytooter.databinding.EmojiPickerDialogBinding
|
|
import jp.juggler.subwaytooter.emoji.*
|
|
import jp.juggler.subwaytooter.pref.PrefB
|
|
import jp.juggler.subwaytooter.pref.PrefS
|
|
import jp.juggler.subwaytooter.span.NetworkEmojiSpan
|
|
import jp.juggler.subwaytooter.table.SavedAccount
|
|
import jp.juggler.subwaytooter.util.emojiSizeMode
|
|
import jp.juggler.subwaytooter.util.minHeightCompat
|
|
import jp.juggler.subwaytooter.util.minWidthCompat
|
|
import jp.juggler.subwaytooter.view.NetworkEmojiView
|
|
import jp.juggler.util.*
|
|
import jp.juggler.util.coroutine.launchAndShowError
|
|
import jp.juggler.util.data.*
|
|
import jp.juggler.util.log.*
|
|
import jp.juggler.util.ui.*
|
|
import org.jetbrains.anko.image
|
|
import org.jetbrains.anko.wrapContent
|
|
import kotlin.math.abs
|
|
import kotlin.math.sign
|
|
|
|
private class EmojiPicker(
|
|
private val activity: AppCompatActivity,
|
|
private val accessInfo: SavedAccount?,
|
|
private val closeOnSelected: Boolean,
|
|
private val onPicked: suspend (EmojiBase, bInstanceHasCustomEmoji: Boolean) -> Unit,
|
|
) {
|
|
companion object {
|
|
private val log = LogCategory("EmojiPicker")
|
|
|
|
private const val VT_CATEGORY = 0
|
|
private const val VT_CUSTOM_EMOJI = 1
|
|
private const val VT_TWEMOJI = 2
|
|
private const val VT_COMPAT_EMOJI = 3
|
|
|
|
private const val gridCols = 6
|
|
|
|
private fun EmojiCategory.getUnicodeEmojis() =
|
|
emojiList.map { PickerItemUnicode(unicodeEmoji = it) }
|
|
}
|
|
|
|
private class SkinTone(val codeInt: Int) {
|
|
val code = StringBuilder().apply { appendCodePoint(codeInt) }.toString()
|
|
}
|
|
|
|
private sealed interface PickerItem
|
|
private class PickerItemUnicode(val unicodeEmoji: UnicodeEmoji) : PickerItem
|
|
private class PickerItemCustom(val customEmoji: CustomEmoji) : PickerItem
|
|
|
|
private open class PickerItemCategory(
|
|
var name: String,
|
|
val category: EmojiCategory,
|
|
val original: PickerItemCategory? = null,
|
|
var next: PickerItemCategory? = null,
|
|
) : PickerItem {
|
|
val items = ArrayList<PickerItem>()
|
|
open fun createFiltered(keywordLower: String?) =
|
|
PickerItemCategory(
|
|
name = name,
|
|
category = category,
|
|
original = this,
|
|
).also { dst ->
|
|
dst.items.addAll(
|
|
if (keywordLower.isNullOrEmpty()) {
|
|
items
|
|
} else {
|
|
items.filter {
|
|
when (it) {
|
|
is PickerItemCustom ->
|
|
it.customEmoji.shortcode.contains(keywordLower)
|
|
is PickerItemUnicode ->
|
|
it.unicodeEmoji.namesLower.any { n -> n.contains(keywordLower) }
|
|
else -> false
|
|
}
|
|
}
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
private class PickerItemCategoryRecent(
|
|
name: String,
|
|
val accessInfo: SavedAccount?,
|
|
) : PickerItemCategory(name, EmojiCategory.Recent) {
|
|
|
|
private val recentsJsonList: List<JsonObject>?
|
|
get() = try {
|
|
PrefS.spEmojiPickerRecent.value.decodeJsonArray().objectList()
|
|
} catch (ex: Throwable) {
|
|
log.w(ex, "can't load spEmojiPickerRecent")
|
|
null
|
|
}
|
|
|
|
private fun JsonObject.parseRecent1(
|
|
customEmojiMap: HashMap<String, CustomEmoji>?,
|
|
): PickerItem? {
|
|
val name = string("name")
|
|
val instance = string("instance")
|
|
try {
|
|
name ?: error("missing emoji name")
|
|
when (instance) {
|
|
null -> EmojiMap.shortNameMap[name]?.let {
|
|
return PickerItemUnicode(unicodeEmoji = it)
|
|
}
|
|
accessInfo?.apiHost?.ascii ->
|
|
customEmojiMap?.get(name)?.let {
|
|
return PickerItemCustom(customEmoji = it)
|
|
}
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.w(ex, "can't add emoji. $name, $instance")
|
|
}
|
|
return null
|
|
}
|
|
|
|
private fun List<JsonObject>.loadRecents() {
|
|
try {
|
|
val customEmojiMap =
|
|
accessInfo?.let { App1.custom_emoji_lister.getMapNonBlocking(it) }
|
|
val newItems = mapNotNull { it.parseRecent1(customEmojiMap) }
|
|
items.clear()
|
|
items.addAll(newItems)
|
|
} catch (ex: Throwable) {
|
|
log.w(ex, "loadRecents failed.")
|
|
}
|
|
}
|
|
|
|
// 最近使用した絵文字のPickerCategoryを作る
|
|
fun load() = recentsJsonList?.loadRecents()
|
|
|
|
fun update(
|
|
targetName: String,
|
|
targetInstance: String?,
|
|
) {
|
|
// Recentをロード(他インスタンスの絵文字を含む)
|
|
val list = recentsJsonList?.toMutableList() ?: ArrayList()
|
|
|
|
// 選択された絵文字と同じ項目を除去
|
|
// 項目が増えすぎたら減らす
|
|
// ユニコード絵文字256個、カスタム絵文字はインスタンス別256個まで
|
|
var nCount = 0
|
|
val it = list.iterator()
|
|
while (it.hasNext()) {
|
|
val item = it.next()
|
|
val itemName = item.string("name")
|
|
val itemInstance = item.string("instance")
|
|
if (itemInstance != targetInstance) continue
|
|
if (itemName == targetName || ++nCount >= 256) {
|
|
it.remove()
|
|
}
|
|
}
|
|
|
|
// 先頭に項目を追加
|
|
list.add(0, JsonObject().apply {
|
|
put("name", targetName)
|
|
targetInstance?.let { put("instance", it) }
|
|
})
|
|
|
|
// 保存する
|
|
try {
|
|
PrefS.spEmojiPickerRecent.value = list.toJsonArray().toString()
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "can't save spEmojiPickerRecent")
|
|
}
|
|
// カテゴリ内のPickerItemの更新
|
|
try {
|
|
list.loadRecents()
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "loadRecents failed.")
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class ViewHolderBase(view: View) : RecyclerView.ViewHolder(view) {
|
|
abstract fun bind(item: PickerItem)
|
|
}
|
|
|
|
private var lastExpandCategory: PickerItemCategory? = null
|
|
private var canCollapse = true
|
|
|
|
private inner class VhCategory(
|
|
view: LinearLayout = LinearLayout(activity),
|
|
) : ViewHolderBase(view) {
|
|
var lastItem: PickerItemCategory? = null
|
|
|
|
val ibExpand = AppCompatImageButton(activity).apply {
|
|
layoutParams = LinearLayout.LayoutParams(gridSize, matchParent)
|
|
background = ContextCompat.getDrawable(
|
|
this@EmojiPicker.activity,
|
|
R.drawable.btn_bg_transparent_round6dp
|
|
)
|
|
setOnClickListener {
|
|
val orig = lastItem?.original
|
|
?: return@setOnClickListener
|
|
lastExpandCategory = if (lastExpandCategory != orig) orig else lastItem?.next
|
|
// 再表示
|
|
showFiltered(
|
|
lastSelectedCategory,
|
|
lastSelectedKeyword,
|
|
scrollCategoryTab = false,
|
|
scrollToCategory = true,
|
|
)
|
|
}
|
|
}
|
|
|
|
val tv = AppCompatTextView(activity).apply {
|
|
layoutParams = LinearLayout.LayoutParams(0, wrapContent).apply {
|
|
weight = 1f
|
|
}
|
|
minHeightCompat = (density * 48f + 0.5f).toInt()
|
|
gravity = Gravity.START or Gravity.CENTER_VERTICAL
|
|
includeFontPadding = false
|
|
}
|
|
|
|
init {
|
|
view.layoutParams = RecyclerView.LayoutParams(headerWidth, wrapContent)
|
|
view.setPadding(cellMargin, cellMargin, cellMargin, cellMargin)
|
|
view.isBaselineAligned = false
|
|
view.gravity = Gravity.START or Gravity.CENTER_VERTICAL
|
|
view.addView(ibExpand)
|
|
view.addView(tv)
|
|
}
|
|
|
|
override fun bind(item: PickerItem) {
|
|
if (item is PickerItemCategory) {
|
|
lastItem = item
|
|
tv.text = item.name
|
|
ibExpand.vg(canCollapse)?.let {
|
|
val drawableId = when (lastExpandCategory == item.original) {
|
|
true -> R.drawable.ic_arrow_drop_down
|
|
else -> R.drawable.ic_arrow_drop_up
|
|
}
|
|
it.image = ContextCompat.getDrawable(activity, drawableId)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private inner class VhCustomEmoji(
|
|
val view: FrameLayout = FrameLayout(activity),
|
|
) : ViewHolderBase(view) {
|
|
val niv = NetworkEmojiView(
|
|
context = activity,
|
|
sizeMode = accessInfo.emojiSizeMode(),
|
|
maxEmojiWidth = NetworkEmojiSpan.maxEmojiWidth,
|
|
).apply {
|
|
layoutParams = FrameLayout.LayoutParams(gridSize, gridSize)
|
|
}
|
|
|
|
init {
|
|
view.setButtonBackground()
|
|
view.setOnClickListener(pickerItemClickListener)
|
|
view.layoutParams = RecyclerView.LayoutParams(wrapContent, wrapContent)
|
|
view.setPadding(cellMargin, cellMargin, cellMargin, cellMargin)
|
|
view.addView(niv)
|
|
}
|
|
|
|
override fun bind(item: PickerItem) {
|
|
if (activity.isDestroyed) return
|
|
if (item is PickerItemCustom) {
|
|
view.setTag(R.id.btnAbout, item)
|
|
niv.setEmoji(
|
|
url = if (disableAnimation) {
|
|
item.customEmoji.staticUrl
|
|
} else {
|
|
item.customEmoji.url
|
|
},
|
|
initialAspect = item.customEmoji.aspect,
|
|
defaultHeight = gridSize,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
private inner class VhTwemoji(
|
|
val view: FrameLayout = FrameLayout(activity),
|
|
) : ViewHolderBase(view) {
|
|
val iv = AppCompatImageView(activity).apply {
|
|
layoutParams = FrameLayout.LayoutParams(gridSize, gridSize)
|
|
scaleType = ImageView.ScaleType.FIT_CENTER
|
|
}
|
|
|
|
init {
|
|
view.setButtonBackground()
|
|
view.setOnClickListener(pickerItemClickListener)
|
|
view.layoutParams = RecyclerView.LayoutParams(wrapContent, wrapContent)
|
|
view.setPadding(cellMargin, cellMargin, cellMargin, cellMargin)
|
|
view.addView(iv)
|
|
}
|
|
|
|
override fun bind(item: PickerItem) {
|
|
if (activity.isDestroyed) return
|
|
if (item is PickerItemUnicode) {
|
|
view.setTag(R.id.btnAbout, item)
|
|
val emoji = applySkinTone(item.unicodeEmoji)
|
|
if (emoji.isSvg) {
|
|
Glide.with(activity)
|
|
.`as`(PictureDrawable::class.java)
|
|
.load("file:///android_asset/${emoji.assetsName}")
|
|
.into(iv)
|
|
} else {
|
|
Glide.with(activity)
|
|
.load(emoji.drawableId)
|
|
.into(iv)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private inner class VhAppCompatEmoji(
|
|
val view: FrameLayout = FrameLayout(activity),
|
|
) : ViewHolderBase(view) {
|
|
val tv = AppCompatTextView(activity).apply {
|
|
layoutParams = FrameLayout.LayoutParams(gridSize, gridSize)
|
|
gravity = Gravity.CENTER
|
|
includeFontPadding = false
|
|
setLineSpacing(0f, 0f)
|
|
setTextSize(TypedValue.COMPLEX_UNIT_PX, gridSize.toFloat() * 0.7f)
|
|
}
|
|
|
|
init {
|
|
view.setButtonBackground()
|
|
view.setOnClickListener(pickerItemClickListener)
|
|
view.layoutParams = RecyclerView.LayoutParams(wrapContent, wrapContent)
|
|
view.addView(tv)
|
|
}
|
|
|
|
override fun bind(item: PickerItem) {
|
|
if (activity.isDestroyed) return
|
|
if (item is PickerItemUnicode) {
|
|
view.setTag(R.id.btnAbout, item)
|
|
val unicodeEmoji = applySkinTone(item.unicodeEmoji)
|
|
tv.text = unicodeEmoji.unifiedCode
|
|
}
|
|
}
|
|
}
|
|
|
|
class FlexboxLayoutManagerWrapper(context: Context) : FlexboxLayoutManager(context) {
|
|
override fun generateLayoutParams(lp: ViewGroup.LayoutParams): RecyclerView.LayoutParams {
|
|
return LayoutParams(lp)
|
|
}
|
|
}
|
|
|
|
private inner class GridAdapter : RecyclerView.Adapter<ViewHolderBase>() {
|
|
|
|
var list: List<PickerItem> = emptyList()
|
|
set(value) {
|
|
field = value
|
|
@Suppress("NotifyDataSetChanged")
|
|
notifyDataSetChanged()
|
|
}
|
|
|
|
override fun getItemCount() = list.size
|
|
|
|
override fun getItemViewType(position: Int) =
|
|
when (list[position]) {
|
|
is PickerItemCategory -> VT_CATEGORY
|
|
is PickerItemCustom -> VT_CUSTOM_EMOJI
|
|
is PickerItemUnicode -> when {
|
|
useTwemoji -> VT_TWEMOJI
|
|
else -> VT_COMPAT_EMOJI
|
|
}
|
|
}
|
|
|
|
override fun onCreateViewHolder(viewGroup: ViewGroup, viewType: Int) =
|
|
when (viewType) {
|
|
VT_CATEGORY -> VhCategory()
|
|
VT_CUSTOM_EMOJI -> VhCustomEmoji()
|
|
VT_TWEMOJI -> VhTwemoji()
|
|
VT_COMPAT_EMOJI -> VhAppCompatEmoji()
|
|
else -> error("unknown viewType=$viewType")
|
|
}
|
|
|
|
override fun onBindViewHolder(viewHolder: ViewHolderBase, position: Int) {
|
|
viewHolder.bind(list[position])
|
|
}
|
|
}
|
|
|
|
private enum class FlickStatus {
|
|
None,
|
|
Start,
|
|
Intercepted,
|
|
}
|
|
|
|
private lateinit var pickerCategries: List<PickerItemCategory>
|
|
|
|
private val adapter = GridAdapter()
|
|
|
|
private val views = EmojiPickerDialogBinding.inflate(activity.layoutInflater)
|
|
|
|
private val ibSkinTone = listOf(
|
|
Pair(R.id.btnSkinTone0, 0),
|
|
Pair(R.id.btnSkinTone1, 0x1F3FB),
|
|
Pair(R.id.btnSkinTone2, 0x1F3FC),
|
|
Pair(R.id.btnSkinTone3, 0x1F3FD),
|
|
Pair(R.id.btnSkinTone4, 0x1F3FE),
|
|
Pair(R.id.btnSkinTone5, 0x1F3FF),
|
|
).map { (btnId, skinToneCode) ->
|
|
views.root.findViewById<ImageButton>(btnId).apply {
|
|
tag = SkinTone(skinToneCode)
|
|
setOnClickListener {
|
|
selectedTone = (it.tag as SkinTone)
|
|
showSkinTone()
|
|
@Suppress("NotifyDataSetChanged")
|
|
adapter.notifyDataSetChanged()
|
|
}
|
|
}
|
|
}
|
|
|
|
private val matchParent = RecyclerView.LayoutParams.MATCH_PARENT
|
|
|
|
private val useTwemoji = PrefB.bpUseTwemoji.value
|
|
private val disableAnimation = PrefB.bpDisableEmojiAnimation.value
|
|
|
|
private var selectedTone: SkinTone = (ibSkinTone[0].tag as SkinTone)
|
|
|
|
private lateinit var dialog: Dialog
|
|
|
|
private var bInstanceHasCustomEmoji = false
|
|
|
|
private var lastSelectedCategory: EmojiCategory? = null
|
|
private var lastSelectedKeyword: String? = null
|
|
|
|
private var recentCategory: PickerItemCategoryRecent? = null
|
|
|
|
private val density = activity.resources.displayMetrics.density
|
|
val cellMargin = (density * 1f + 0.5f).toInt()
|
|
val gridSize = (density * 48f + 0.5f).toInt()
|
|
val headerWidth = gridSize * 6
|
|
private val cancelY = 16f
|
|
private val interceptX = 40f
|
|
private var tracker: VelocityTracker? = null
|
|
private var dragging = FlickStatus.None
|
|
private var startX = 0f
|
|
private var startY = 0f
|
|
|
|
private val textWatcher = object : TextWatcher {
|
|
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
|
|
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
|
|
override fun afterTextChanged(s: Editable?) {
|
|
showFiltered(null, s?.toString())
|
|
}
|
|
}
|
|
|
|
private val pickerItemClickListener = View.OnClickListener { v ->
|
|
val targetEmoji: EmojiBase
|
|
val targetName: String
|
|
val targetInstance: String?
|
|
when (val item = v.getTag(R.id.btnAbout)) {
|
|
is PickerItemUnicode -> {
|
|
targetEmoji = applySkinTone(item.unicodeEmoji)
|
|
targetName = targetEmoji.unifiedName
|
|
targetInstance = null
|
|
}
|
|
is PickerItemCustom -> {
|
|
targetEmoji = item.customEmoji
|
|
targetName = item.customEmoji.shortcode
|
|
targetInstance = accessInfo!!.apiHost.ascii
|
|
}
|
|
else -> return@OnClickListener
|
|
}
|
|
|
|
recentCategory?.update(targetName, targetInstance)
|
|
|
|
if (closeOnSelected) {
|
|
dialog.dismissSafe()
|
|
} else if (lastSelectedCategory == null || lastSelectedCategory == EmojiCategory.Recent) {
|
|
// 全カテゴリ表示や最近の表示は最近の絵文字の順序を変えるため更新してしまう
|
|
showFiltered(lastSelectedCategory, lastSelectedKeyword)
|
|
// XXX: タップ状態の表示が行えない…
|
|
} else {
|
|
// この場合はビューの更新は不要で、タップ状態の表示を行える
|
|
}
|
|
activity.launchAndShowError {
|
|
onPicked(targetEmoji, bInstanceHasCustomEmoji)
|
|
}
|
|
}
|
|
|
|
private suspend fun createCustomEmojiCategories(): List<PickerItemCategory> {
|
|
accessInfo ?: error("missing accessInfo")
|
|
val context = activity
|
|
val srcList = App1.custom_emoji_lister.getList(accessInfo)
|
|
val nameMap = HashMap<String, PickerItemCategory>()
|
|
for (emoji in srcList) {
|
|
if (!emoji.visibleInPicker) continue
|
|
val categoryName = emoji.category ?: ""
|
|
(nameMap[categoryName]
|
|
?: PickerItemCategory(
|
|
name = categoryName,
|
|
category = EmojiCategory.Custom,
|
|
).also { nameMap[categoryName] = it })
|
|
.items.add(PickerItemCustom(emoji))
|
|
}
|
|
val otherCategory = nameMap[""]
|
|
|
|
// カテゴリ名の頭に「カスタム」を追加
|
|
return nameMap.values.onEach {
|
|
it.name = when (it) {
|
|
otherCategory -> when (nameMap.size) {
|
|
0 -> context.getString(R.string.emoji_category_custom)
|
|
else -> context.getString(
|
|
R.string.emoji_picker_custom_of,
|
|
context.getString(R.string.others)
|
|
)
|
|
}
|
|
else ->
|
|
context.getString(R.string.emoji_picker_custom_of, it.name)
|
|
}
|
|
}.sortedWith { l, r ->
|
|
if (l == otherCategory) 1
|
|
else if (r == otherCategory) -1
|
|
else l.name.compareTo(r.name)
|
|
}
|
|
}
|
|
|
|
private suspend fun buildCategoryList() = buildList {
|
|
// 最近使った絵文字
|
|
PickerItemCategoryRecent(
|
|
name = activity.getString(R.string.emoji_category_recent),
|
|
accessInfo = accessInfo,
|
|
).also {
|
|
recentCategory = it
|
|
it.load()
|
|
add(it)
|
|
}
|
|
|
|
// カスタム絵文字
|
|
try {
|
|
addAll(createCustomEmojiCategories())
|
|
} catch (ex: Throwable) {
|
|
log.w(ex, "createCustomEmojiCategories failed.")
|
|
}
|
|
|
|
val categories = mutableListOf(
|
|
EmojiCategory.People,
|
|
EmojiCategory.ComplexTones,
|
|
EmojiCategory.Nature,
|
|
EmojiCategory.Foods,
|
|
EmojiCategory.Activities,
|
|
EmojiCategory.Places,
|
|
EmojiCategory.Objects,
|
|
EmojiCategory.Symbols,
|
|
EmojiCategory.Flags,
|
|
)
|
|
if (PrefB.bpEmojiPickerCategoryOther.value) {
|
|
categories.add(EmojiCategory.Others)
|
|
}
|
|
for (category in categories) {
|
|
val pc = PickerItemCategory(
|
|
category = category,
|
|
name = activity.getString(category.titleId),
|
|
)
|
|
pc.items.addAll(category.getUnicodeEmojis())
|
|
add(pc)
|
|
}
|
|
}
|
|
|
|
private fun applySkinTone(emojiArg: UnicodeEmoji): UnicodeEmoji {
|
|
// トーン指定がないなら元のコード
|
|
val selectedTone = selectedTone.takeIf { it.codeInt > 0 } ?: return emojiArg
|
|
|
|
var emoji = emojiArg
|
|
|
|
// Recentなどでは既にsuffixがついた名前が用意されている
|
|
// suffixを除去する
|
|
emoji.toneParent?.let { emoji = it }
|
|
|
|
// 指定したトーンのサフィックスを追加して、絵文字が存在すればその名前にする
|
|
emoji.toneChildren.find { it.first == selectedTone.code }
|
|
?.let { return it.second }
|
|
|
|
// なければトーンなしの絵文字
|
|
return emoji
|
|
}
|
|
|
|
private fun showSkinTone() {
|
|
ibSkinTone.forEach {
|
|
when (selectedTone) {
|
|
it.tag -> it.setImageResource(R.drawable.check_mark)
|
|
else -> it.setImageDrawable(null)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun showFiltered(
|
|
selectedCategory: EmojiCategory?,
|
|
selectedKeyword: String?,
|
|
scrollCategoryTab: Boolean = true,
|
|
scrollToCategory: Boolean = false,
|
|
) {
|
|
lastSelectedCategory = selectedCategory
|
|
lastSelectedKeyword = selectedKeyword
|
|
val keywordLower = selectedKeyword?.lowercase()?.trim()
|
|
this.canCollapse =
|
|
keywordLower.isNullOrEmpty() && (selectedCategory == null || selectedCategory == EmojiCategory.Custom)
|
|
|
|
adapter.list = buildList {
|
|
val filteredCategories = pickerCategries.filter {
|
|
selectedCategory == null || it.category == selectedCategory
|
|
}.mapNotNull { category ->
|
|
category.createFiltered(keywordLower)
|
|
.takeIf { it.items.isNotEmpty() }
|
|
}
|
|
|
|
for (i in filteredCategories.indices) {
|
|
filteredCategories[i].next =
|
|
filteredCategories.elementAtOrNull(i + 1)?.original
|
|
?: filteredCategories.elementAtOrNull(i - 1)?.original
|
|
}
|
|
|
|
if (lastExpandCategory == null ||
|
|
filteredCategories.none { it.original == lastExpandCategory }
|
|
) lastExpandCategory = filteredCategories.firstOrNull()?.original
|
|
|
|
filteredCategories.forEach {
|
|
if (selectedCategory == null || it.category == EmojiCategory.Custom) {
|
|
// 見出し付き表示の場合は折りたたむ可能性がある
|
|
add(it)
|
|
if (!canCollapse || lastExpandCategory == it.original) addAll(it.items)
|
|
} else {
|
|
// カスタム以外のカテゴリが選択されている場合、（ヘッダがなく解除できないので) 折りたたみはできない
|
|
addAll(it.items)
|
|
}
|
|
}
|
|
}
|
|
|
|
val targetCategory = lastExpandCategory
|
|
if (scrollToCategory && targetCategory != null) {
|
|
views.root.handler?.postDelayed({
|
|
adapter.list.indexOfFirst { (it as? PickerItemCategory)?.original == targetCategory }
|
|
.takeIf { it != -1 }
|
|
?.let { views.rvGrid.smoothScrollToPosition(it) }
|
|
}, 100L)
|
|
}
|
|
|
|
for (it in views.llCategories.children) {
|
|
val backgroundId = when (it.tag) {
|
|
selectedCategory -> R.drawable.bg_button_cw
|
|
else -> R.drawable.btn_bg_transparent_round6dp
|
|
}
|
|
it.background = ContextCompat.getDrawable(it.context, backgroundId)
|
|
|
|
if (it.tag == selectedCategory && scrollCategoryTab) {
|
|
val oldScrollX = views.svCategories.scrollX
|
|
val visibleWidth = views.svCategories.width
|
|
log.i("left=${it.left},r=${it.right},s=$oldScrollX")
|
|
when {
|
|
oldScrollX > it.left ->
|
|
views.svCategories.smoothScrollTo(it.left, 0)
|
|
oldScrollX + visibleWidth < it.right ->
|
|
views.svCategories.smoothScrollTo(it.right - visibleWidth, 0)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun addCategoryButton(category: EmojiCategory) {
|
|
val density = activity.resources.displayMetrics.density
|
|
val wrapContent = FlexboxLayout.LayoutParams.WRAP_CONTENT
|
|
val minWidth = (density * 48f + 0.5f).toInt()
|
|
val padTb = (density * 4f + 0.5f).toInt()
|
|
val padLr = (density * 6f + 0.5f).toInt()
|
|
AppCompatButton(activity).apply {
|
|
tag = category
|
|
layoutParams = FlexboxLayout.LayoutParams(wrapContent, wrapContent)
|
|
background =
|
|
ContextCompat.getDrawable(context, R.drawable.btn_bg_transparent_round6dp)
|
|
minWidthCompat = minWidth
|
|
minHeightCompat = minWidth
|
|
setPadding(padLr, padTb, padLr, padTb)
|
|
text = activity?.getString(category.titleId)
|
|
setOnClickListener {
|
|
views.etFilter.removeTextChangedListener(textWatcher)
|
|
views.etFilter.setText("")
|
|
views.etFilter.addTextChangedListener(textWatcher)
|
|
showFiltered(category, null)
|
|
}
|
|
}.let { views.llCategories.addView(it) }
|
|
}
|
|
|
|
private fun movePage(delta: Int) {
|
|
val categories = buildList {
|
|
addAll(pickerCategries.map { it.category }.distinct().sorted())
|
|
}
|
|
val newIndex = when (
|
|
val oldIndex = categories.indexOfFirst { it == lastSelectedCategory }
|
|
) {
|
|
-1 -> if (delta > 0) 0 else categories.size - 1
|
|
else -> (oldIndex + categories.size + delta) % categories.size
|
|
}
|
|
val newCategory = categories[newIndex]
|
|
showFiltered(newCategory, null)
|
|
}
|
|
|
|
private fun View.setButtonBackground() {
|
|
background = ContextCompat.getDrawable(context, R.drawable.btn_bg_transparent_round6dp)
|
|
}
|
|
|
|
private fun handleTouch(ev: MotionEvent, wasIntercept: Boolean) =
|
|
try {
|
|
when (ev.actionMasked) {
|
|
MotionEvent.ACTION_CANCEL -> {
|
|
log.i("ACTION_CANCEL wasIntercept=$wasIntercept")
|
|
dragging = FlickStatus.None
|
|
wasIntercept
|
|
}
|
|
MotionEvent.ACTION_UP -> {
|
|
try {
|
|
log.i("ACTION_UP wasIntercept=$wasIntercept")
|
|
if (dragging == FlickStatus.Intercepted) {
|
|
tracker?.let {
|
|
it.addMovement(ev)
|
|
it.computeCurrentVelocity(1000)
|
|
val vx = it.xVelocity
|
|
val vy = it.yVelocity
|
|
val vxDp = vx / density
|
|
val aspect = abs(vx) / abs(vy)
|
|
log.i("vx=$vx vy=$vy")
|
|
if (aspect < 2f) {
|
|
log.i("not gesture: aspect=$aspect")
|
|
} else if (abs(vxDp) < 40f) {
|
|
log.i("not gesture: vxDp=$vxDp")
|
|
} else {
|
|
movePage((vxDp.sign * -1f).toInt())
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
dragging = FlickStatus.None
|
|
}
|
|
wasIntercept
|
|
}
|
|
MotionEvent.ACTION_DOWN -> {
|
|
log.i("ACTION_DOWN wasIntercept=$wasIntercept")
|
|
// ドラッグ開始
|
|
dragging = FlickStatus.Start
|
|
if (tracker == null) {
|
|
tracker = VelocityTracker.obtain()
|
|
}
|
|
tracker?.clear()
|
|
startX = ev.x
|
|
startY = ev.y
|
|
wasIntercept
|
|
}
|
|
MotionEvent.ACTION_MOVE -> {
|
|
if (dragging == FlickStatus.None) {
|
|
wasIntercept
|
|
} else {
|
|
// 移動量追跡
|
|
tracker?.addMovement(ev)
|
|
val deltaX = abs(ev.x - startX) / density
|
|
val deltaY = abs(ev.y - startY) / density
|
|
when {
|
|
// すでにインターセプトしている
|
|
wasIntercept -> true
|
|
|
|
// 上下方向に大きく動かしたらそれ以上追跡しない
|
|
deltaY >= cancelY -> {
|
|
log.i("not flick! $deltaY")
|
|
dragging = FlickStatus.None
|
|
false
|
|
}
|
|
|
|
// 横方向に大きく動かしたらインターセプトする
|
|
deltaX >= interceptX && deltaX > deltaY -> {
|
|
log.i("intercept! $deltaX")
|
|
dragging = FlickStatus.Intercepted
|
|
true
|
|
}
|
|
else -> {
|
|
log.d("not yet intercept. $deltaX, $deltaY")
|
|
false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else -> log.w("handleTouch else $ev")
|
|
}
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "handleTouch failed. ev=$ev, wasIntercept=$wasIntercept")
|
|
wasIntercept
|
|
}
|
|
|
|
suspend fun start() {
|
|
pickerCategries = buildCategoryList()
|
|
|
|
bInstanceHasCustomEmoji = pickerCategries.any { it.category == EmojiCategory.Custom }
|
|
|
|
pickerCategries.map { it.category }.distinct().sorted().forEach {
|
|
addCategoryButton(it)
|
|
}
|
|
|
|
views.etFilter.addTextChangedListener(textWatcher)
|
|
|
|
showFiltered(null, null)
|
|
|
|
views.giGrid.intercept = { handleTouch(it, wasIntercept = false) }
|
|
views.giGrid.touch = { handleTouch(it, wasIntercept = true) }
|
|
|
|
views.rvGrid.adapter = adapter
|
|
|
|
views.rvGrid.layoutManager = FlexboxLayoutManagerWrapper(activity).apply {
|
|
flexDirection = FlexDirection.ROW
|
|
flexWrap = FlexWrap.WRAP
|
|
justifyContent = JustifyContent.FLEX_START
|
|
}
|
|
|
|
//
|
|
// gridCols,
|
|
// RecyclerView.VERTICAL,
|
|
// false
|
|
// ).also {
|
|
// it.spanSizeLookup = adapter.spanSizeLookup
|
|
// }
|
|
|
|
showSkinTone()
|
|
|
|
this.dialog = Dialog(activity)
|
|
dialog.setContentView(views.root)
|
|
dialog.setCancelable(true)
|
|
dialog.setCanceledOnTouchOutside(true)
|
|
dialog.setOnDismissListener {
|
|
tracker?.recycle()
|
|
}
|
|
dialog.window?.let { w ->
|
|
@Suppress("DEPRECATION")
|
|
w.setSoftInputMode(
|
|
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE or
|
|
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
|
|
)
|
|
}
|
|
dialog.show()
|
|
}
|
|
}
|
|
|
|
fun launchEmojiPicker(
|
|
activity: AppCompatActivity,
|
|
accessInfo: SavedAccount?,
|
|
closeOnSelected: Boolean,
|
|
onPicked: suspend (EmojiBase, bInstanceHasCustomEmoji: Boolean) -> Unit,
|
|
) = activity.launchAndShowError {
|
|
EmojiPicker(
|
|
activity = activity,
|
|
accessInfo = accessInfo,
|
|
closeOnSelected = closeOnSelected,
|
|
onPicked = onPicked,
|
|
).start()
|
|
}
|