Skip to content

Instantly share code, notes, and snippets.

@PollyGlot

PollyGlot/FilterActivity.kt

Created January 3, 2020 15:45
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save PollyGlot/3d75a6fa9405ad19d4fd70a6d801a140 to your computer and use it in GitHub Desktop.
Save PollyGlot/3d75a6fa9405ad19d4fd70a6d801a140 to your computer and use it in GitHub Desktop.
Download ZIP
A filter functionality I was responsible for to filter videos / playlists in search results of a Kinomap application
Raw
FilterActivity.kt
package com.kinomap.trainingapps.helper
import android.annotation.SuppressLint
import android.content.Context
import android.content.SharedPreferences
import android.content.pm.ActivityInfo
import android.os.Bundle
import android.preference.PreferenceManager
import android.util.Log
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.*
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.Toolbar
import com.crystal.crystalrangeseekbar.widgets.CrystalRangeSeekbar
import com.kinomap.api.helper.constants.PreferencesConstants.*
import com.kinomap.api.helper.model.LanguageObject
import com.kinomap.api.helper.rx.GetLanguages
import com.kinomap.api.helper.rx.GetLanguagesInterface
import com.kinomap.kinomapcommon.util.getDouble
import com.kinomap.kinomapcommon.util.putDouble
import com.kinomap.trainingapps.helper.fragment.ListPlaylistsCoachingFragment
import com.kinomap.trainingapps.helper.fragment.ListPlaylistsSectionFragment
import com.kinomap.trainingapps.helper.fragment.ListVideosCoachingFragment
import com.kinomap.trainingapps.helper.fragment.ListVideosSectionFragment
import kotlinx.android.synthetic.main.activity_filter.*
import kotlin.math.*
import androidx.core.content.ContextCompat.getSystemService
import android.icu.lang.UCharacter.GraphemeClusterBreak.T
import androidx.core.content.ContextCompat.getSystemService
import android.icu.lang.UCharacter.GraphemeClusterBreak.T
class FilterActivity : AppCompatActivity(), View.OnClickListener {
private lateinit var filterType: String
private lateinit var durationSeekBar: CrystalRangeSeekbar
private lateinit var distanceSeekBar: CrystalRangeSeekbar
private lateinit var speedSeekBar: CrystalRangeSeekbar
private lateinit var powerSeekBar: CrystalRangeSeekbar
private lateinit var slopeSeekBar: CrystalRangeSeekbar
private lateinit var difficultySeekBar: CrystalRangeSeekbar
lateinit var preferences: SharedPreferences
lateinit var spinnerArrayAdapter: ArrayAdapter<String>
var spinnerGroupId: Int? = null
var languageList = mutableListOf<LanguageObject>()
enum class RangeSeekbarType(val min: Double, val max: Double) {
DURATION(0.0, 180.0),
DISTANCE(0.0, 200.0),
SPEED(0.0, 70.0),
POWER(0.0, 800.0),
SLOPE(0.0, 2000.0),
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_filter)
// force portrait for smartphone
if (!resources.getBoolean(R.bool.isTablet)) {
requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
}
val toolbar = findViewById<Toolbar>(R.id.toolbar)
setSupportActionBar(toolbar)
supportActionBar?.setDisplayHomeAsUpEnabled(true)
supportActionBar?.setDisplayShowHomeEnabled(true)
toolbar.setNavigationIcon(R.drawable.ic_arrow_back)
preferences = PreferenceManager.getDefaultSharedPreferences(this)
filterType = intent.getStringExtra(ARGS_TYPE_FILTER)
when (filterType) {
VIDEOS_FILTER -> {
videosFilter?.visibility = View.VISIBLE
getVideosFilter()
}
PLAYLISTS_FILTER -> {
playlistsFilter?.visibility = View.VISIBLE
getPlaylistsFilter()
}
VIDEOS_COACHING_FILTER -> {
videosCoachingFilter?.visibility = View.VISIBLE
getVideosCoachingFilter()
getLanguages()
}
PLAYLISTS_COACHING_FILTER -> {
}
}
filterShowResults.setOnClickListener(this)
}
private fun getLanguages() {
GetLanguages(getLanguageInterface = getLanguageInterface).setObservable().setObserver().send()
}
private var getLanguageInterface = object : GetLanguagesInterface {
override fun onGetLanguagesSuccess(videoObject: MutableList<LanguageObject>) {
languageList.addAll(videoObject)
spinnerArrayAdapter = ArrayAdapter(this@FilterActivity, android.R.layout.simple_spinner_dropdown_item, languageList.map { languageObject -> languageObject.nativeName })
spinnerArrayAdapter.insert(resources.getString(R.string.select_language), 0)
spinnerLanguage?.adapter = spinnerArrayAdapter
languageList.find { languageObject -> languageObject.groupId == spinnerGroupId }?.let {
val position = languageList.indexOfFirst { languageObject -> languageObject.groupId == spinnerGroupId }
spinnerLanguage.setSelection(position + 1)
}
}
override fun onGetLanguagesError(e: Throwable) {
Log.e("GETLANGUAGES", e.message)
}
}
private fun getVideosFilter() {
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// ORDER BY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
when (preferences.getString(PREF_FILTER_ORDER_BY, FILTER_BY_LATEST)) {
FILTER_BY_LATEST -> orderByRecent.isChecked = true
FILTER_BY_POPULARITY -> orderByPopularity.isChecked = true
FILTER_BY_DISTANCE -> orderByDistance.isChecked = true
FILTER_BY_DURATION -> orderByDuration.isChecked = true
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SPORT TYPE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
trainingTypeCycling?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, true)
trainingTypeRunning?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, true)
trainingTypeRowing?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, true)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// MIN QUALITY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
filterSeekBarVideoQuality.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
Log.d("GREGFILTER", "quality progress $progress")
filterVideoQuality.text = when (progress) {
0 -> getString(R.string.filter_video_quality_all)
1 -> getString(R.string.filter_video_quality_medium)
2 -> getString(R.string.filter_video_quality_good)
3 -> getString(R.string.filter_video_quality_stabilized)
else -> getString(R.string.filter_video_quality_good)
}
}
override fun onStartTrackingTouch(seekBar: SeekBar?) {}
override fun onStopTrackingTouch(seekBar: SeekBar?) {}
})
filterSeekBarVideoQuality.apply {
when (preferences.getString(PREF_FILTER_VIDEO_QUALITY, QUALITY_GOOD)) {
"${QUALITY_UNDEFINED}|${QUALITY_BAD}|${QUALITY_MEDIUM}|${QUALITY_GOOD}|${QUALITY_STABILIZED}" -> {
progress = 0
filterVideoQuality.text = getString(R.string.filter_quality_all)
}
"${QUALITY_MEDIUM}|${QUALITY_GOOD}|${QUALITY_STABILIZED}" -> {
progress = 1
filterVideoQuality.text = getString(R.string.filter_quality_medium)
}
"${QUALITY_GOOD}|${QUALITY_STABILIZED}" -> {
progress = 2
filterVideoQuality.text = getString(R.string.filter_quality_good)
}
QUALITY_STABILIZED -> {
progress = 3
filterVideoQuality.text = getString(R.string.filter_video_quality_stabilized)
}
else -> {
progress = 2
filterVideoQuality.text = getString(R.string.filter_quality_good)
}
}
}
// filterVideoQuality.text = when (progress) {
// 0 -> getString(R.string.filter_video_quality_all)
// 1 -> getString(R.string.filter_video_quality_medium)
// 2 -> getString(R.string.filter_video_quality_good)
// 3 -> getString(R.string.filter_video_quality_stabilized)
// else -> getString(R.string.filter_video_quality_good)
// }
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// HIDE COMPLETED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
when (preferences.getInt(PREF_FILTER_HIDE_FINISHED_VIDEOS, HIDE_VIDEOS)) {
1 -> filterHideCompletedVideosSwitch.isChecked = true
0 -> filterHideCompletedVideosSwitch.isChecked = false
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// DURATION //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
durationSeekBar = findViewById(R.id.filterSeekBarDuration)
durationSeekBar.setMinValue(min)
durationSeekBar.setMaxValue(max)
durationSeekBar.setMinStartValue(logSeekBar(RangeSeekbarType.DURATION, preferences.getDouble(PREF_FILTER_VIDEO_DURATION_MIN, RangeSeekbarType.DURATION.min), true).toFloat())
durationSeekBar.setMaxStartValue(logSeekBar(RangeSeekbarType.DURATION, preferences.getDouble(PREF_FILTER_VIDEO_DURATION_MAX, RangeSeekbarType.DURATION.max), true).toFloat())
durationSeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
setLogSeekBar(
seekbarType = RangeSeekbarType.DURATION,
textView = filterDuration,
minValue = minValue.toDouble(),
maxValue = maxValue.toDouble()
)
}
durationSeekBar.apply()
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// DURATION //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
distanceSeekBar = findViewById(R.id.filterSeekBarDistance)
distanceSeekBar.setMinValue(min)
distanceSeekBar.setMaxValue(max)
distanceSeekBar.setMinStartValue(logSeekBar(RangeSeekbarType.DISTANCE, preferences.getDouble(PREF_FILTER_VIDEO_DISTANCE_MIN, RangeSeekbarType.DISTANCE.min), true).toFloat())
distanceSeekBar.setMaxStartValue(logSeekBar(RangeSeekbarType.DISTANCE, preferences.getDouble(PREF_FILTER_VIDEO_DISTANCE_MAX, RangeSeekbarType.DISTANCE.max), true).toFloat())
distanceSeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
setLogSeekBar(
seekbarType = RangeSeekbarType.DISTANCE,
textView = filterDistance,
minValue = minValue.toDouble(),
maxValue = maxValue.toDouble()
)
}
distanceSeekBar.apply()
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AVERAGE SPEED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
speedSeekBar = findViewById(R.id.filterSeekBarAverageSpeed)
speedSeekBar.setMinValue(min)
speedSeekBar.setMaxValue(max)
speedSeekBar.setMinStartValue(logSeekBar(RangeSeekbarType.SPEED, preferences.getDouble(PREF_FILTER_VIDEO_AVG_SPEED_MIN, RangeSeekbarType.SPEED.min), true).toFloat())
speedSeekBar.setMaxStartValue(logSeekBar(RangeSeekbarType.SPEED, preferences.getDouble(PREF_FILTER_VIDEO_AVG_SPEED_MAX, RangeSeekbarType.SPEED.max), true).toFloat())
speedSeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
setLogSeekBar(
seekbarType = RangeSeekbarType.SPEED,
textView = filterAverageSpeed,
minValue = minValue.toDouble(),
maxValue = maxValue.toDouble()
)
}
speedSeekBar.apply()
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AVERAGE POWER //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
powerSeekBar = findViewById(R.id.filterSeekBarAverageWatt)
powerSeekBar.setMinValue(min)
powerSeekBar.setMaxValue(max)
powerSeekBar.setMinStartValue(logSeekBar(RangeSeekbarType.POWER, preferences.getDouble(PREF_FILTER_VIDEO_AVG_POWER_MIN, RangeSeekbarType.POWER.min), true).toFloat())
powerSeekBar.setMaxStartValue(logSeekBar(RangeSeekbarType.POWER, preferences.getDouble(PREF_FILTER_VIDEO_AVG_POWER_MAX, RangeSeekbarType.POWER.max), true).toFloat())
powerSeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
setLogSeekBar(
seekbarType = RangeSeekbarType.POWER,
textView = filterAverageWatt,
minValue = minValue.toDouble(),
maxValue = maxValue.toDouble()
)
}
powerSeekBar.apply()
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AVERAGE POWER //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
slopeSeekBar = findViewById(R.id.filterSeekBarPositiveSlope)
slopeSeekBar.setMinValue(min)
slopeSeekBar.setMaxValue(max)
slopeSeekBar.setMinStartValue(logSeekBar(RangeSeekbarType.SLOPE, preferences.getDouble(PREF_FILTER_VIDEO_SLOPE_MIN, RangeSeekbarType.SLOPE.min), true).toFloat())
slopeSeekBar.setMaxStartValue(logSeekBar(RangeSeekbarType.SLOPE, preferences.getDouble(PREF_FILTER_VIDEO_SLOPE_MAX, RangeSeekbarType.SLOPE.max), true).toFloat())
slopeSeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
setLogSeekBar(
seekbarType = RangeSeekbarType.SLOPE,
textView = filterPositiveSlope,
minValue = minValue.toDouble(),
maxValue = maxValue.toDouble()
)
}
slopeSeekBar.apply()
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// DIFFICULTY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
difficultySeekBar = findViewById(R.id.filterSeekBarDifficulty)
difficultySeekBar.setMinValue(DIFFICULTY_1.toFloat())
difficultySeekBar.setMaxValue(DIFFICULTY_5.toFloat())
difficultySeekBar.setMinStartValue(preferences.getInt(PREF_FILTER_VIDEO_DIFFICULTY_MIN, DIFFICULTY_1).toFloat())
difficultySeekBar.setMaxStartValue(preferences.getInt(PREF_FILTER_VIDEO_DIFFICULTY_MAX, DIFFICULTY_5).toFloat())
difficultySeekBar.setOnRangeSeekbarChangeListener { minValue, maxValue ->
filterDifficulty.text = "$minValue - $maxValue"
}
difficultySeekBar.apply()
}
@SuppressLint("ApplySharedPref")
private fun setVideosFilter() {
preferences.edit().apply {
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE ORDER BY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putString(PREF_FILTER_ORDER_BY, when {
orderByRecent.isChecked -> FILTER_BY_LATEST
orderByPopularity.isChecked -> FILTER_BY_POPULARITY
orderByDistance.isChecked -> FILTER_BY_DISTANCE
orderByDuration.isChecked -> FILTER_BY_DURATION
else -> FILTER_BY_LATEST
})
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE SPORT TYPE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, trainingTypeCycling.isChecked)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, trainingTypeRunning.isChecked)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, trainingTypeRowing.isChecked)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE MIN QUALITY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putString(PREF_FILTER_VIDEO_QUALITY, when (filterSeekBarVideoQuality.progress) {
0 -> "${QUALITY_UNDEFINED}|${QUALITY_BAD}|${QUALITY_MEDIUM}|${QUALITY_GOOD}|${QUALITY_STABILIZED}"
1 -> "${QUALITY_MEDIUM}|${QUALITY_GOOD}|${QUALITY_STABILIZED}"
2 -> "${QUALITY_GOOD}|${QUALITY_STABILIZED}"
3 -> QUALITY_STABILIZED
else -> QUALITY_GOOD
})
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE HIDE COMPLETED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putInt(PREF_FILTER_HIDE_FINISHED_VIDEOS, when {
filterHideCompletedVideosSwitch.isChecked -> 1
else -> 0
})
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE DURATION //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_DURATION_MIN, logSeekBar(RangeSeekbarType.DURATION, durationSeekBar.selectedMinValue.toDouble(), false))
putDouble(PREF_FILTER_VIDEO_DURATION_MAX, logSeekBar(RangeSeekbarType.DURATION, durationSeekBar.selectedMaxValue.toDouble(), false))
Log.d("FILTERS", "save duration min ${logSeekBar(RangeSeekbarType.DURATION, durationSeekBar.selectedMinValue.toDouble(), false)}")
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE DISTANCE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_DISTANCE_MIN, logSeekBar(RangeSeekbarType.DISTANCE, distanceSeekBar.selectedMinValue.toDouble(), false))
putDouble(PREF_FILTER_VIDEO_DISTANCE_MAX, logSeekBar(RangeSeekbarType.DISTANCE, distanceSeekBar.selectedMaxValue.toDouble(), false))
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE AVERAGE SPEED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_AVG_SPEED_MIN, logSeekBar(RangeSeekbarType.SPEED, speedSeekBar.selectedMinValue.toDouble(), false))
putDouble(PREF_FILTER_VIDEO_AVG_SPEED_MAX, logSeekBar(RangeSeekbarType.SPEED, speedSeekBar.selectedMaxValue.toDouble(), false))
Log.d("FILTERS", "save speed max ${logSeekBar(RangeSeekbarType.SPEED, speedSeekBar.selectedMaxValue.toDouble(), false)}")
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE AVERAGE POWER //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_AVG_POWER_MIN, logSeekBar(RangeSeekbarType.POWER, powerSeekBar.selectedMinValue.toDouble(), false))
putDouble(PREF_FILTER_VIDEO_AVG_POWER_MAX, logSeekBar(RangeSeekbarType.POWER, powerSeekBar.selectedMaxValue.toDouble(), false))
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE AVERAGE SLOPE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_SLOPE_MIN, logSeekBar(RangeSeekbarType.SLOPE, slopeSeekBar.selectedMinValue.toDouble(), false))
putDouble(PREF_FILTER_VIDEO_SLOPE_MAX, logSeekBar(RangeSeekbarType.SLOPE, slopeSeekBar.selectedMaxValue.toDouble(), false))
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// SAVE DIFFICULTY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putInt(PREF_FILTER_VIDEO_DIFFICULTY_MIN, difficultySeekBar.selectedMinValue.toInt())
putInt(PREF_FILTER_VIDEO_DIFFICULTY_MAX, difficultySeekBar.selectedMaxValue.toInt())
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// FILTER BUTTON STATE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
if (filterType == ListVideosSectionFragment.VIDEOS_FILTER)
putBoolean(FILTER_VIDEOS_BUTTON_FILTERED,
!(orderByRecent.isChecked
&& trainingTypeCycling.isChecked
&& trainingTypeRunning.isChecked
&& trainingTypeRowing.isChecked
&& filterSeekBarVideoQuality.progress == 2
&& !filterHideCompletedVideosSwitch.isChecked
&& durationSeekBar.selectedMinValue == min
&& durationSeekBar.selectedMaxValue == max
&& distanceSeekBar.selectedMinValue == min
&& distanceSeekBar.selectedMaxValue == max
&& speedSeekBar.selectedMinValue == min
&& speedSeekBar.selectedMaxValue == max
&& powerSeekBar.selectedMinValue == min
&& powerSeekBar.selectedMaxValue == max
&& difficultySeekBar.selectedMinValue == DIFFICULTY_1
&& difficultySeekBar.selectedMaxValue == DIFFICULTY_5
))
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
@SuppressLint("ApplySharedPref")
private fun resetVideosFilter() {
preferences.edit().apply {
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET ORDER BY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putString(PREF_FILTER_ORDER_BY, when {
orderByRecent.isChecked -> FILTER_BY_LATEST
orderByPopularity.isChecked -> null
orderByDistance.isChecked -> null
orderByDuration.isChecked -> null
else -> FILTER_BY_LATEST
})
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET SPORT TYPE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, true)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, true)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, true)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET MIN QUALITY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putString(PREF_FILTER_VIDEO_QUALITY, QUALITY_GOOD)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET HIDE COMPLETED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putInt(PREF_FILTER_HIDE_FINISHED_VIDEOS, HIDE_VIDEOS)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET DURATION //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_DURATION_MIN, RangeSeekbarType.DURATION.min)
putDouble(PREF_FILTER_VIDEO_DURATION_MAX, RangeSeekbarType.DURATION.max)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET DISTANCE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_DISTANCE_MIN, RangeSeekbarType.DISTANCE.min)
putDouble(PREF_FILTER_VIDEO_DISTANCE_MAX, RangeSeekbarType.DISTANCE.max)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET SPEED //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_AVG_SPEED_MIN, RangeSeekbarType.SPEED.min)
putDouble(PREF_FILTER_VIDEO_AVG_SPEED_MAX, RangeSeekbarType.SPEED.max)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET POWER //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_AVG_POWER_MIN, RangeSeekbarType.POWER.min)
putDouble(PREF_FILTER_VIDEO_AVG_POWER_MAX, RangeSeekbarType.POWER.max)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET SLOPE //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putDouble(PREF_FILTER_VIDEO_SLOPE_MIN, RangeSeekbarType.SLOPE.min)
putDouble(PREF_FILTER_VIDEO_SLOPE_MAX, RangeSeekbarType.SLOPE.max)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// RESET DIFFICULTY //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
putInt(PREF_FILTER_VIDEO_DIFFICULTY_MIN, DIFFICULTY_1)
putInt(PREF_FILTER_VIDEO_DIFFICULTY_MAX, DIFFICULTY_5)
///////////////////////////////////////////////////////////////////////////////////////////////////
// //
// FILTERED BUTTON //
// //
///////////////////////////////////////////////////////////////////////////////////////////////////
if (filterType == ListVideosSectionFragment.VIDEOS_FILTER)
putBoolean(FILTER_VIDEOS_BUTTON_FILTERED, false)
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
private fun getPlaylistsFilter() {
playlistTrainingTypeCycling?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, true)
playlistTrainingTypeRunning?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, true)
playlistTrainingTypeRowing?.isChecked = preferences.getBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, true)
}
@SuppressLint("ApplySharedPref")
private fun setPlaylistsFilter() {
preferences.edit().apply {
putBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, playlistTrainingTypeCycling.isChecked)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, playlistTrainingTypeRunning.isChecked)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, playlistTrainingTypeRowing.isChecked)
if (filterType == ListPlaylistsSectionFragment.PLAYLISTS_FILTER)
putBoolean(FILTER_PLAYLISTS_BUTTON_FILTERED,
!(playlistTrainingTypeCycling.isChecked
&& playlistTrainingTypeRunning.isChecked
&& playlistTrainingTypeRowing.isChecked))
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
@SuppressLint("ApplySharedPref")
private fun resetPlaylistsFilter() {
preferences.edit().apply {
putBoolean(PREF_FILTER_ACTIVITY_TYPE_CYCLING, true)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_RUNNING, true)
putBoolean(PREF_FILTER_ACTIVITY_TYPE_ROWING, true)
if (filterType == ListPlaylistsSectionFragment.PLAYLISTS_FILTER)
putBoolean(FILTER_PLAYLISTS_BUTTON_FILTERED, false)
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
private fun getVideosCoachingFilter() {
machineTypeBike?.isChecked = preferences.getBoolean(PREF_FILTER_MACHINE_TYPE_BIKE, true)
machineTypeTypeHometrainer?.isChecked = preferences.getBoolean(PREF_FILTER_MACHINE_TYPE_HOMETRAINER, true)
machineTypeTypeTreadmill?.isChecked = preferences.getBoolean(PREF_FILTER_MACHINE_TYPE_TREADMILL, true)
machineTypeTypeElliptical?.isChecked = preferences.getBoolean(PREF_FILTER_MACHINE_TYPE_ELLIPTICAL, true)
machineTypeTypeRower?.isChecked = preferences.getBoolean(PREF_FILTER_MACHINE_TYPE_ROWER, true)
spinnerGroupId = preferences.getInt(PREF_FILTER_LANGUAGE, -1)
}
@SuppressLint("ApplySharedPref")
private fun setVideosCoachingFilter() {
if (spinnerLanguage.selectedItemPosition != 0) {
spinnerGroupId = languageList[spinnerLanguage.selectedItemPosition - 1].groupId
}
preferences.edit().apply {
putBoolean(PREF_FILTER_MACHINE_TYPE_BIKE, machineTypeBike.isChecked)
putBoolean(PREF_FILTER_MACHINE_TYPE_HOMETRAINER, machineTypeTypeHometrainer.isChecked)
putBoolean(PREF_FILTER_MACHINE_TYPE_TREADMILL, machineTypeTypeTreadmill.isChecked)
putBoolean(PREF_FILTER_MACHINE_TYPE_ELLIPTICAL, machineTypeTypeElliptical.isChecked)
putBoolean(PREF_FILTER_MACHINE_TYPE_ROWER, machineTypeTypeRower.isChecked)
putInt(PREF_FILTER_LANGUAGE, if (spinnerLanguage.selectedItemPosition == 0) 0 else spinnerGroupId!!)
if (filterType == ListVideosCoachingFragment.VIDEOS_COACHING_FILTER)
putBoolean(FILTER_VIDEOS_COACHING_BUTTON_FILTERED,
!(machineTypeBike.isChecked
&& machineTypeTypeHometrainer.isChecked
&& machineTypeTypeTreadmill.isChecked
&& machineTypeTypeElliptical.isChecked
&& machineTypeTypeRower.isChecked
&& spinnerLanguage.selectedItemPosition == 0))
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
@SuppressLint("ApplySharedPref")
private fun resetVideosCoachingFilter() {
preferences.edit().apply {
putBoolean(PREF_FILTER_MACHINE_TYPE_BIKE, true)
putBoolean(PREF_FILTER_MACHINE_TYPE_HOMETRAINER, true)
putBoolean(PREF_FILTER_MACHINE_TYPE_TREADMILL, true)
putBoolean(PREF_FILTER_MACHINE_TYPE_ELLIPTICAL, true)
putBoolean(PREF_FILTER_MACHINE_TYPE_ROWER, true)
putInt(PREF_FILTER_LANGUAGE, 0)
if (filterType == ListVideosCoachingFragment.VIDEOS_COACHING_FILTER)
putBoolean(FILTER_VIDEOS_COACHING_BUTTON_FILTERED, false)
commit()
}
setResult(RESULT_CODE_REFRESH, intent)
finish()
}
private fun setLogSeekBar(seekbarType: RangeSeekbarType, textView: TextView, minValue: Double, maxValue: Double) {
textView.text = when (seekbarType) {
RangeSeekbarType.DURATION -> "${logSeekBar(seekbarType, minValue, false).toInt()} min - ${logSeekBar(seekbarType, maxValue, false).toInt()}+ min"
RangeSeekbarType.DISTANCE -> "${logSeekBar(seekbarType, minValue, false).toInt()} km - ${logSeekBar(seekbarType, maxValue, false).toInt()}+ km"
RangeSeekbarType.SPEED -> "${logSeekBar(seekbarType, minValue, false).toInt()} km/h - ${logSeekBar(seekbarType, maxValue, false).toInt()}+ km/h"
RangeSeekbarType.POWER -> "${logSeekBar(seekbarType, minValue, false).toInt()} watts - ${logSeekBar(seekbarType, maxValue, false).toInt()}+ watts"
RangeSeekbarType.SLOPE -> "${logSeekBar(seekbarType, minValue, false).toInt()} m - ${logSeekBar(seekbarType, maxValue, false).toInt()}+ m"
}
}
private fun logSeekBar(seekbarType: RangeSeekbarType, value: Double, reverse: Boolean): Double {
if (value < 0.2) {
return 0.0
} else if (max - value < 0.1) {
return seekbarType.max
}
val minP = min
val maxP = max
val minVal = if (seekbarType.min == 0.0) 0.0 else ln(seekbarType.min)
val maxVal = ln(seekbarType.max)
val scale = (maxVal - minVal) / (maxP - minP)
Log.d("FILTRE_VALUE", "filter value - $value")
return if (reverse) (ln(value) - minVal) / scale + minP else exp(minVal + scale * (value - minP))
}
override fun onClick(v: View?) {
Log.d("FILTERS", filterType)
when (filterType) {
VIDEOS_FILTER -> setVideosFilter()
PLAYLISTS_FILTER -> setPlaylistsFilter()
VIDEOS_COACHING_FILTER -> setVideosCoachingFilter()
// PLAYLISTS_COACHING_FILTER -> setPlaylistsCoachingFilter()
}
}
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
menuInflater.inflate(R.menu.menu_filter, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem?): Boolean {
when (item?.itemId) {
R.id.toolbarReset -> when (filterType) {
ListVideosSectionFragment.VIDEOS_FILTER -> resetVideosFilter()
ListPlaylistsSectionFragment.PLAYLISTS_FILTER -> resetPlaylistsFilter()
ListVideosCoachingFragment.VIDEOS_COACHING_FILTER -> resetVideosCoachingFilter()
// ListPlaylistsCoachingFragment.PLAYLISTS_COACHING_FILTER -> resetPlaylistsCoachingFilter()
}
}
return super.onOptionsItemSelected(item)
}
override fun onSupportNavigateUp(): Boolean {
onBackPressed()
return true
}
companion object {
const val FILTER_BY_LATEST = "latest"
const val FILTER_BY_POPULARITY = "popular"
const val FILTER_BY_DISTANCE = "distanceAsc"
const val FILTER_BY_DURATION = "durationAsc"
const val QUALITY_UNDEFINED = "undefined"
const val QUALITY_BAD = "bad"
const val QUALITY_MEDIUM = "medium"
const val QUALITY_GOOD = "good"
const val QUALITY_STABILIZED = "stabilized"
const val VIDEOS_FILTER = "video_filter"
const val PLAYLISTS_FILTER = "playlist_filter"
const val VIDEOS_COACHING_FILTER = "videos_coaching_filter"
const val PLAYLISTS_COACHING_FILTER = "playlists_coaching_filter"
const val DIFFICULTY_1 = 1
const val DIFFICULTY_2 = 2
const val DIFFICULTY_3 = 3
const val DIFFICULTY_4 = 4
const val DIFFICULTY_5 = 5
const val HIDE_VIDEOS = 0
const val ARGS_TYPE_FILTER = "filter_extra_key"
const val RESULT_CODE_REFRESH = 666
const val REQUEST_CODE = 665
const val min = 0f
const val max = 100f
fun getDifficultyParams(preferences: SharedPreferences): String {
val difficulty = StringBuilder()
val difficultyMin = preferences.getInt(PREF_FILTER_VIDEO_DIFFICULTY_MIN, DIFFICULTY_1)
val difficultyMax = preferences.getInt(PREF_FILTER_VIDEO_DIFFICULTY_MAX, DIFFICULTY_5)
for (i in difficultyMin..difficultyMax) {
difficulty.append(i)
if (i != difficultyMax) {
difficulty.append("|")
}
}
return difficulty.toString()
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment