Calendar duration graph added + enhancements

feature/top10
Laurent 7 years ago
parent 777bbb6903
commit 23b993f149
  1. 4
      app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt
  2. 22
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt
  3. 18
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  4. 18
      app/src/main/java/net/pokeranalytics/android/calculus/Report.kt
  5. 36
      app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt
  6. 2
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  7. 2
      app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt
  8. 4
      app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt
  9. 4
      app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt
  10. 16
      app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
  11. 4
      app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticsFragment.kt
  12. 21
      app/src/main/java/net/pokeranalytics/android/ui/graph/GraphExtensions.kt
  13. 7
      app/src/main/java/net/pokeranalytics/android/ui/view/LegendView.kt

@ -68,8 +68,8 @@ class PerfsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
val average = results.computedStat(Stat.AVERAGE) val average = results.computedStat(Stat.AVERAGE)
Timber.d("*** AVERAGE: ${average?.value}") Timber.d("*** AVERAGE: ${average?.value}")
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
Timber.d("*** DURATION: ${duration?.value}") Timber.d("*** HOURLY_DURATION: ${duration?.value}")
} }
} }

@ -95,7 +95,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
Assert.fail("No AVERAGE stat") Assert.fail("No AVERAGE stat")
} }
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(4.0, duration.value, delta) assertEquals(4.0, duration.value, delta)
} else { } else {
@ -132,7 +132,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
} else { } else {
Assert.fail("No avgBuyin stat") Assert.fail("No avgBuyin stat")
} }
val avgDuration = results.computedStat(Stat.AVERAGE_DURATION) val avgDuration = results.computedStat(Stat.AVERAGE_HOURLY_DURATION)
if (avgDuration != null) { if (avgDuration != null) {
assertEquals(2.0, avgDuration.value, delta) assertEquals(2.0, avgDuration.value, delta)
} else { } else {
@ -259,7 +259,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(3.0, duration.value, delta) assertEquals(3.0, duration.value, delta)
} else { } else {
@ -326,7 +326,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(8.0, duration.value, delta) assertEquals(8.0, duration.value, delta)
} else { } else {
@ -409,7 +409,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(8.0, duration.value, delta) assertEquals(8.0, duration.value, delta)
} else { } else {
@ -425,7 +425,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results2: ComputedResults = Calculator.compute(realm, group2, options) val results2: ComputedResults = Calculator.compute(realm, group2, options)
val duration2 = results2.computedStat(Stat.DURATION) val duration2 = results2.computedStat(Stat.HOURLY_DURATION)
if (duration2 != null) { if (duration2 != null) {
assertEquals(7.0, duration2.value, delta) assertEquals(7.0, duration2.value, delta)
} else { } else {
@ -554,7 +554,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(7.0, duration.value, delta) assertEquals(7.0, duration.value, delta)
} else { } else {
@ -727,12 +727,12 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val group = ComputableGroup("test", listOf(QueryCondition.IsCash)) val group = ComputableGroup("test", listOf(QueryCondition.IsCash))
val options = Calculator.Options() val options = Calculator.Options()
options.displayedStats = listOf(Stat.DURATION) options.displayedStats = listOf(Stat.HOURLY_DURATION)
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(2.0, duration.value, delta) assertEquals(2.0, duration.value, delta)
} else { } else {
@ -772,12 +772,12 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val group = ComputableGroup("test", listOf(QueryCondition.IsCash)) val group = ComputableGroup("test", listOf(QueryCondition.IsCash))
val options = Calculator.Options() val options = Calculator.Options()
options.displayedStats = listOf(Stat.DURATION) options.displayedStats = listOf(Stat.HOURLY_DURATION)
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val duration = results.computedStat(Stat.DURATION) val duration = results.computedStat(Stat.HOURLY_DURATION)
if (duration != null) { if (duration != null) {
assertEquals(4.0, duration.value, delta) assertEquals(4.0, duration.value, delta)
} else { } else {

@ -393,14 +393,14 @@ class Calculator {
results.addEvolutionValue(tHourlyRate, stat = HOURLY_RATE, data = sessionSet) results.addEvolutionValue(tHourlyRate, stat = HOURLY_RATE, data = sessionSet)
results.addEvolutionValue(tIndex.toDouble(), stat = NUMBER_OF_SETS, data = sessionSet) results.addEvolutionValue(tIndex.toDouble(), stat = NUMBER_OF_SETS, data = sessionSet)
results.addEvolutionValue( results.addEvolutionValue(
(sessionSet.startDate.time / 3600000).toDouble(), sessionSet.hourlyDuration,
sessionSet.netDuration.toDouble(), tHourlyDuration,
stat = DURATION, HOURLY_DURATION,
data = sessionSet sessionSet
) )
results.addEvolutionValue( results.addEvolutionValue(
tHourlyDuration / tIndex, tHourlyDuration / tIndex,
stat = AVERAGE_DURATION, stat = AVERAGE_HOURLY_DURATION,
data = sessionSet data = sessionSet
) )
results.addEvolutionValue(tHourlyRateBB, stat = HOURLY_RATE_BB, data = sessionSet) results.addEvolutionValue(tHourlyRateBB, stat = HOURLY_RATE_BB, data = sessionSet)
@ -422,13 +422,13 @@ class Calculator {
results.addEvolutionValue( results.addEvolutionValue(
sessionSet.hourlyDuration, sessionSet.hourlyDuration,
tHourlyDuration, tHourlyDuration,
DURATION, HOURLY_DURATION,
sessionSet sessionSet
) )
results.addEvolutionValue( results.addEvolutionValue(
tHourlyDuration / tIndex, tHourlyDuration / tIndex,
tHourlyDuration, tHourlyDuration,
AVERAGE_DURATION, AVERAGE_HOURLY_DURATION,
sessionSet sessionSet
) )
results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet) results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet)
@ -464,9 +464,9 @@ class Calculator {
if (sessionSets.size > 0) { if (sessionSets.size > 0) {
val avgDuration = gHourlyDuration / sessionSets.size val avgDuration = gHourlyDuration / sessionSets.size
results.addStat(HOURLY_RATE, hourlyRate) results.addStat(HOURLY_RATE, hourlyRate)
results.addStat(AVERAGE_DURATION, avgDuration) results.addStat(AVERAGE_HOURLY_DURATION, avgDuration)
} }
results.addStat(DURATION, gHourlyDuration) results.addStat(HOURLY_DURATION, gHourlyDuration)
} }
if (gBBSum != null) { if (gBBSum != null) {

@ -66,7 +66,9 @@ class Report(var options: Calculator.Options) {
} }
} }
return BarDataSet(entries, statToUse?.name) val barDataSet = BarDataSet(entries, statToUse?.name)
barDataSet.setDrawValues(false)
return barDataSet
} }
fun multiLineEntries(context: Context): List<LineDataSet> { fun multiLineEntries(context: Context): List<LineDataSet> {
@ -240,7 +242,7 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
val stat = computedStat.stat val stat = computedStat.stat
previousResult.computedStat(stat)?.let { previousComputedStat -> previousResult.computedStat(stat)?.let { previousComputedStat ->
when (stat) { when (stat) {
Stat.NET_RESULT, Stat.DURATION, Stat.BB_NET_RESULT, Stat.BB_SESSION_COUNT, Stat.NET_RESULT, Stat.HOURLY_DURATION, Stat.BB_NET_RESULT, Stat.BB_SESSION_COUNT,
Stat.WINNING_SESSION_COUNT, Stat.TOTAL_BUYIN, Stat.HANDS_PLAYED, Stat.NUMBER_OF_GAMES, Stat.NUMBER_OF_SETS -> { Stat.WINNING_SESSION_COUNT, Stat.TOTAL_BUYIN, Stat.HANDS_PLAYED, Stat.NUMBER_OF_GAMES, Stat.NUMBER_OF_SETS -> {
val previousValue = previousComputedStat.progressValue ?: previousComputedStat.value val previousValue = previousComputedStat.progressValue ?: previousComputedStat.value
computedStat.progressValue = previousValue + computedStat.value computedStat.progressValue = previousValue + computedStat.value
@ -255,7 +257,7 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
val netResult = this.computedStat(Stat.NET_RESULT)?.progressValue val netResult = this.computedStat(Stat.NET_RESULT)?.progressValue
val bbNetResult = this.computedStat(Stat.BB_NET_RESULT)?.progressValue val bbNetResult = this.computedStat(Stat.BB_NET_RESULT)?.progressValue
val duration = this.computedStat(Stat.DURATION)?.progressValue val duration = this.computedStat(Stat.HOURLY_DURATION)?.progressValue
val numberOfGames = this.computedStat(Stat.NUMBER_OF_GAMES)?.progressValue val numberOfGames = this.computedStat(Stat.NUMBER_OF_GAMES)?.progressValue
val numberOfSets = this.computedStat(Stat.NUMBER_OF_SETS)?.progressValue val numberOfSets = this.computedStat(Stat.NUMBER_OF_SETS)?.progressValue
val handsPlayed = this.computedStat(Stat.HANDS_PLAYED)?.progressValue val handsPlayed = this.computedStat(Stat.HANDS_PLAYED)?.progressValue
@ -275,7 +277,7 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
computedStat.progressValue = netResult / numberOfGames computedStat.progressValue = netResult / numberOfGames
} }
} }
Stat.AVERAGE_DURATION -> { Stat.AVERAGE_HOURLY_DURATION -> {
if (duration != null && numberOfSets != null) { if (duration != null && numberOfSets != null) {
computedStat.progressValue = duration / numberOfSets computedStat.progressValue = duration / numberOfSets
} }
@ -342,9 +344,9 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
fun defaultStatEntries(stat: Stat, context: Context): DataSet<out Entry> { fun defaultStatEntries(stat: Stat, context: Context): DataSet<out Entry> {
return when (stat) { return when (stat) {
Stat.NUMBER_OF_SETS, Stat.NUMBER_OF_GAMES -> this.barEntries(stat) Stat.NUMBER_OF_SETS, Stat.NUMBER_OF_GAMES -> this.barEntries(stat, context = context)
Stat.STANDARD_DEVIATION -> this.distributionEntries(stat, context) Stat.STANDARD_DEVIATION -> this.distributionEntries(stat, context)
Stat.DURATION -> this.barEntries(stat) Stat.HOURLY_DURATION -> this.barEntries(stat, context)
else -> this.singleLineEntries(stat, context) else -> this.singleLineEntries(stat, context)
} }
} }
@ -369,7 +371,7 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
return PALineDataSet(entries, stat.name, context) return PALineDataSet(entries, stat.name, context)
} }
fun barEntries(stat: Stat): BarDataSet { fun barEntries(stat: Stat, context: Context): BarDataSet {
val entries = mutableListOf<BarEntry>() val entries = mutableListOf<BarEntry>()
this._evolutionValues[stat]?.let { points -> this._evolutionValues[stat]?.let { points ->
@ -378,6 +380,8 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
} }
} }
val dataSet = BarDataSet(entries, stat.name) val dataSet = BarDataSet(entries, stat.name)
dataSet.color = context.getColor(R.color.green)
// dataSet.barBorderWidth = 1.0f
dataSet.setDrawValues(false) dataSet.setDrawValues(false)
return dataSet return dataSet
} }

@ -89,8 +89,8 @@ enum class Stat : RowRepresentable {
AVERAGE, AVERAGE,
NUMBER_OF_SETS, NUMBER_OF_SETS,
NUMBER_OF_GAMES, NUMBER_OF_GAMES,
DURATION, HOURLY_DURATION,
AVERAGE_DURATION, AVERAGE_HOURLY_DURATION,
NET_BB_PER_100_HANDS, NET_BB_PER_100_HANDS,
HOURLY_RATE_BB, HOURLY_RATE_BB,
AVERAGE_NET_BB, AVERAGE_NET_BB,
@ -139,8 +139,8 @@ enum class Stat : RowRepresentable {
AVERAGE -> R.string.average AVERAGE -> R.string.average
NUMBER_OF_SETS -> R.string.number_of_sessions NUMBER_OF_SETS -> R.string.number_of_sessions
NUMBER_OF_GAMES -> R.string.number_of_records NUMBER_OF_GAMES -> R.string.number_of_records
DURATION -> R.string.duration HOURLY_DURATION -> R.string.duration
AVERAGE_DURATION -> R.string.average_hours_played AVERAGE_HOURLY_DURATION -> R.string.average_hours_played
NET_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands NET_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands
HOURLY_RATE_BB -> R.string.average_hour_rate_bb_ HOURLY_RATE_BB -> R.string.average_hour_rate_bb_
AVERAGE_NET_BB -> R.string.average_net_result_bb_ AVERAGE_NET_BB -> R.string.average_net_result_bb_
@ -186,7 +186,7 @@ enum class Stat : RowRepresentable {
NUMBER_OF_SETS, NUMBER_OF_GAMES, HANDS_PLAYED, LOCATIONS_PLAYED, DAYS_PLAYED -> { NUMBER_OF_SETS, NUMBER_OF_GAMES, HANDS_PLAYED, LOCATIONS_PLAYED, DAYS_PLAYED -> {
return TextFormat("${value.toInt()}") return TextFormat("${value.toInt()}")
} // white durations } // white durations
DURATION, AVERAGE_DURATION, MAXIMUM_DURATION -> { HOURLY_DURATION, AVERAGE_HOURLY_DURATION, MAXIMUM_DURATION -> {
return TextFormat(value.formattedHourlyDuration()) return TextFormat(value.formattedHourlyDuration())
} // red/green percentages } // red/green percentages
WIN_RATIO, ROI -> { WIN_RATIO, ROI -> {
@ -215,15 +215,15 @@ enum class Stat : RowRepresentable {
fun cumulativeLabelResId(context: Context): String { fun cumulativeLabelResId(context: Context): String {
val resId = when (this) { val resId = when (this) {
AVERAGE, AVERAGE_DURATION, NET_BB_PER_100_HANDS, AVERAGE, AVERAGE_HOURLY_DURATION, NET_BB_PER_100_HANDS,
HOURLY_RATE_BB, AVERAGE_NET_BB, ROI, HOURLY_RATE -> R.string.average HOURLY_RATE_BB, AVERAGE_NET_BB, ROI, HOURLY_RATE -> R.string.average
NUMBER_OF_SETS -> R.string.number_of_sessions NUMBER_OF_SETS -> R.string.number_of_sessions
NUMBER_OF_GAMES -> R.string.number_of_records NUMBER_OF_GAMES -> R.string.number_of_records
NET_RESULT, DURATION -> R.string.total NET_RESULT -> R.string.total
STANDARD_DEVIATION -> R.string.net_result STANDARD_DEVIATION -> R.string.net_result
STANDARD_DEVIATION_HOURLY -> R.string.hour_rate_without_pauses STANDARD_DEVIATION_HOURLY -> R.string.hour_rate_without_pauses
STANDARD_DEVIATION_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands STANDARD_DEVIATION_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands
WIN_RATIO -> return this.name WIN_RATIO, HOURLY_DURATION -> return this.localizedTitle(context)
else -> null else -> null
} }
resId?.let { resId?.let {
@ -250,7 +250,7 @@ enum class Stat : RowRepresentable {
val hasEvolutionGraph: Boolean val hasEvolutionGraph: Boolean
get() { get() {
return when (this) { return when (this) {
DURATION, AVERAGE_DURATION -> false HOURLY_DURATION, AVERAGE_HOURLY_DURATION -> false
else -> true else -> true
} }
} }
@ -258,7 +258,7 @@ enum class Stat : RowRepresentable {
val significantIndividualValue: Boolean val significantIndividualValue: Boolean
get() { get() {
return when (this) { return when (this) {
WIN_RATIO, NUMBER_OF_SETS, NUMBER_OF_GAMES, STANDARD_DEVIATION -> false WIN_RATIO, NUMBER_OF_SETS, NUMBER_OF_GAMES, STANDARD_DEVIATION, HOURLY_DURATION -> false
else -> true else -> true
} }
} }
@ -271,6 +271,22 @@ enum class Stat : RowRepresentable {
} }
} }
val showXAxisZero: Boolean
get() {
return when (this) {
HOURLY_DURATION -> true
else -> false
}
}
val showYAxisZero: Boolean
get() {
return when (this) {
HOURLY_DURATION -> true
else -> false
}
}
override val viewType: Int = RowViewType.TITLE_VALUE.ordinal override val viewType: Int = RowViewType.TITLE_VALUE.ordinal
} }

@ -939,7 +939,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
this.estimatedHands this.estimatedHands
) )
Stat.AVERAGE_NET_BB -> this.bbNet Stat.AVERAGE_NET_BB -> this.bbNet
Stat.DURATION, Stat.AVERAGE_DURATION -> this.netDuration.toDouble() Stat.HOURLY_DURATION, Stat.AVERAGE_HOURLY_DURATION -> this.netDuration.toDouble()
Stat.HOURLY_RATE, Stat.STANDARD_DEVIATION_HOURLY -> this.hourlyRate Stat.HOURLY_RATE, Stat.STANDARD_DEVIATION_HOURLY -> this.hourlyRate
Stat.HANDS_PLAYED -> this.estimatedHands Stat.HANDS_PLAYED -> this.estimatedHands
Stat.WIN_RATIO -> null Stat.WIN_RATIO -> null

@ -121,7 +121,7 @@ open class SessionSet() : RealmObject(), Timed, Filterable {
override fun formattedValue(stat: Stat) : TextFormat { override fun formattedValue(stat: Stat) : TextFormat {
return when (stat) { return when (stat) {
Stat.NET_RESULT, Stat.AVERAGE -> stat.format(this.ratedNet, currency = null) Stat.NET_RESULT, Stat.AVERAGE -> stat.format(this.ratedNet, currency = null)
Stat.DURATION, Stat.AVERAGE_DURATION -> stat.format(this.netDuration.toDouble(), currency = null) Stat.HOURLY_DURATION, Stat.AVERAGE_HOURLY_DURATION -> stat.format(this.hourlyDuration, currency = null)
Stat.HOURLY_RATE -> stat.format(this.hourlyRate, currency = null) Stat.HOURLY_RATE -> stat.format(this.hourlyRate, currency = null)
Stat.HANDS_PLAYED -> stat.format(this.estimatedHands, currency = null) Stat.HANDS_PLAYED -> stat.format(this.estimatedHands, currency = null)
Stat.HOURLY_RATE_BB -> stat.format(this.bbHourlyRate, currency = null) Stat.HOURLY_RATE_BB -> stat.format(this.bbHourlyRate, currency = null)

@ -190,8 +190,8 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable
rowRepresentables.add(GraphRow(report, Stat.STANDARD_DEVIATION)) rowRepresentables.add(GraphRow(report, Stat.STANDARD_DEVIATION))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.WIN_RATIO), it.computedStat(Stat.MAXIMUM_NETRESULT))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.WIN_RATIO), it.computedStat(Stat.MAXIMUM_NETRESULT)))
rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.volume)) rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.volume))
rowRepresentables.add(GraphRow(report, Stat.DURATION)) rowRepresentables.add(GraphRow(report, Stat.HOURLY_DURATION))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DURATION), it.computedStat(Stat.AVERAGE_DURATION))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.HOURLY_DURATION), it.computedStat(Stat.AVERAGE_HOURLY_DURATION)))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DAYS_PLAYED), it.computedStat(Stat.MAXIMUM_DURATION))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DAYS_PLAYED), it.computedStat(Stat.MAXIMUM_DURATION)))
} }

@ -138,8 +138,8 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
3 -> currentStat = Stat.WIN_RATIO 3 -> currentStat = Stat.WIN_RATIO
4 -> currentStat = Stat.STANDARD_DEVIATION_HOURLY 4 -> currentStat = Stat.STANDARD_DEVIATION_HOURLY
5 -> currentStat = Stat.AVERAGE 5 -> currentStat = Stat.AVERAGE
6 -> currentStat = Stat.AVERAGE_DURATION 6 -> currentStat = Stat.AVERAGE_HOURLY_DURATION
7 -> currentStat = Stat.DURATION 7 -> currentStat = Stat.HOURLY_DURATION
} }
displayData() displayData()
} }

@ -98,7 +98,16 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.chartContainer.removeAllViews() this.chartContainer.removeAllViews()
this.chartView = when (dataSet) { this.chartView = when (dataSet) {
is LineDataSet -> LineChart(context) is LineDataSet -> LineChart(context)
is BarDataSet -> BarChart(context) is BarDataSet -> {
val barChart = BarChart(context)
if (stat.showXAxisZero) {
barChart.xAxis.axisMinimum = 0.0f
}
if (stat.showYAxisZero) {
barChart.axisLeft.axisMinimum = 0.0f
}
barChart
}
else -> null else -> null
} }
this.chartContainer.addView(this.chartView) this.chartContainer.addView(this.chartView)
@ -111,8 +120,9 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
} }
is BarDataSet -> { is BarDataSet -> {
val barChart = this.chartView as BarChart val barChart = this.chartView as BarChart
val colors = arrayOf(R.color.green_light).toIntArray() // val colors = arrayOf(R.color.green_light).toIntArray()
dataSet.setColors(colors, context) // dataSet.setColors(colors, context)
dataSet.color = requireContext().getColor(R.color.green_light)
val barData = BarData(listOf(dataSet)) val barData = BarData(listOf(dataSet))
barChart.data = barData barChart.data = barData
} }

@ -117,8 +117,8 @@ class StatisticsFragment : TableReportFragment() {
Stat.HOURLY_RATE, Stat.HOURLY_RATE,
Stat.AVERAGE, Stat.AVERAGE,
Stat.NUMBER_OF_SETS, Stat.NUMBER_OF_SETS,
Stat.AVERAGE_DURATION, Stat.AVERAGE_HOURLY_DURATION,
Stat.DURATION Stat.HOURLY_DURATION
) )
val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats) val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
val cgStats: List<Stat> = listOf( val cgStats: List<Stat> = listOf(

@ -3,6 +3,7 @@ package net.pokeranalytics.android.ui.graph
import android.content.Context import android.content.Context
import androidx.core.content.ContextCompat import androidx.core.content.ContextCompat
import androidx.core.content.res.ResourcesCompat import androidx.core.content.res.ResourcesCompat
import com.github.mikephil.charting.charts.BarChart
import com.github.mikephil.charting.charts.BarLineChartBase import com.github.mikephil.charting.charts.BarLineChartBase
import com.github.mikephil.charting.components.XAxis import com.github.mikephil.charting.components.XAxis
import net.pokeranalytics.android.R import net.pokeranalytics.android.R
@ -14,7 +15,11 @@ enum class AxisFormatting {
Y_DURATION, Y_DURATION,
} }
fun BarLineChartBase<*>.setStyle(small: Boolean, axisFormatting: AxisFormatting = AxisFormatting.DEFAULT, context: Context) { fun BarLineChartBase<*>.setStyle(
small: Boolean,
axisFormatting: AxisFormatting = AxisFormatting.DEFAULT,
context: Context
) {
this.legend.isEnabled = false this.legend.isEnabled = false
this.description.isEnabled = false this.description.isEnabled = false
@ -23,7 +28,6 @@ fun BarLineChartBase<*>.setStyle(small: Boolean, axisFormatting: AxisFormatting
this.xAxis.axisLineColor = ContextCompat.getColor(context, R.color.chart_default) this.xAxis.axisLineColor = ContextCompat.getColor(context, R.color.chart_default)
this.xAxis.enableGridDashedLine(3.0f.px, 5.0f.px, 1.0f.px) this.xAxis.enableGridDashedLine(3.0f.px, 5.0f.px, 1.0f.px)
this.xAxis.position = XAxis.XAxisPosition.BOTTOM this.xAxis.position = XAxis.XAxisPosition.BOTTOM
this.xAxis.setDrawLabels(true)
this.xAxis.setDrawGridLines(true) this.xAxis.setDrawGridLines(true)
this.xAxis.isGranularityEnabled = true this.xAxis.isGranularityEnabled = true
this.xAxis.granularity = 1.0f this.xAxis.granularity = 1.0f
@ -33,13 +37,21 @@ fun BarLineChartBase<*>.setStyle(small: Boolean, axisFormatting: AxisFormatting
this.xAxis.textSize = 12f this.xAxis.textSize = 12f
this.xAxis.isEnabled = true this.xAxis.isEnabled = true
when (this) {
is BarChart -> {
this.xAxis.setDrawLabels(false)
}
else -> {
this.xAxis.setDrawLabels(true)
}
}
// Y Axis // Y Axis
this.axisLeft.setDrawAxisLine(false) this.axisLeft.setDrawAxisLine(false)
this.axisLeft.setDrawGridLines(true) this.axisLeft.setDrawGridLines(true)
this.axisLeft.enableGridDashedLine(3.0f.px, 5.0f.px, 1.0f.px) this.axisLeft.enableGridDashedLine(3.0f.px, 5.0f.px, 1.0f.px)
this.axisLeft.setDrawZeroLine(true) this.axisLeft.setDrawZeroLine(true)
// this.axisLeft.zeroLineWidth = 1.0f.px
this.axisLeft.zeroLineColor = ContextCompat.getColor(context, R.color.chart_default) this.axisLeft.zeroLineColor = ContextCompat.getColor(context, R.color.chart_default)
this.axisLeft.isGranularityEnabled = true this.axisLeft.isGranularityEnabled = true
@ -47,7 +59,8 @@ fun BarLineChartBase<*>.setStyle(small: Boolean, axisFormatting: AxisFormatting
this.axisLeft.textColor = ContextCompat.getColor(context, R.color.chart_default) this.axisLeft.textColor = ContextCompat.getColor(context, R.color.chart_default)
this.axisLeft.typeface = ResourcesCompat.getFont(context, R.font.roboto_medium) this.axisLeft.typeface = ResourcesCompat.getFont(context, R.font.roboto_medium)
this.axisLeft.labelCount = if (small) 1 else 7 // @todo not great if interval is [0..2] for number of records as we get decimals this.axisLeft.labelCount =
if (small) 1 else 7 // @todo not great if interval is [0..2] for number of records as we get decimals
this.axisLeft.textSize = 12f this.axisLeft.textSize = 12f
this.axisLeft.valueFormatter = LargeNumberFormatter() this.axisLeft.valueFormatter = LargeNumberFormatter()

@ -57,6 +57,7 @@ class LegendView : FrameLayout {
} else { } else {
this.stat1Name.text = stat.cumulativeLabelResId(context) this.stat1Name.text = stat.cumulativeLabelResId(context)
this.stat2Name.isVisible = false this.stat2Name.isVisible = false
this.stat2Value.isVisible = false
} }
val counterText = "$counter ${context.getString(R.string.sessions)}" val counterText = "$counter ${context.getString(R.string.sessions)}"
@ -77,9 +78,9 @@ class LegendView : FrameLayout {
this.stat2Value.setTextFormat(it, context) this.stat2Value.setTextFormat(it, context)
} }
val showRightStat = values.rightFormat != null // val showRightStat = values.rightFormat != null
this.stat2Name.isVisible = showRightStat // this.stat2Name.isVisible = showRightStat
this.stat2Value.isVisible = showRightStat // this.stat2Value.isVisible = showRightStat
} }

Loading…
Cancel
Save