470 lines
17 KiB
Kotlin
470 lines
17 KiB
Kotlin
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.fenix.settings
|
|
|
|
/*
|
|
* Copyright 2018 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import android.content.Context
|
|
import android.content.res.TypedArray
|
|
import android.os.Parcel
|
|
import android.os.Parcelable
|
|
import android.util.AttributeSet
|
|
import android.util.Log
|
|
import android.util.TypedValue
|
|
import android.view.KeyEvent
|
|
import android.view.View
|
|
import android.view.accessibility.AccessibilityNodeInfo
|
|
import android.widget.SeekBar
|
|
import android.widget.SeekBar.OnSeekBarChangeListener
|
|
import android.widget.TextView
|
|
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.RangeInfoCompat.RANGE_TYPE_PERCENT
|
|
import androidx.preference.Preference
|
|
import androidx.preference.PreferenceViewHolder
|
|
import org.mozilla.fenix.R
|
|
|
|
import java.text.NumberFormat
|
|
import kotlin.math.PI
|
|
import kotlin.math.roundToInt
|
|
|
|
/**
|
|
* Preference based on android.preference.SeekBarPreference but uses support preference as a base.
|
|
* It contains a title and a [SeekBar] and a SeekBar value [TextView] and an Example [TextView].
|
|
* The actual preference layout is customizable by setting `android:layout` on the
|
|
* preference widget layout or `seekBarPreferenceStyle` attribute.
|
|
*
|
|
* The [SeekBar] within the preference can be defined adjustable or not by setting `adjustable` attribute.
|
|
* If adjustable, the preference will be responsive to DPAD left/right keys.
|
|
* Otherwise, it skips those keys.
|
|
*
|
|
* The [SeekBar] value view can be shown or disabled by setting `showSeekBarValue`
|
|
* attribute to true or false, respectively.
|
|
*
|
|
* Other [SeekBar] specific attributes (e.g. `title, summary, defaultValue, min, max`)
|
|
* can be set directly on the preference widget layout.
|
|
*/
|
|
@SuppressWarnings("LargeClass")
|
|
class TextPercentageSeekBarPreference @JvmOverloads constructor(
|
|
context: Context,
|
|
attrs: AttributeSet? = null,
|
|
defStyleAttr: Int = R.attr.seekBarPreferenceStyle,
|
|
defStyleRes: Int = 0
|
|
) : Preference(context, attrs, defStyleAttr, defStyleRes) {
|
|
/* synthetic access */
|
|
internal var mSeekBarValue: Int = 0
|
|
/* synthetic access */
|
|
internal var mMin: Int = 0
|
|
private var mMax: Int = 0
|
|
private var mSeekBarIncrement: Int = 0
|
|
/* synthetic access */
|
|
internal var mTrackingTouch: Boolean = false
|
|
/* synthetic access */
|
|
internal var mSeekBar: SeekBar? = null
|
|
private var mSeekBarValueTextView: TextView? = null
|
|
private var mExampleTextTextView: TextView? = null
|
|
/**
|
|
* Whether the SeekBar should respond to the left/right keys
|
|
*/
|
|
/* synthetic access */
|
|
var isAdjustable: Boolean = false
|
|
/**
|
|
* Whether to show the SeekBar value TextView next to the bar
|
|
*/
|
|
private var mShowSeekBarValue: Boolean = false
|
|
/**
|
|
* Whether the SeekBarPreference should continuously save the Seekbar value while it is being dragged.
|
|
*/
|
|
/* synthetic access */
|
|
var updatesContinuously: Boolean = false
|
|
/**
|
|
* Listener reacting to the [SeekBar] changing value by the user
|
|
*/
|
|
private val mSeekBarChangeListener = object : OnSeekBarChangeListener {
|
|
override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
|
|
if (fromUser && (updatesContinuously || !mTrackingTouch)) {
|
|
syncValueInternal(seekBar)
|
|
} else {
|
|
// We always want to update the text while the seekbar is being dragged
|
|
updateLabelValue(progress + mMin)
|
|
updateExampleTextValue(progress + mMin)
|
|
}
|
|
}
|
|
|
|
override fun onStartTrackingTouch(seekBar: SeekBar) {
|
|
mTrackingTouch = true
|
|
}
|
|
|
|
override fun onStopTrackingTouch(seekBar: SeekBar) {
|
|
mTrackingTouch = false
|
|
if (seekBar.progress + mMin != mSeekBarValue) {
|
|
syncValueInternal(seekBar)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Listener reacting to the user pressing DPAD left/right keys if `adjustable` attribute is
|
|
* set to true; it transfers the key presses to the [SeekBar]
|
|
* to be handled accordingly.
|
|
*/
|
|
private val mSeekBarKeyListener = View.OnKeyListener { _, keyCode, event ->
|
|
return@OnKeyListener if (event.action != KeyEvent.ACTION_DOWN) {
|
|
false
|
|
} else if (!isAdjustable && (keyCode == KeyEvent.KEYCODE_DPAD_LEFT || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT)) {
|
|
// Right or left keys are pressed when in non-adjustable mode; Skip the keys.
|
|
false
|
|
} else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_ENTER) {
|
|
// We don't want to propagate the click keys down to the SeekBar view since it will
|
|
// create the ripple effect for the thumb.
|
|
false
|
|
} else if (mSeekBar == null) {
|
|
Log.e(TAG, "SeekBar view is null and hence cannot be adjusted.")
|
|
false
|
|
} else {
|
|
mSeekBar!!.onKeyDown(keyCode, event)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the lower bound set on the [SeekBar].
|
|
* @return The lower bound set
|
|
* Sets the lower bound on the [SeekBar].
|
|
* @param min The lower bound to set
|
|
*/
|
|
var min: Int
|
|
get() = mMin
|
|
set(min) {
|
|
var minimum = min
|
|
if (minimum > mMax) {
|
|
minimum = mMax
|
|
}
|
|
if (minimum != mMin) {
|
|
mMin = minimum
|
|
notifyChanged()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the amount of increment change via each arrow key click. This value is derived from
|
|
* user's specified increment value if it's not zero. Otherwise, the default value is picked
|
|
* from the default mKeyProgressIncrement value in [android.widget.AbsSeekBar].
|
|
* @return The amount of increment on the [SeekBar] performed after each user's arrow
|
|
* key press
|
|
*/
|
|
var seekBarIncrement: Int
|
|
get() = mSeekBarIncrement
|
|
/**
|
|
* Sets the increment amount on the [SeekBar] for each arrow key press.
|
|
* @param seekBarIncrement The amount to increment or decrement when the user presses an
|
|
* arrow key.
|
|
*/
|
|
set(seekBarIncrement) {
|
|
if (seekBarIncrement != mSeekBarIncrement) {
|
|
mSeekBarIncrement = Math.min(mMax - mMin, Math.abs(seekBarIncrement))
|
|
notifyChanged()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets/Sets the upper bound set on the [SeekBar].
|
|
*/
|
|
var max: Int
|
|
get() = mMax
|
|
set(max) {
|
|
var maximum = max
|
|
if (maximum < mMin) {
|
|
maximum = mMin
|
|
}
|
|
if (maximum != mMax) {
|
|
mMax = maximum
|
|
notifyChanged()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets whether the current [SeekBar] value is displayed to the user.
|
|
* @return Whether the current [SeekBar] value is displayed to the user
|
|
* @see .setShowSeekBarValue
|
|
*/
|
|
var showSeekBarValue: Boolean
|
|
get() = mShowSeekBarValue
|
|
/**
|
|
* Sets whether the current [SeekBar] value is displayed to the user.
|
|
* @param showSeekBarValue Whether the current [SeekBar] value is displayed to the user
|
|
* @see .getShowSeekBarValue
|
|
*/
|
|
set(showSeekBarValue) {
|
|
mShowSeekBarValue = showSeekBarValue
|
|
notifyChanged()
|
|
}
|
|
|
|
/**
|
|
* Gets/Sets the current progress of the [SeekBar].
|
|
*/
|
|
var value: Int
|
|
get() = mSeekBarValue
|
|
set(seekBarValue) = setValueInternal(seekBarValue, true)
|
|
|
|
init {
|
|
val a = context.obtainStyledAttributes(
|
|
attrs, R.styleable.SeekBarPreference, defStyleAttr, defStyleRes
|
|
)
|
|
|
|
// The ordering of these two statements are important. If we want to set max first, we need
|
|
// to perform the same steps by changing min/max to max/min as following:
|
|
// mMax = a.getInt(...) and setMin(...).
|
|
mMin = a.getInt(R.styleable.SeekBarPreference_min, 0)
|
|
max = a.getInt(R.styleable.SeekBarPreference_android_max, SEEK_BAR_MAX)
|
|
seekBarIncrement = a.getInt(R.styleable.SeekBarPreference_seekBarIncrement, 0)
|
|
isAdjustable = a.getBoolean(R.styleable.SeekBarPreference_adjustable, true)
|
|
mShowSeekBarValue = a.getBoolean(R.styleable.SeekBarPreference_showSeekBarValue, false)
|
|
updatesContinuously = a.getBoolean(
|
|
R.styleable.SeekBarPreference_updatesContinuously,
|
|
false
|
|
)
|
|
a.recycle()
|
|
}
|
|
|
|
override fun onBindViewHolder(view: PreferenceViewHolder) {
|
|
super.onBindViewHolder(view)
|
|
view.itemView.setOnKeyListener(mSeekBarKeyListener)
|
|
mSeekBar = view.findViewById(R.id.seekbar) as SeekBar
|
|
mExampleTextTextView = view.findViewById(R.id.sampleText) as TextView
|
|
mSeekBarValueTextView = view.findViewById(R.id.seekbar_value) as TextView
|
|
if (mShowSeekBarValue) {
|
|
mSeekBarValueTextView?.visibility = View.VISIBLE
|
|
} else {
|
|
mSeekBarValueTextView?.visibility = View.GONE
|
|
mSeekBarValueTextView = null
|
|
}
|
|
|
|
if (mSeekBar == null) {
|
|
Log.e(TAG, "SeekBar view is null in onBindViewHolder.")
|
|
return
|
|
}
|
|
mSeekBar?.setOnSeekBarChangeListener(mSeekBarChangeListener)
|
|
mSeekBar?.max = mMax - mMin
|
|
// If the increment is not zero, use that. Otherwise, use the default mKeyProgressIncrement
|
|
// in AbsSeekBar when it's zero. This default increment value is set by AbsSeekBar
|
|
// after calling setMax. That's why it's important to call setKeyProgressIncrement after
|
|
// calling setMax() since setMax() can change the increment value.
|
|
if (mSeekBarIncrement != 0) {
|
|
mSeekBar?.keyProgressIncrement = mSeekBarIncrement
|
|
} else {
|
|
mSeekBarIncrement = mSeekBar!!.keyProgressIncrement
|
|
}
|
|
|
|
mSeekBar?.progress = mSeekBarValue - mMin
|
|
updateExampleTextValue(mSeekBarValue)
|
|
updateLabelValue(mSeekBarValue)
|
|
mSeekBar?.isEnabled = isEnabled
|
|
mSeekBar?.let {
|
|
it.thumbOffset = it.thumb.intrinsicWidth.div(2 * PI).roundToInt()
|
|
}
|
|
}
|
|
|
|
override fun onSetInitialValue(initialValue: Any?) {
|
|
var defaultValue = initialValue
|
|
if (defaultValue == null) {
|
|
defaultValue = 0
|
|
}
|
|
value = getPersistedInt((defaultValue as Int?)!!)
|
|
}
|
|
|
|
override fun onGetDefaultValue(a: TypedArray?, index: Int): Any {
|
|
return a!!.getInt(index, 0)
|
|
}
|
|
|
|
private fun setValueInternal(value: Int, notifyChanged: Boolean) {
|
|
var seekBarValue = value
|
|
if (seekBarValue < mMin) {
|
|
seekBarValue = mMin
|
|
}
|
|
if (seekBarValue > mMax) {
|
|
seekBarValue = mMax
|
|
}
|
|
|
|
if (seekBarValue != mSeekBarValue) {
|
|
mSeekBarValue = seekBarValue
|
|
updateLabelValue(mSeekBarValue)
|
|
updateExampleTextValue(mSeekBarValue)
|
|
persistInt(seekBarValue)
|
|
if (notifyChanged) {
|
|
notifyChanged()
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Persist the [SeekBar]'s SeekBar value if callChangeListener returns true, otherwise
|
|
* set the [SeekBar]'s value to the stored value.
|
|
*/
|
|
/* synthetic access */
|
|
internal fun syncValueInternal(seekBar: SeekBar) {
|
|
val seekBarValue = mMin + seekBar.progress
|
|
if (seekBarValue != mSeekBarValue) {
|
|
if (callChangeListener(seekBarValue)) {
|
|
setValueInternal(seekBarValue, false)
|
|
} else {
|
|
seekBar.progress = mSeekBarValue - mMin
|
|
updateLabelValue(mSeekBarValue)
|
|
updateExampleTextValue(mSeekBarValue)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempts to update the TextView label that displays the current value.
|
|
*
|
|
* @param labelValue the value to display next to the [SeekBar]
|
|
*/
|
|
/* synthetic access */
|
|
internal fun updateLabelValue(labelValue: Int) {
|
|
var value = labelValue
|
|
if (mSeekBarValueTextView != null) {
|
|
value = value * STEP_SIZE + MIN_VALUE
|
|
val decimalValue = (value / DECIMAL_CONVERSION).toDouble()
|
|
val percentage = NumberFormat.getPercentInstance().format(decimalValue)
|
|
mSeekBarValueTextView?.text = percentage
|
|
}
|
|
|
|
mSeekBar?.setAccessibilityDelegate(object :
|
|
View.AccessibilityDelegate() {
|
|
override fun onInitializeAccessibilityNodeInfo(
|
|
host: View?,
|
|
info: AccessibilityNodeInfo?
|
|
) {
|
|
super.onInitializeAccessibilityNodeInfo(host, info)
|
|
val initialInfo = info?.rangeInfo
|
|
info?.rangeInfo = initialInfo?.let {
|
|
AccessibilityNodeInfo.RangeInfo.obtain(
|
|
RANGE_TYPE_PERCENT,
|
|
MIN_VALUE.toFloat(),
|
|
SEEK_BAR_MAX.toFloat(),
|
|
convertCurrentValue(it.current)
|
|
)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Attempts to update the example TextView text with text scale size.
|
|
*
|
|
* @param textValue the value of text size
|
|
*/
|
|
internal fun updateExampleTextValue(textValue: Int) {
|
|
var value = textValue
|
|
if (mExampleTextTextView != null) {
|
|
value = value * STEP_SIZE + MIN_VALUE
|
|
val decimal = value / DECIMAL_CONVERSION
|
|
val textSize = TEXT_SIZE * decimal
|
|
mExampleTextTextView?.setTextSize(TypedValue.COMPLEX_UNIT_SP, textSize)
|
|
}
|
|
}
|
|
|
|
override fun onSaveInstanceState(): Parcelable {
|
|
val superState = super.onSaveInstanceState()
|
|
if (isPersistent) {
|
|
// No need to save instance state since it's persistent
|
|
return superState
|
|
}
|
|
|
|
// Save the instance state
|
|
val myState = SavedState(superState)
|
|
myState.mSeekBarValue = mSeekBarValue
|
|
myState.mMin = mMin
|
|
myState.mMax = mMax
|
|
return myState
|
|
}
|
|
|
|
override fun onRestoreInstanceState(state: Parcelable?) {
|
|
if (state?.javaClass != SavedState::class.java) {
|
|
// Didn't save state for us in onSaveInstanceState
|
|
super.onRestoreInstanceState(state)
|
|
return
|
|
}
|
|
|
|
// Restore the instance state
|
|
val myState = state as SavedState?
|
|
super.onRestoreInstanceState(myState!!.superState)
|
|
mSeekBarValue = myState.mSeekBarValue
|
|
mMin = myState.mMin
|
|
mMax = myState.mMax
|
|
notifyChanged()
|
|
}
|
|
|
|
/**
|
|
* SavedState, a subclass of [BaseSavedState], will store the state of this preference.
|
|
*
|
|
*
|
|
* It is important to always call through to super methods.
|
|
*/
|
|
private class SavedState : BaseSavedState {
|
|
|
|
internal var mSeekBarValue: Int = 0
|
|
internal var mMin: Int = 0
|
|
internal var mMax: Int = 0
|
|
|
|
internal constructor(source: Parcel) : super(source) {
|
|
|
|
// Restore the click counter
|
|
mSeekBarValue = source.readInt()
|
|
mMin = source.readInt()
|
|
mMax = source.readInt()
|
|
}
|
|
|
|
internal constructor(superState: Parcelable) : super(superState)
|
|
|
|
override fun writeToParcel(dest: Parcel, flags: Int) {
|
|
super.writeToParcel(dest, flags)
|
|
|
|
// Save the click counter
|
|
dest.writeInt(mSeekBarValue)
|
|
dest.writeInt(mMin)
|
|
dest.writeInt(mMax)
|
|
}
|
|
|
|
companion object {
|
|
@JvmField
|
|
val CREATOR: Parcelable.Creator<SavedState> = object : Parcelable.Creator<SavedState> {
|
|
override fun createFromParcel(`in`: Parcel): SavedState {
|
|
return SavedState(`in`)
|
|
}
|
|
|
|
override fun newArray(size: Int): Array<SavedState?> {
|
|
return arrayOfNulls(size)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun convertCurrentValue(current: Float): Float {
|
|
return current * STEP_SIZE + MIN_VALUE.toFloat()
|
|
}
|
|
|
|
companion object {
|
|
private const val TAG = "SeekBarPreference"
|
|
private const val STEP_SIZE = 5
|
|
private const val MIN_VALUE = 50
|
|
private const val DECIMAL_CONVERSION = 100f
|
|
private const val TEXT_SIZE = 16f
|
|
private const val SEEK_BAR_MAX = 100
|
|
}
|
|
}
|