MainActivity: set unit for bottle content

Make the UI more flexible and
slightly easier to understand.

app/src/main/java/it/danieleverducci/lunatracker/MainActivity.kt

@@ -148,10 +148,12 @@ class MainActivity : AppCompatActivity() {
         val eventTypeStats = mutableMapOf<LunaEvent.Type, Int>()
 
         if (dynamicMenu) {
-            val sampleSize = 100
+            // populate frequency map from all events of the last two weeks
-            // populate frequency map from first 100 events
+            val lastWeekTime = (System.currentTimeMillis() / 1000) - (14 * 24 * 60 * 60)
-            allEvents.take(sampleSize.coerceAtMost(allEvents.size)).forEach {
+            allEvents.forEach {
-                eventTypeStats[it.type] = 1 + (eventTypeStats[it.type] ?: 0)
+                if (it.time > lastWeekTime) {
+                    eventTypeStats[it.type] = 1 + (eventTypeStats[it.type] ?: 0)
+                }
             }
         }
 
@@ -160,60 +162,55 @@ class MainActivity : AppCompatActivity() {
             compareBy({ -1 * (eventTypeStats[it] ?: 0) }, { it.ordinal })
         ).filter { it != LunaEvent.Type.UNKNOWN }
 
-        fun setupMenu(maxButtonCount: Int, sortedEventTypes: List<LunaEvent.Type>): Int {
-            val row1 = findViewById<View>(R.id.linear_layout_row1)
-            val row1Button1 = findViewById<TextView>(R.id.button1_row1)
-            val row1Button2 = findViewById<TextView>(R.id.button2_row1)
-
-            val row2 = findViewById<View>(R.id.linear_layout_row2)
-            val row2Button1 = findViewById<TextView>(R.id.button1_row2)
-            val row2Button2 = findViewById<TextView>(R.id.button2_row2)
-            val row2Button3 = findViewById<TextView>(R.id.button3_row2)
-
-            val row3 = findViewById<View>(R.id.linear_layout_row3)
-            val row3Button1 = findViewById<TextView>(R.id.button1_row3)
-            val row3Button2 = findViewById<TextView>(R.id.button2_row3)
-
-            // hide all rows/buttons (except row 3)
-            for (view in listOf(row1, row1Button1, row1Button2,
-                                row2, row2Button1, row2Button2, row2Button3,
-                                row3, row3Button1, row3Button2)) {
-                view.visibility = View.GONE
-            }
-            row3.visibility = View.VISIBLE
-
-            var showCounter = 0
-
-            fun show(vararg tvs: TextView) {
-                for (tv in tvs) {
-                    val type = sortedEventTypes[showCounter]
-                    tv.text = LunaEvent.getHeaderEmoji(applicationContext, type)
-                    tv.setOnClickListener { showCreateDialog(type) }
-                    tv.visibility = View.VISIBLE
-                    // show parent row
-                    (tv.parent as View).visibility = View.VISIBLE
-                    showCounter += 1
-                }
-            }
-
-            when (maxButtonCount) {
-                0 -> { } // ignore - show empty row3
-                1 -> show(row3Button1)
-                2 -> show(row3Button1, row3Button2)
-                3 -> show(row1Button1, row3Button1)
-                4, 5, 6 -> show(row1Button1, row1Button2, row3Button1, row3Button2)
-                else -> show(row1Button1, row1Button2, row2Button1, row2Button2, row2Button3, row3Button1, row3Button2)
-            }
-
-            return showCounter
-        }
-
         val usedEventCount = eventTypeStats.count { it.value > 0 }
         val maxButtonCount = if (dynamicMenu) { usedEventCount } else { 7 }
-        val eventsShown = setupMenu(maxButtonCount, eventTypesSorted)
+
+        val row1 = findViewById<View>(R.id.linear_layout_row1)
+        val row1Button1 = findViewById<TextView>(R.id.button1_row1)
+        val row1Button2 = findViewById<TextView>(R.id.button2_row1)
+
+        val row2 = findViewById<View>(R.id.linear_layout_row2)
+        val row2Button1 = findViewById<TextView>(R.id.button1_row2)
+        val row2Button2 = findViewById<TextView>(R.id.button2_row2)
+        val row2Button3 = findViewById<TextView>(R.id.button3_row2)
+
+        val row3 = findViewById<View>(R.id.linear_layout_row3)
+        val row3Button1 = findViewById<TextView>(R.id.button1_row3)
+        val row3Button2 = findViewById<TextView>(R.id.button2_row3)
+
+        // hide all rows/buttons (except row 3)
+        for (view in listOf(row1, row1Button1, row1Button2,
+                            row2, row2Button1, row2Button2, row2Button3,
+                            row3, row3Button1, row3Button2)) {
+            view.visibility = View.GONE
+        }
+        row3.visibility = View.VISIBLE
+
+        var showCounter = 0
+
+        fun show(vararg tvs: TextView) {
+            for (tv in tvs) {
+                val type = eventTypesSorted[showCounter]
+                tv.text = LunaEvent.getHeaderEmoji(applicationContext, type)
+                tv.setOnClickListener { showCreateDialog(type) }
+                tv.visibility = View.VISIBLE
+                // show parent row
+                (tv.parent as View).visibility = View.VISIBLE
+                showCounter += 1
+            }
+        }
+
+        when (maxButtonCount) {
+            0 -> { } // ignore - show empty row3
+            1 -> show(row3Button1)
+            2 -> show(row3Button1, row3Button2)
+            3 -> show(row1Button1, row3Button1)
+            4, 5, 6 -> show(row1Button1, row1Button2, row3Button1, row3Button2)
+            else -> show(row1Button1, row1Button2, row2Button1, row2Button2, row2Button3, row3Button1, row3Button2)
+        }
 
         // store left over events for popup menu
-        currentPopupItems = eventTypesSorted.subList(eventsShown, eventTypesSorted.size)
+        currentPopupItems = eventTypesSorted.subList(showCounter, eventTypesSorted.size)
     }
 
     override fun onStart() {
@@ -275,6 +272,9 @@ class MainActivity : AppCompatActivity() {
         numberPicker.wrapSelectorWheel = false
         numberPicker.value = event.quantity / 10
 
+        val numberPickerUnit = dialogView.findViewById<TextView>(R.id.dialog_number_picker_unit)
+        numberPickerUnit.text = NumericUtils(this).measurement_unit_liquid_base
+
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
         val pickedTime = dateTimePicker(event.time, dateTV)
 
@@ -421,11 +421,11 @@ class MainActivity : AppCompatActivity() {
         return dateTime
     }
 
-    fun addSleepEvent(event: LunaEvent) {
+    fun addDurationEvent(event: LunaEvent) {
-        askSleepValue(event, true) { saveEvent(event) }
+        askDurationEvent(event, true) { saveEvent(event) }
     }
 
-    fun askSleepValue(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
+    fun askDurationEvent(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_duration, null)
         d.setTitle(event.getDialogTitle(this))
@@ -434,70 +434,109 @@ class MainActivity : AppCompatActivity() {
         val durationTextView = dialogView.findViewById<TextView>(R.id.dialog_date_duration)
         val datePickerBegin = dialogView.findViewById<TextView>(R.id.dialog_date_picker_begin)
         val datePickerEnd = dialogView.findViewById<TextView>(R.id.dialog_date_picker_end)
+        val dateDelimiter = dialogView.findViewById<TextView>(R.id.dialog_date_range_delimiter)
+        val durationButtons = dialogView.findViewById<LinearLayout>(R.id.duration_buttons)
+        val durationNowButton = dialogView.findViewById<Button>(R.id.dialog_date_duration_now)
+        val durationClearButton = dialogView.findViewById<Button>(R.id.dialog_date_duration_clear)
+        val durationMinus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_minus5)
+        val durationPlus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_plus5)
 
         val currentDurationTextColor = durationTextView.currentTextColor
         val invalidDurationTextColor = ContextCompat.getColor(this, R.color.danger)
 
         // in seconds
-        var sleepStart = event.time
+        var durationStart = event.getStartTime()
-        var sleepEnd = event.time + event.quantity
+        var durationEnd = event.getEndTime()
+
+        fun isValidTime(timeUnix: Long): Boolean {
+            val now = System.currentTimeMillis() / 1000
+            return timeUnix in 1..now
+        }
 
         fun isValidTimeSpan(timeBeginUnix: Long, timeEndUnix: Long): Boolean {
-            val now = System.currentTimeMillis() / 1000
+            return (timeBeginUnix <= timeEndUnix) && (timeEndUnix - timeBeginUnix) < (24 * 60 * 60)
-            return (timeBeginUnix > 0)
-                && (timeEndUnix > 0)
-                && (timeBeginUnix <= timeEndUnix)
-                && (timeBeginUnix <= now)
-                && (timeEndUnix <= now)
-                && (timeEndUnix - timeBeginUnix) < (24 * 60 * 60)
         }
 
-        // prevent printing of seconds
+        fun updateFields() {
-        fun adjustToMinute(unixTime: Long): Long {
+            datePickerBegin.text = DateUtils.formatDateTime(durationStart)
-            return unixTime - (unixTime % 60)
+            datePickerEnd.text = DateUtils.formatDateTime(durationEnd)
-        }
 
-        fun updateDuration() {
             durationTextView.setTextColor(currentDurationTextColor)
-            val duration = sleepEnd - sleepStart
+            val duration = durationEnd - durationStart
             if (duration == 0L) {
-                // baby is sleeping
+                // event is ongoing
                 durationTextView.text = "💤"
+                dateDelimiter.visibility = View.GONE
+                datePickerEnd.visibility = View.GONE
             } else {
                 durationTextView.text = DateUtils.formatTimeDuration(applicationContext, duration)
-                if (!isValidTimeSpan(sleepStart, sleepEnd)) {
+                if (!isValidTimeSpan(durationStart, durationEnd)) {
                     durationTextView.setTextColor(invalidDurationTextColor)
                 }
+                dateDelimiter.visibility = View.VISIBLE
+                datePickerEnd.visibility = View.VISIBLE
             }
+
+            datePickerBegin.setTextColor(if (isValidTime(durationStart)) { currentDurationTextColor } else { invalidDurationTextColor })
+            datePickerEnd.setTextColor(if (isValidTime(durationEnd)) { currentDurationTextColor } else { invalidDurationTextColor })
         }
 
-        val pickedDateTimeBegin = dateTimePicker(event.time, datePickerBegin) { time: Long ->
+        val pickedDateTimeBegin = dateTimePicker(event.time, datePickerBegin) { pickedTime: Long ->
-            sleepStart = adjustToMinute(time)
+            durationStart = pickedTime
-            updateDuration()
+            if (datePickerEnd.visibility == View.GONE) {
+                durationEnd = pickedTime
+            }
+            updateFields()
         }
 
-        val pickedDateTimeEnd = dateTimePicker(event.time + event.quantity, datePickerEnd) { time: Long ->
+        val pickedDateTimeEnd = dateTimePicker(event.time + event.quantity, datePickerEnd) { pickedTime: Long ->
-            sleepEnd = adjustToMinute(time)
+            durationEnd = pickedTime
-            updateDuration()
+            updateFields()
         }
 
-        sleepStart = adjustToMinute(pickedDateTimeBegin.time.time / 1000)
-        sleepEnd = adjustToMinute(pickedDateTimeEnd.time.time / 1000)
-        updateDuration()
-
         if (showTime) {
+            dateDelimiter.visibility = View.GONE
             datePickerEnd.visibility = View.GONE
             durationTextView.visibility = View.GONE
+            durationButtons.visibility = View.GONE
             //d.setMessage("")
         } else {
+            dateDelimiter.visibility = View.VISIBLE
+            datePickerEnd.visibility = View.VISIBLE
             durationTextView.visibility = View.VISIBLE
+            durationButtons.visibility = View.VISIBLE
             d.setMessage(event.getDialogMessage(this))
         }
 
+        durationStart = pickedDateTimeBegin.time.time / 1000
+        durationEnd = pickedDateTimeEnd.time.time / 1000
+
+        updateFields()
+
+        durationMinus5Button.setOnClickListener {
+            durationEnd = (durationEnd - 300).coerceAtLeast(durationStart)
+            updateFields()
+        }
+
+        durationPlus5Button.setOnClickListener {
+            durationEnd = (durationEnd + 300).coerceAtLeast(durationStart)
+            updateFields()
+        }
+
+        durationClearButton.setOnClickListener {
+            durationEnd = durationStart
+            updateFields()
+        }
+
+        durationNowButton.setOnClickListener {
+            durationEnd = System.currentTimeMillis() / 1000
+            updateFields()
+        }
+
         d.setPositiveButton(android.R.string.ok) { dialogInterface, i ->
-            if (isValidTimeSpan(sleepStart, sleepEnd)) {
+            if (isValidTime(durationStart) && isValidTime(durationEnd) && isValidTimeSpan(durationStart, durationEnd)) {
-                event.time = sleepStart
+                event.time = durationStart
-                event.quantity = (sleepEnd - sleepStart).toInt()
+                event.quantity = (durationEnd - durationStart).toInt()
                 onPositive()
             } else {
                 Toast.makeText(this, R.string.toast_date_error, Toast.LENGTH_SHORT).show()
@@ -843,7 +882,7 @@ class MainActivity : AppCompatActivity() {
                 LunaEvent.Type.PUKE -> askAmountValue(event, false, updateValues)
                 LunaEvent.Type.TEMPERATURE -> askTemperatureValue(event, false, updateValues)
                 LunaEvent.Type.NOTE -> askNotes(event, false, updateValues)
-                LunaEvent.Type.SLEEP -> askSleepValue(event, false, updateValues)
+                LunaEvent.Type.SLEEP -> askDurationEvent(event, false, updateValues)
                 else -> {
                     Log.w(TAG, "Unexpected type: ${event.type}")
                 }
@@ -1270,7 +1309,7 @@ class MainActivity : AppCompatActivity() {
             LunaEvent.Type.FOOD -> addNoteEvent(event)
             LunaEvent.Type.PUKE -> addAmountEvent(event)
             LunaEvent.Type.BATH -> addPlainEvent(event)
-            LunaEvent.Type.SLEEP -> addSleepEvent(event)
+            LunaEvent.Type.SLEEP -> addDurationEvent(event)
             LunaEvent.Type.UNKNOWN -> {} // ignore
         }
     }

app/src/main/java/it/danieleverducci/lunatracker/StatisticsActivity.kt

@@ -1,5 +1,6 @@
 package it.danieleverducci.lunatracker
 
+import android.graphics.Canvas
 import android.graphics.Color
 import android.os.Bundle
 import android.util.Log
@@ -11,14 +12,19 @@ import android.widget.TextView
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.graphics.toColorInt
+import com.github.mikephil.charting.animation.ChartAnimator
 import com.github.mikephil.charting.charts.BarChart
+import com.github.mikephil.charting.components.YAxis
 import com.github.mikephil.charting.data.BarData
 import com.github.mikephil.charting.data.BarDataSet
 import com.github.mikephil.charting.data.BarEntry
 import com.github.mikephil.charting.data.Entry
 import com.github.mikephil.charting.formatter.ValueFormatter
 import com.github.mikephil.charting.highlight.Highlight
+import com.github.mikephil.charting.interfaces.dataprovider.BarDataProvider
 import com.github.mikephil.charting.listener.OnChartValueSelectedListener
+import com.github.mikephil.charting.renderer.HorizontalBarChartRenderer
+import com.github.mikephil.charting.utils.ViewPortHandler
 import it.danieleverducci.lunatracker.entities.LunaEvent
 import utils.DateUtils
 import utils.NumericUtils
@@ -175,14 +181,11 @@ class StatisticsActivity : AppCompatActivity() {
         val values = ArrayList<BarEntry>()
         val stack = ArrayList(List(state.endSpan - state.startSpan + 1) { IntArray(24 * 60 * 60 / SLEEP_PATTERN_GRANULARITY) })
 
-        Log.d(TAG, "stack.size: ${stack.size}, array.size: ${stack[0].size}, dayCounter.daysWithData.size: ${state.dayCounter.daysWithData.size}")
-
         fun stackValuePattern(index: Int, spanBegin: Long, spanEnd: Long, begin: Long, end: Long) {
             val beginDays = unixToDays(begin)
             val endDays = unixToDays(end)
             var mid = begin
 
-            //Log.d(TAG, "stackValuePattern: ${beginDays}..${endDays}")
             for (i in beginDays..endDays) {
                 // i is the days/weeks/months since unix epoch
                 val dayBegin = daysToUnix(i)
@@ -195,7 +198,6 @@ class StatisticsActivity : AppCompatActivity() {
                     assert(sleepBegin <= sleepEnd)
                     val iBegin = (sleepBegin - dayBegin) / SLEEP_PATTERN_GRANULARITY
                     val iEnd = iBegin + (sleepEnd - sleepBegin) / SLEEP_PATTERN_GRANULARITY
-                    //Log.d(TAG, "index: $index, iBegin: $iBegin, iEnd: $iEnd, dayBegin: ${Date(dayBegin * 1000)}, dayEnd: ${Date(dayEnd * 1000)}, sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}")
                     for (j in iBegin..<iEnd) {
                         stack[index][j.toInt()] += 1
                     }
@@ -213,17 +215,14 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
-            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
-                //Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
-                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
                 stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
@@ -250,7 +249,6 @@ class StatisticsActivity : AppCompatActivity() {
         for ((index, dayArray) in stack.withIndex()) {
             val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
 
-            //Log.d(TAG, "index: $index: daysWithData: $daysWithData, dayArray: ${dayArray.joinToString { it.toString() }}")
             val vals = ArrayList<Float>()
 
             var prevIndex = -1 // time slot index
@@ -272,14 +270,10 @@ class StatisticsActivity : AppCompatActivity() {
                 allColors.add(mapColor(prevValue, daysWithData))
             }
 
-            //Log.d(TAG, "Range $index, vals: ${vals.joinToString { it.toInt().toString() }}") //, allColors: ${allColors.joinToString { it.toString() }}")
+            assert(values.size == index)
-
+            values.add(BarEntry(values.size.toFloat(), vals.toFloatArray()))
-            //Log.d(TAG, "index: ${index.toFloat()}")
-            values.add(BarEntry(index.toFloat(), vals.toFloatArray()))
         }
 
-        //Log.d(TAG, "daysWithData: ${state.dayCounter.daysWithData.joinToString()}")
-
         barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
             override fun onValueSelected(e: Entry?, h: Highlight?) {
                 if (e == null || h == null) {
@@ -303,7 +297,6 @@ class StatisticsActivity : AppCompatActivity() {
 
                 val dayStartUnix = daysToUnix(unixToDays(state.startUnix) + index)
 
-                //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, x: ${e.x.toInt()}, dayStartUnix: ${Date(dayStartUnix * 1000)}")
                 val startSeconds =
                     SLEEP_PATTERN_GRANULARITY * value.yVals.sliceArray(0..<h.stackIndex)
                         .fold(0) { acc, y -> acc + y.toInt() }
@@ -316,10 +309,7 @@ class StatisticsActivity : AppCompatActivity() {
                     format.format((dayStartUnix + startSeconds) * 1000).toString()
                 val endTimeString =
                     format.format((dayStartUnix + endSeconds) * 1000).toString()
-                val durationString = NumericUtils(applicationContext).formatEventQuantity(
+                val durationString = DateUtils.formatTimeDuration(applicationContext, durationSeconds.toLong())
-                    LunaEvent.Type.SLEEP,
-                    durationSeconds
-                )
 
                 val daysWithData =
                     stack[e.x.toInt()][startSeconds / SLEEP_PATTERN_GRANULARITY]
@@ -348,28 +338,21 @@ class StatisticsActivity : AppCompatActivity() {
         })
 
         val set1 = BarDataSet(values, "")
-        val data = BarData(set1)
         set1.colors = allColors
-
         set1.setDrawValues(false) // usually too many values
         set1.isHighlightEnabled = true
-
         set1.setDrawIcons(false)
 
-        //Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
+        val data = BarData(set1)
-
         data.setValueTextSize(12f)
-        barChart.setData(data)
 
-        // does not work quite right yet
-        //Log.d(TAG, "xChartMax: ${barChart.xChartMax}")
-        //barChart.centerViewTo(barChart.xChartMax, 0F, YAxis.AxisDependency.LEFT)
-
-        barChart.legend.isEnabled = false
         val valueCount = min(values.size, 24)
+        barChart.setData(data)
+        barChart.legend.isEnabled = false
         barChart.setVisibleXRangeMaximum(valueCount.toFloat())
         barChart.xAxis.setLabelCount(valueCount)
         barChart.xAxis.setCenterAxisLabels(false)
+        barChart.moveViewTo(data.getEntryCount().toFloat(), 0f, YAxis.AxisDependency.LEFT)
         barChart.invalidate()
     }
 
@@ -400,7 +383,8 @@ class StatisticsActivity : AppCompatActivity() {
 
             // update value
             val newYVals = appendToFloatArray(yVals, awakeDuration.toFloat(), sleepDuration.toFloat())
-            values[index] = BarEntry(x, newYVals)
+            assert(index == x.toInt())
+            values[index] = BarEntry(index.toFloat(), newYVals)
         }
 
         for (range in ranges) {
@@ -412,17 +396,14 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
-            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
-                //Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
-                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
                 stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
@@ -431,12 +412,11 @@ class StatisticsActivity : AppCompatActivity() {
             }
         }
 
-        val set1 = BarDataSet(values, "")
-        val data = BarData(set1)
-
         // awake phase color is transparent
+        val set1 = BarDataSet(values, "")
         set1.colors = arrayListOf("#00000000".toColorInt(), "#72d7f5".toColorInt())
         set1.setDrawValues(false) // usually too many values
+        set1.setDrawIcons(false)
         set1.isHighlightEnabled = true
 
         barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
@@ -461,7 +441,7 @@ class StatisticsActivity : AppCompatActivity() {
                 }
 
                 val duration = value.yVals[h.stackIndex].toInt()
-                val durationString = NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, duration)
+                val durationString = DateUtils.formatTimeDuration(applicationContext, duration.toLong())
 
                 val offsetUnix = spanToUnix(state.startSpan + e.x.toInt()) // start of the time span (day/week/month)
                 val startUnix = offsetUnix + value.yVals.sliceArray(0..<h.stackIndex).fold(0) { acc, y -> acc + y.toInt() }
@@ -476,26 +456,37 @@ class StatisticsActivity : AppCompatActivity() {
 
             override fun onNothingSelected() {}
         })
-        //Log.d(TAG, "showSleepPatternBarGraphDaily: values.size: ${values.size}, barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
-        set1.setDrawIcons(false)
 
+        val data = BarData(set1)
         data.setValueTextSize(12f)
-        barChart.setData(data)
 
-        //Log.d(TAG, "showSleepPatternBarGraphDaily: new barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
-
-        barChart.legend.isEnabled = false
         val valueCount = min(values.size, 24)
+        barChart.setData(data)
+        barChart.legend.isEnabled = false
         barChart.setVisibleXRangeMaximum(valueCount.toFloat())
         barChart.xAxis.setLabelCount(valueCount)
         barChart.xAxis.setCenterAxisLabels(false)
+        barChart.moveViewTo(data.getEntryCount().toFloat(), 0f, YAxis.AxisDependency.LEFT)
         barChart.invalidate()
     }
 
+    // Make sure the value on the bar is not out of screen.
+    class CustomHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator, viewPortHandler: ViewPortHandler): HorizontalBarChartRenderer(chart, animator, viewPortHandler) {
+        override fun drawValue(
+            c: Canvas,
+            valueText: String,
+            x: Float,
+            y: Float,
+            color: Int
+        ) {
+            mValuePaint.setColor(color)
+            c.drawText(valueText, x.coerceAtLeast(60F), y, mValuePaint)
+        }
+    }
+
     fun showSleepBarGraph(state: GraphState) {
         val ranges = toSleepRanges(state.events)
         val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
-        //Log.d(TAG, "startUnix: ${Date(state.startUnix * 1000)}, endUnix: ${Date(state.endUnix * 1000)}")
 
         for (range in ranges) {
             // a sleep event can span to another day
@@ -506,18 +497,14 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
-            //Log.d(TAG, "beginIndex: $begIndex, endIndex: $endIndex, startUnix: ${Date(startUnix * 1000)} ($startUnix), endUnix: ${Date(endUnix * 1000)} ($endUnix)")
-            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
-                //Log.d(TAG, "i: $i, mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
-                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
 
@@ -544,19 +531,22 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         val set1 = BarDataSet(values, "")
-        val data = BarData(set1)
         set1.setDrawValues(true)
+        set1.setDrawIcons(false)
         set1.isHighlightEnabled = false
 
+        val data = BarData(set1)
+        data.setValueTextSize(12f)
         data.setValueFormatter(object : ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
+
                 val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
                 return when (graphTypeSelection) {
                     GraphType.SLEEP_EVENTS -> {
                         prefix + value.toInt().toString()
                     }
                     GraphType.SLEEP_SUM -> {
-                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, value.toInt())
+                        prefix + DateUtils.formatTimeDuration(applicationContext, value.toLong())
                     }
                     else -> {
                         Log.e(TAG, "unhandled graphTypeSelection $graphTypeSelection")
@@ -566,16 +556,14 @@ class StatisticsActivity : AppCompatActivity() {
             }
         })
 
-        set1.setDrawIcons(false)
-
-        data.setValueTextSize(12f)
-        barChart.setData(data)
-
-        barChart.legend.isEnabled = false
         val valueCount = min(values.size, 24)
+        barChart.renderer = CustomHorizontalBarChartRenderer(barChart, barChart.animator, barChart.viewPortHandler)
+        barChart.setData(data)
+        barChart.legend.isEnabled = false
         barChart.setVisibleXRangeMaximum(valueCount.toFloat())
         barChart.xAxis.setLabelCount(valueCount)
         barChart.xAxis.setCenterAxisLabels(false)
+        barChart.moveViewTo(data.getEntryCount().toFloat(), 0f, YAxis.AxisDependency.LEFT)
         barChart.invalidate()
     }
 
@@ -599,7 +587,6 @@ class StatisticsActivity : AppCompatActivity() {
 
         for (index in values.indices) {
             val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
-            //Log.d(TAG, "values[$index].y: ${values[index].y}, daysWithData: $daysWithData")
             if (daysWithData == 0) {
                 assert(values[index].y == 0F)
             } else {
@@ -608,15 +595,14 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         val set1 = BarDataSet(values, "")
-
         set1.setDrawValues(true)
         set1.isHighlightEnabled = false
-        val data = BarData(set1)
 
+        val data = BarData(set1)
+        data.setValueTextSize(12f)
         data.setValueFormatter(object : ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
                 val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
-                //Log.d(TAG, "getFormattedValue ${dataTypeSelectionValue} ${eventTypeSelectionValue}")
                 return when (graphTypeSelection) {
                     GraphType.BOTTLE_EVENTS -> {
                         prefix + value.toInt().toString()
@@ -632,13 +618,13 @@ class StatisticsActivity : AppCompatActivity() {
             }
         })
 
-        data.setValueTextSize(12f)
-        barChart.setData(data)
-
         val valueCount = min(values.size, 24)
+        barChart.renderer = CustomHorizontalBarChartRenderer(barChart, barChart.animator, barChart.viewPortHandler)
+        barChart.setData(data)
         barChart.setVisibleXRangeMaximum(valueCount.toFloat())
         barChart.xAxis.setLabelCount(valueCount)
         barChart.xAxis.setCenterAxisLabels(false)
+        barChart.moveViewTo(data.getEntryCount().toFloat(), 0f, YAxis.AxisDependency.LEFT)
         barChart.invalidate()
     }
 
@@ -650,10 +636,8 @@ class StatisticsActivity : AppCompatActivity() {
         fun countDaysWithData(beginUnix: Long, endUnix: Long): Int {
             val beginDays = unixToDays(beginUnix)
             val endDays = unixToDays(endUnix)
-            //Log.d(TAG, "countDaysWithData: beginDays: $beginDays, endDays: $endDays, ${Date(beginUnix * 1000)} - ${Date(endUnix * 1000)}")
             var count = 0
             for (i in (beginDays - startDays)..<(endDays - startDays)) {
-                //Log.d(TAG, "countDaysWithData: i: $i, size: ${daysWithData.size}")
                 count += if (daysWithData[i]) { 1 } else { 0 }
             }
             return count
@@ -673,14 +657,12 @@ class StatisticsActivity : AppCompatActivity() {
     data class GraphState(val events: List<LunaEvent>, val dayCounter: DayCounter, val startUnix: Long, val endUnix: Long, val startSpan: Int, val endSpan: Int)
 
     fun showGraph() {
-        //Log.d(TAG, "showGraph: graphTypeSelection: $graphTypeSelection, timeRangeSelection: $timeRangeSelection")
         barChart.fitScreen()
         barChart.data?.clearValues()
         barChart.xAxis.valueFormatter = null
         barChart.notifyDataSetChanged()
         barChart.clear()
         barChart.invalidate()
-        //Log.d(TAG, "resetBarChart; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
 
         val type = when (graphTypeSelection) {
             GraphType.BOTTLE_EVENTS,
@@ -690,7 +672,6 @@ class StatisticsActivity : AppCompatActivity() {
             GraphType.SLEEP_PATTERN -> LunaEvent.Type.SLEEP
         }
 
-
         val events = MainActivity.allEvents.filter { it.type == type }.sortedBy { it.time }
 
         if (events.isEmpty()) {
@@ -715,8 +696,6 @@ class StatisticsActivity : AppCompatActivity() {
         val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next span
         val dayCounter = DayCounter(startDays, endDays)
 
-        //Log.d(TAG, "startUnix: ${Date(1000 * startUnix)}, endUnix: ${Date(1000 * endUnix)}, startSpan: ${Date(1000 * spanToUnix(startSpan))}, endSpan: ${Date(1000 * spanToUnix(endSpan))}, startDaysUnix: ${Date(daysToUnix(startDays) * 1000)}. endDaysUnix: ${Date(daysToUnix(endDays) * 1000)}")
-
         // print dates
         barChart.xAxis.valueFormatter = object: ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
@@ -730,8 +709,6 @@ class StatisticsActivity : AppCompatActivity() {
                 val week = dateTime.get(Calendar.WEEK_OF_YEAR)
                 val day = dateTime.get(Calendar.DAY_OF_MONTH)
 
-                //Log.d(TAG, "index: $index, unixSeconds: ${Date(1000 * unixSeconds)}, day: $day, week: $week, month: $month, year: $year")
-
                 // Adjust years if the first week of a year starts in the previous year.
                 val years = if (month == 12 && week == 1) {
                     year + 1
@@ -783,8 +760,6 @@ class StatisticsActivity : AppCompatActivity() {
         val spinnerAdapter =
             ArrayAdapter.createFromResource(this, arrayId, R.layout.statistics_spinner_item)
 
-        //Log.d(TAG, "spinner ${arrayValues.indexOf(currentValue)} (${arrayValues.joinToString { it }})")
-
         spinner.adapter = spinnerAdapter
         spinner.setSelection(arrayValues.indexOf(currentValue))
         spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {

app/src/main/java/it/danieleverducci/lunatracker/entities/LunaEvent.kt

@@ -174,7 +174,7 @@ class LunaEvent: Comparable<LunaEvent> {
                     Type.DIAPERCHANGE_PEE,
                     Type.PUKE -> R.string.log_amount_dialog_description
                     Type.WEIGHT -> R.string.log_weight_dialog_description
-                    Type.SLEEP -> R.string.log_sleep_dialog_description
+                    Type.SLEEP -> R.string.log_duration_dialog_description
                     else -> R.string.log_unknown_dialog_description
                 }
             )

app/src/main/java/utils/DateUtils.kt

@@ -9,10 +9,15 @@ import java.util.Date
 class DateUtils {
     companion object {
         /**
-         * Format time duration in seconds as e.g. "2 hours, 1 min".
+         * Format time duration in seconds as e.g. "2 hours, 1 min", rounded to minutes.
          * Used for the duration to the next/previous event in the event details dialog.
          */
         fun formatTimeDuration(context: Context, secondsDiff: Long): String {
+            val adjusted = (secondsDiff + 30) - (secondsDiff + 30) % 60
+            return formatTimeDurationExact(context, adjusted)
+        }
+
+        fun formatTimeDurationExact(context: Context, secondsDiff: Long): String {
             var seconds = secondsDiff
 
             val years = (seconds / (365 * 24 * 60 * 60F)).toLong()

app/src/main/res/layout/dialog_edit_bottle.xml

@@ -18,6 +18,7 @@
             android:layout_height="wrap_content"/>
 
         <TextView
+            android:id="@+id/dialog_number_picker_unit"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginStart="10dp"

app/src/main/res/layout/dialog_edit_duration.xml

@@ -7,26 +7,83 @@
     android:gravity="center"
     android:orientation="vertical">
 
-    <TextView
-        android:id="@+id/dialog_date_picker_begin"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center"
-        android:layout_marginTop="10dp"/>
-
     <TextView
         android:id="@+id/dialog_date_duration"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_marginTop="20dp"
+        android:layout_marginTop="10dp"
         android:textSize="20sp"
         android:text="💤"/>
 
-    <TextView
+    <LinearLayout
-        android:id="@+id/dialog_date_picker_end"
+        android:id="@+id/duration_buttons"
-        android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_gravity="center"
+        android:layout_width="match_parent"
-        android:layout_marginTop="20dp"/>
+        android:gravity="center"
+        android:layout_marginTop="20dp"
+        android:layout_marginHorizontal="10dp"
+        android:orientation="horizontal">
+
+        <Button
+            android:id="@+id/dialog_date_duration_minus5"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/dialog_duration_button_minus_5"/>
+
+        <Button
+            android:id="@+id/dialog_date_duration_now"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/dialog_duration_button_now"/>
+
+        <Button
+            android:id="@+id/dialog_date_duration_clear"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/dialog_duration_button_clear"/>
+
+        <Button
+            android:id="@+id/dialog_date_duration_plus5"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/dialog_duration_button_plus_5"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_height="wrap_content"
+        android:layout_width="match_parent"
+        android:gravity="center"
+        android:layout_marginTop="20dp"
+        android:layout_marginHorizontal="10dp"
+        android:orientation="horizontal">
+
+        <TextView
+            android:id="@+id/dialog_date_picker_begin"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:gravity="center"
+            android:layout_weight="1"/>
+
+        <TextView
+            android:id="@+id/dialog_date_range_delimiter"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:gravity="center"
+            android:layout_weight="1"
+            android:text="－"/>
+
+        <TextView
+            android:id="@+id/dialog_date_picker_end"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:gravity="center"
+            android:layout_weight="1"/>
+
+    </LinearLayout>
 
 </LinearLayout>

app/src/main/res/values/strings.xml

@@ -130,7 +130,7 @@
     <string name="log_temperature_dialog_description">Select the temperature:</string>
     <string name="log_unknown_dialog_description"></string>
     <string name="log_weight_dialog_description">Insert the weight:</string>
-    <string name="log_sleep_dialog_description">Set sleep duration:</string>
+    <string name="log_duration_dialog_description">Set duration:</string>
 
     <string name="measurement_unit_liquid_base_metric" translatable="false">ml</string>
     <string name="measurement_unit_weight_base_metric" translatable="false">g</string>
@@ -160,6 +160,11 @@
     <string name="dialog_event_detail_notes">Notes</string>
     <string name="dialog_event_detail_signature">by %s</string>
 
+    <string name="dialog_duration_button_clear">Clear</string>
+    <string name="dialog_duration_button_minus_5">-5 min</string>
+    <string name="dialog_duration_button_now">Now</string>
+    <string name="dialog_duration_button_plus_5">+5 min</string>
+
     <string name="dialog_add_logbook_title">Add logbook</string>
     <string name="dialog_add_logbook_logbookname">👶 Logbook name</string>
     <string name="dialog_add_logbook_message">Write a name to identify this logbook. This name will appear on top of the screen and, if you use WebDAV, will be in the save file name as well.</string>