Created
January 3, 2020 15:45
-
-
Save PollyGlot/3d75a6fa9405ad19d4fd70a6d801a140 to your computer and use it in GitHub Desktop.
A filter functionality I was responsible for to filter videos / playlists in search results of a Kinomap application
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| 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