392 lines
12 KiB
Kotlin
392 lines
12 KiB
Kotlin
package jp.juggler.util
|
|
|
|
import android.content.*
|
|
import android.content.res.ColorStateList
|
|
import android.content.res.TypedArray
|
|
import android.graphics.Color
|
|
import android.graphics.ColorFilter
|
|
import android.graphics.PorterDuff
|
|
import android.graphics.PorterDuffColorFilter
|
|
import android.graphics.drawable.Drawable
|
|
import android.graphics.drawable.GradientDrawable
|
|
import android.graphics.drawable.RippleDrawable
|
|
import android.graphics.drawable.ShapeDrawable
|
|
import android.graphics.drawable.shapes.RectShape
|
|
import android.os.SystemClock
|
|
import android.text.Editable
|
|
import android.text.TextWatcher
|
|
import android.util.SparseArray
|
|
import android.view.View
|
|
import android.widget.ImageButton
|
|
import android.widget.ImageView
|
|
import androidx.activity.ComponentActivity
|
|
import androidx.activity.result.ActivityResult
|
|
import androidx.activity.result.ActivityResultLauncher
|
|
import androidx.activity.result.contract.ActivityResultContracts
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.core.app.ActivityOptionsCompat
|
|
import androidx.core.content.ContextCompat
|
|
import jp.juggler.subwaytooter.R
|
|
import java.util.*
|
|
|
|
object UiUtils {
|
|
|
|
val log = LogCategory("UiUtils")
|
|
}
|
|
|
|
// colorARGB.applyAlphaMultiplier(0.5f) でalpha値が半分になったARGB値を得る
|
|
fun Int.applyAlphaMultiplier(alphaMultiplier: Float? = null): Int {
|
|
return if (alphaMultiplier == null) {
|
|
this
|
|
} else {
|
|
val rgb = (this and 0xffffff)
|
|
val alpha = clipRange(0, 255, ((this ushr 24).toFloat() * alphaMultiplier + 0.5f).toInt())
|
|
return rgb or (alpha shl 24)
|
|
}
|
|
}
|
|
|
|
fun Context.attrColor(attrId: Int): Int {
|
|
val a = theme.obtainStyledAttributes(intArrayOf(attrId))
|
|
val color = a.getColor(0, Color.BLACK)
|
|
a.recycle()
|
|
return color
|
|
}
|
|
|
|
fun <T> TypedArray.use(block: (TypedArray) -> T): T =
|
|
try {
|
|
block(this)
|
|
} finally {
|
|
recycle()
|
|
}
|
|
|
|
fun Context.getAttributeResourceId(attrId: Int) =
|
|
theme.obtainStyledAttributes(intArrayOf(attrId))
|
|
.use { it.getResourceId(0, 0) }
|
|
.notZero() ?: error("missing resource id. attr_id=0x${attrId.toString(16)}")
|
|
|
|
fun Context.attrDrawable(attrId: Int): Drawable {
|
|
val drawableId = getAttributeResourceId(attrId)
|
|
return ContextCompat.getDrawable(this, drawableId)
|
|
?: error("getDrawable failed. drawableId=0x${drawableId.toString(16)}")
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
// 後方互換用にボタン背景Drawableを生成する
|
|
//private fun getStateListDrawable(normalColor : Int, pressedColor : Int) : StateListDrawable {
|
|
// val states = StateListDrawable()
|
|
// states.addState(intArrayOf(android.R.attr.state_pressed), ColorDrawable(pressedColor))
|
|
// states.addState(intArrayOf(android.R.attr.state_focused), ColorDrawable(pressedColor))
|
|
// states.addState(intArrayOf(android.R.attr.state_activated), ColorDrawable(pressedColor))
|
|
// states.addState(intArrayOf(), ColorDrawable(normalColor))
|
|
// return states
|
|
//}
|
|
|
|
// 色を指定してRectShapeを生成する
|
|
private fun getRectShape(color: Int): Drawable {
|
|
val r = RectShape()
|
|
val shapeDrawable = ShapeDrawable(r)
|
|
shapeDrawable.paint.color = color
|
|
return shapeDrawable
|
|
}
|
|
|
|
// 色を指定して角丸Drawableを作成する
|
|
fun createRoundDrawable(
|
|
radius: Float,
|
|
fillColor: Int? = null,
|
|
strokeColor: Int? = null,
|
|
strokeWidth: Int = 4
|
|
) =
|
|
GradientDrawable().apply {
|
|
cornerRadius = radius
|
|
if (fillColor != null) setColor(fillColor)
|
|
if (strokeColor != null) setStroke(strokeWidth, strokeColor)
|
|
}
|
|
|
|
// 色を指定してRippleDrawableを生成する
|
|
fun getAdaptiveRippleDrawable(normalColor: Int, pressedColor: Int): Drawable {
|
|
return RippleDrawable(ColorStateList.valueOf(pressedColor), getRectShape(normalColor), null)
|
|
}
|
|
|
|
// 色を指定してRippleDrawableを生成する
|
|
fun getAdaptiveRippleDrawableRound(
|
|
context: Context,
|
|
normalColor: Int,
|
|
pressedColor: Int,
|
|
roundNormal: Boolean = false
|
|
): Drawable {
|
|
val dp6 = context.resources.displayMetrics.density * 6f
|
|
return if (roundNormal) {
|
|
// 押してない時に通常色を塗る範囲も角丸にする
|
|
RippleDrawable(
|
|
ColorStateList.valueOf(pressedColor),
|
|
createRoundDrawable(dp6, fillColor = normalColor),
|
|
null
|
|
)
|
|
} else {
|
|
// 押してない時に通常色を塗る範囲は四角だが、リップルエフェクトは角丸
|
|
return RippleDrawable(
|
|
ColorStateList.valueOf(pressedColor),
|
|
getRectShape(normalColor),
|
|
createRoundDrawable(dp6, Color.WHITE)
|
|
)
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
private class ColorFilterCacheValue(
|
|
val filter: ColorFilter,
|
|
var lastUsed: Long
|
|
)
|
|
|
|
private val colorFilterCache = SparseArray<ColorFilterCacheValue>()
|
|
private var colorFilterCacheLastSweep = 0L
|
|
|
|
private fun createColorFilter(rgb: Int): ColorFilter {
|
|
synchronized(colorFilterCache) {
|
|
val now = SystemClock.elapsedRealtime()
|
|
val cacheValue = colorFilterCache[rgb]
|
|
if (cacheValue != null) {
|
|
cacheValue.lastUsed = now
|
|
return cacheValue.filter
|
|
}
|
|
|
|
val size = colorFilterCache.size()
|
|
if (now - colorFilterCacheLastSweep >= 10000L && size >= 128) {
|
|
colorFilterCacheLastSweep = now
|
|
for (i in size - 1 downTo 0) {
|
|
val v = colorFilterCache.valueAt(i)
|
|
if (now - v.lastUsed >= 10000L) {
|
|
colorFilterCache.removeAt(i)
|
|
}
|
|
}
|
|
}
|
|
|
|
val f = PorterDuffColorFilter(rgb, PorterDuff.Mode.SRC_ATOP)
|
|
colorFilterCache.put(rgb, ColorFilterCacheValue(f, now))
|
|
return f
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
|
|
private class ColoredDrawableCacheKey(
|
|
val drawableId: Int,
|
|
val rgb: Int,
|
|
val alpha: Int
|
|
) {
|
|
|
|
override fun equals(other: Any?): Boolean {
|
|
return this === other || (
|
|
other is ColoredDrawableCacheKey
|
|
&& drawableId == other.drawableId
|
|
&& rgb == other.rgb
|
|
&& alpha == other.alpha
|
|
)
|
|
}
|
|
|
|
override fun hashCode(): Int {
|
|
return drawableId xor (rgb or (alpha shl 24))
|
|
}
|
|
}
|
|
|
|
private class ColoredDrawableCacheValue(
|
|
val drawable: Drawable,
|
|
var lastUsed: Long
|
|
)
|
|
|
|
private val coloredDrawableCache = HashMap<ColoredDrawableCacheKey, ColoredDrawableCacheValue>()
|
|
private var coloredDrawableCacheLastSweep = 0L
|
|
|
|
fun createColoredDrawable(
|
|
context: Context,
|
|
drawableId: Int,
|
|
color: Int,
|
|
alphaMultiplier: Float
|
|
): Drawable {
|
|
val rgb = (color and 0xffffff) or Color.BLACK
|
|
val alpha = if (alphaMultiplier >= 1f) {
|
|
(color ushr 24)
|
|
} else {
|
|
clipRange(0, 255, ((color ushr 24).toFloat() * alphaMultiplier + 0.5f).toInt())
|
|
}
|
|
|
|
val cacheKey = ColoredDrawableCacheKey(drawableId, rgb, alpha)
|
|
synchronized(coloredDrawableCache) {
|
|
val now = SystemClock.elapsedRealtime()
|
|
val cacheValue = coloredDrawableCache[cacheKey]
|
|
if (cacheValue != null) {
|
|
cacheValue.lastUsed = now
|
|
return cacheValue.drawable
|
|
}
|
|
|
|
if (now - coloredDrawableCacheLastSweep >= 10000L && coloredDrawableCache.size >= 128) {
|
|
coloredDrawableCacheLastSweep = now
|
|
val list = coloredDrawableCache.entries.sortedBy { it.value.lastUsed }
|
|
for (i in 0 until list.size - 64) {
|
|
val (k, v) = list[i]
|
|
if (now - v.lastUsed <= 10000L) break
|
|
coloredDrawableCache.remove(k)
|
|
}
|
|
}
|
|
|
|
// 色指定が他のアイコンに影響しないようにする
|
|
// カラーフィルターとアルファ値を設定する
|
|
val d = ContextCompat.getDrawable(context, drawableId)!!.mutate()
|
|
d.colorFilter = createColorFilter(rgb)
|
|
d.alpha = alpha
|
|
coloredDrawableCache[cacheKey] = ColoredDrawableCacheValue(d, now)
|
|
return d
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
fun setIconDrawableId(
|
|
context: Context,
|
|
imageView: ImageView,
|
|
drawableId: Int,
|
|
color: Int? = null,
|
|
alphaMultiplier: Float
|
|
) {
|
|
if (color == null) {
|
|
// ImageViewにアイコンを設定する。デフォルトの色
|
|
imageView.setImageDrawable(ContextCompat.getDrawable(context, drawableId))
|
|
} else {
|
|
imageView.setImageDrawable(
|
|
createColoredDrawable(
|
|
context,
|
|
drawableId,
|
|
color,
|
|
alphaMultiplier
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
//fun setIconAttr(
|
|
// context : Context,
|
|
// imageView : ImageView,
|
|
// iconAttrId : Int,
|
|
// color : Int? = null,
|
|
// alphaMultiplier : Float? = null
|
|
//) {
|
|
// setIconDrawableId(
|
|
// context,
|
|
// imageView,
|
|
// getAttributeResourceId(context, iconAttrId),
|
|
// color,
|
|
// alphaMultiplier
|
|
// )
|
|
//}
|
|
|
|
fun CharSequence.copyToClipboard(context: Context) {
|
|
try {
|
|
// Gets a handle to the clipboard service.
|
|
val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
|
|
?: throw NotImplementedError("missing ClipboardManager system service")
|
|
|
|
// Creates a new text clip to put on the clipboard
|
|
val clip = ClipData.newPlainText("text", this)
|
|
|
|
// Set the clipboard's primary clip.
|
|
|
|
clipboard.setPrimaryClip(clip)
|
|
|
|
context.showToast(false, R.string.copy_complete)
|
|
} catch (ex: Throwable) {
|
|
UiUtils.log.trace(ex)
|
|
context.showToast(ex, "copy failed.")
|
|
}
|
|
|
|
}
|
|
|
|
fun DialogInterface.dismissSafe() {
|
|
try {
|
|
dismiss()
|
|
} catch (ignored: Throwable) {
|
|
// 非同期処理の後などではDialogがWindowTokenを失っている場合があり、IllegalArgumentException がたまに出る
|
|
}
|
|
}
|
|
|
|
class CustomTextWatcher(
|
|
val callback: () -> Unit
|
|
) : 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) {
|
|
callback()
|
|
}
|
|
}
|
|
|
|
// ImageButton のForeground colorで有効/無効を表現する
|
|
fun ImageButton.setEnabledColor(context: Context, iconId: Int, color: Int, enabled: Boolean) {
|
|
isEnabled = enabled
|
|
setImageDrawable(
|
|
createColoredDrawable(
|
|
context = context,
|
|
drawableId = iconId,
|
|
color = color,
|
|
alphaMultiplier = when (enabled) {
|
|
true -> 1f
|
|
else -> 0.5f
|
|
}
|
|
)
|
|
)
|
|
}
|
|
|
|
var View.isEnabledAlpha :Boolean
|
|
get() = isEnabled
|
|
set(enabled){
|
|
this.isEnabled = enabled
|
|
this.alpha = when (enabled) {
|
|
true -> 1f
|
|
else -> 0.3f
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
|
|
class ActivityResultHandler<A : ComponentActivity>(
|
|
val callback: A.(ActivityResult?) -> Unit
|
|
) {
|
|
private lateinit var log: LogCategory
|
|
private lateinit var context: Context
|
|
private lateinit var launcher: ActivityResultLauncher<Intent>
|
|
|
|
// startForActivityResultの代わりに呼び出す
|
|
fun launch(intent: Intent,options: ActivityOptionsCompat?=null) = try {
|
|
launcher.launch(intent,options)
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "launch failed")
|
|
context.showToast(ex, "activity launch failed.")
|
|
}
|
|
|
|
// onCreate時に呼び出す
|
|
fun register(a: A, log: LogCategory) {
|
|
this.log = log
|
|
this.context = a.applicationContext
|
|
this.launcher = a.registerForActivityResult(
|
|
ActivityResultContracts.StartActivityForResult()
|
|
) { callback(a, it) }
|
|
}
|
|
}
|
|
|
|
@Suppress("unused")
|
|
fun <A : ComponentActivity> A.activityResultHandler(callback: A.(ActivityResult?) -> Unit) =
|
|
ActivityResultHandler(callback)
|
|
|
|
val AppCompatActivity.isLiveActivity: Boolean
|
|
get() = !(isFinishing || isDestroyed)
|