global: rename StatisticsActivity to LongTermStatisticsActivity

Make way for a future ShortTermStatisticsActivity.

app/build.gradle.kts

@@ -6,12 +6,12 @@ plugins {
 
 android {
     namespace = "it.danieleverducci.lunatracker"
-    compileSdk = 34
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "it.danieleverducci.lunatracker"
         minSdk = 21
-        targetSdk = 34
+        targetSdk = 36
         versionCode = 7
         versionName = "0.9"
 
@@ -31,6 +31,12 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
+    dependenciesInfo {
+        // Disables dependency metadata when building APKs.
+        includeInApk = false
+        // Disables dependency metadata when building Android App Bundles.
+        includeInBundle = false
+    }
     kotlinOptions {
         jvmTarget = "11"
     }
@@ -40,7 +46,6 @@ android {
 }
 
 dependencies {
-
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
@@ -51,7 +56,7 @@ dependencies {
     implementation(libs.androidx.material3)
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.recyclerview)
-    implementation("com.github.thegrizzlylabs:sardine-android:v0.9")
+    implementation(libs.sardine.android)
     implementation(libs.material)
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
@@ -60,7 +65,5 @@ dependencies {
     androidTestImplementation(libs.androidx.ui.test.junit4)
     debugImplementation(libs.androidx.ui.tooling)
     debugImplementation(libs.androidx.ui.test.manifest)
-    implementation("com.github.PhilJay:MPAndroidChart:v3.1.0")
+    implementation(libs.mpandroidchart.vv310)
-//    implementation(libs.mpandroidchart)
-    //implementation project(':MPChartLib')
 }

app/src/main/AndroidManifest.xml

@@ -31,7 +31,7 @@
             android:label="@string/settings_title"
             android:theme="@style/Theme.LunaTracker"/>
         <activity
-            android:name=".StatisticsActivity"
+            android:name=".LongTermStatisticsActivity"
             android:label="@string/statistics_title"
             android:theme="@style/Theme.LunaTracker"/>
     </application>

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

@@ -0,0 +1,901 @@
+package it.danieleverducci.lunatracker
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.os.Bundle
+import android.util.Log
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Spinner
+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
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import kotlin.math.max
+import kotlin.math.min
+
+class LongTermStatisticsActivity : AppCompatActivity() {
+    var lastToastShown = 0L
+
+    lateinit var barChart: BarChart
+    lateinit var noDataTextView: TextView
+    lateinit var graphTypeSpinner: Spinner
+    lateinit var timeRangeSpinner: Spinner
+
+    lateinit var unixToSpan: (Long) -> Int
+    lateinit var spanToUnix: (Int) -> Long
+
+    enum class GraphType {
+        BOTTLE_EVENTS,
+        BOTTLE_SUM,
+        SLEEP_SUM,
+        SLEEP_EVENTS,
+        SLEEP_PATTERN
+    }
+
+    enum class TimeRange {
+        DAY,
+        WEEK,
+        MONTH
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        setContentView(R.layout.activity_statistics)
+
+        val logbookName = intent.getStringExtra("LOOGBOOK_NAME")
+        if (logbookName == null) {
+            finish()
+            return
+        }
+
+        noDataTextView = findViewById(R.id.no_data)
+
+        barChart = findViewById(R.id.bar_chart)
+        barChart.setBackgroundColor(Color.WHITE)
+        barChart.description.text = logbookName
+        barChart.setDrawValueAboveBar(false)
+
+        barChart.axisLeft.setAxisMinimum(0F)
+        barChart.axisLeft.setDrawGridLines(false)
+        barChart.axisLeft.setDrawLabels(false)
+
+        barChart.axisRight.setDrawGridLines(false)
+        barChart.axisRight.setDrawLabels(false)
+
+        barChart.xAxis.setDrawLabels(true)
+        barChart.xAxis.setDrawAxisLine(false)
+
+        barChart.isScaleXEnabled = false
+        barChart.isScaleYEnabled = true
+
+        graphTypeSpinner = findViewById(R.id.graph_type_selection)
+        timeRangeSpinner = findViewById(R.id.time_range_selection)
+
+        setupSpinner(graphTypeSelection.name,
+            R.id.graph_type_selection,
+            R.array.StatisticsTypeLabels,
+            R.array.StatisticsTypeValues,
+            object : SpinnerItemSelected {
+                override fun call(newValue: String?) {
+                    //Log.d("event", "new value: $newValue")
+                    newValue ?: return
+                    graphTypeSelection = GraphType.valueOf(newValue)
+                    showGraph()
+                }
+            }
+        )
+
+        setupSpinner(timeRangeSelection.name,
+            R.id.time_range_selection,
+            R.array.StatisticsTimeLabels,
+            R.array.StatisticsTimeValues,
+            object : SpinnerItemSelected {
+                override fun call(newValue: String?) {
+                    //Log.d("event", "new value: $newValue")
+                    newValue ?: return
+                    timeRangeSelection = TimeRange.valueOf(newValue)
+                    setSpans()
+                    showGraph()
+                }
+            }
+        )
+
+        setSpans()
+        showGraph()
+    }
+
+    fun setSpans() {
+        unixToSpan  = when (timeRangeSelection) {
+            TimeRange.DAY -> { unix: Long -> unixToDays(unix) }
+            TimeRange.WEEK -> { unix: Long -> unixToWeeks(unix) }
+            TimeRange.MONTH -> { unix: Long -> unixToMonths(unix) }
+        }
+
+        spanToUnix = when (timeRangeSelection) {
+            TimeRange.DAY -> { span: Int -> daysToUnix(span) }
+            TimeRange.WEEK -> { span: Int -> weeksToUnix(span) }
+            TimeRange.MONTH -> { span: Int -> monthsToUnix(span) }
+        }
+    }
+
+    data class SleepRange(val start: Long, var end: Long)
+
+    fun toSleepRanges(events: List<LunaEvent>): ArrayList<SleepRange> {
+        val ranges = arrayListOf<SleepRange>()
+        val now = System.currentTimeMillis() / 1000
+
+        // Transform events into time ranges.
+        // Merge overlapping times and extend
+        // ongoing sleep events until now.
+        var warningShown = false
+        for (event in events) {
+            val startTime = event.time
+            val endTime = if (event.quantity == 0) {
+                now
+            } else {
+                event.time + event.quantity
+            }
+
+            // handle overlap
+            val previousRange = ranges.lastOrNull()
+            if (previousRange != null && previousRange.end > startTime) {
+                // cap previous range to avoid overlap
+                previousRange.end = startTime
+                if (!warningShown) {
+                    Toast.makeText(applicationContext, "Overlapping sleep event at ${DateUtils.formatDateTime(startTime)}", Toast.LENGTH_SHORT).show()
+                    warningShown = true
+                }
+            }
+
+            ranges.add(SleepRange(startTime, endTime))
+        }
+
+        return ranges
+    }
+
+    fun showSleepPatternBarGraphSlotted(state: GraphState) {
+        val ranges = toSleepRanges(state.events)
+        val values = ArrayList<BarEntry>()
+        val stack = ArrayList(List(state.endSpan - state.startSpan + 1) { IntArray(24 * 60 * 60 / SLEEP_PATTERN_GRANULARITY) })
+
+        fun stackValuePattern(index: Int, spanBegin: Long, spanEnd: Long, begin: Long, end: Long) {
+            val beginDays = unixToDays(begin)
+            val endDays = unixToDays(end)
+            var mid = begin
+
+            for (i in beginDays..endDays) {
+                // i is the days/weeks/months since unix epoch
+                val dayBegin = daysToUnix(i)
+                val dayEnd =  daysToUnix(i + 1)
+                val sleepBegin = max(mid, dayBegin)
+                val sleepEnd = min(end, dayEnd)
+
+                if (sleepBegin != sleepEnd) {
+                    assert(dayBegin <= dayEnd)
+                    assert(sleepBegin <= sleepEnd)
+                    val iBegin = (sleepBegin - dayBegin) / SLEEP_PATTERN_GRANULARITY
+                    val iEnd = iBegin + (sleepEnd - sleepBegin) / SLEEP_PATTERN_GRANULARITY
+                    for (j in iBegin..<iEnd) {
+                        stack[index][j.toInt()] += 1
+                    }
+                }
+                mid = sleepEnd
+            }
+        }
+
+        for (range in ranges) {
+            // a sleep event can span to another day
+            // distribute sleep time over the days
+            val startUnix = range.start
+            val endUnix = range.end
+            val begIndex = unixToSpan(startUnix)
+            val endIndex = unixToSpan(endUnix)
+            var mid = startUnix
+
+            for (i in begIndex..endIndex) {
+                // i is the days/weeks/months since unix epoch
+                val spanBegin = spanToUnix(i)
+                val spanEnd =  spanToUnix(i + 1)
+                val sleepBegin = max(mid, spanBegin)
+                val sleepEnd = min(endUnix, spanEnd)
+                val index = i - state.startSpan
+                val duration = sleepEnd - sleepBegin
+
+                state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
+                stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
+
+                mid = sleepEnd
+            }
+        }
+
+        fun mapColor(occurrences: Int, maxOccurrences: Int): Int {
+            // occurrences: number of reported sleeps in a specific time slot
+            // maxOccurrences: maximum number of days with data that can contribute to maxOccurrences
+            assert(maxOccurrences > 0)
+            assert(occurrences <= maxOccurrences)
+
+            // map to color
+            val q = occurrences.toFloat() / maxOccurrences.toFloat()
+            val i = q * (SLEEP_PATTERN_COLORS.size - 1).toFloat()
+            return SLEEP_PATTERN_COLORS[i.toInt()]
+        }
+
+        val allColors = ArrayList<Int>()
+
+        // convert array of time slots that represent a day to value and color arrays used by chart library
+        for ((index, dayArray) in stack.withIndex()) {
+            val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
+
+            val vals = ArrayList<Float>()
+
+            var prevIndex = -1 // time slot index
+            var prevValue = -1 // number of entries we have found for time slot
+            for ((i, v) in dayArray.withIndex()) {
+                if (i == 0) {
+                    prevIndex = i
+                    prevValue = v
+                } else if (prevValue != v) {
+                    vals.add((i - prevIndex).toFloat())
+                    allColors.add(mapColor(prevValue.coerceAtMost(daysWithData), daysWithData))
+                    prevIndex = i
+                    prevValue = v
+                }
+            }
+
+            if (prevIndex != -1) {
+                vals.add((dayArray.size - prevIndex).toFloat())
+                allColors.add(mapColor(prevValue, daysWithData))
+            }
+
+            assert(values.size == index)
+            values.add(BarEntry(values.size.toFloat(), vals.toFloatArray()))
+        }
+
+        barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
+            override fun onValueSelected(e: Entry?, h: Highlight?) {
+                if (e == null || h == null) {
+                    return
+                }
+
+                val index = e.x.toInt()
+                if (index !in 0..values.size) {
+                    return
+                }
+
+                val value = values[index]
+                if (value.yVals == null || h.stackIndex !in 0..value.yVals.size) {
+                    return
+                }
+
+                if ((lastToastShown + TOAST_FREQUENCY_MS) > System.currentTimeMillis()) {
+                    // only show one Toast message after another
+                    return
+                }
+
+                val dayStartUnix = daysToUnix(unixToDays(state.startUnix) + index)
+
+                val startSeconds =
+                    SLEEP_PATTERN_GRANULARITY * value.yVals.sliceArray(0..<h.stackIndex)
+                        .fold(0) { acc, y -> acc + y.toInt() }
+                val durationSeconds =
+                    SLEEP_PATTERN_GRANULARITY * value.yVals[h.stackIndex].toInt()
+                val endSeconds = startSeconds + durationSeconds
+
+                val format = SimpleDateFormat("HH:mm", Locale.getDefault())
+                val startTimeString =
+                    format.format((dayStartUnix + startSeconds) * 1000).toString()
+                val endTimeString =
+                    format.format((dayStartUnix + endSeconds) * 1000).toString()
+                val durationString = DateUtils.formatTimeDuration(applicationContext, durationSeconds.toLong())
+
+                val daysWithData =
+                    stack[e.x.toInt()][startSeconds / SLEEP_PATTERN_GRANULARITY]
+                val daysWithDataMax = state.dayCounter.countDaysWithData(
+                    spanToUnix(state.startSpan + index),
+                    spanToUnix(state.startSpan + index + 1)
+                )
+
+                // percentage of days in this span where baby is asleep in this time slot
+                val pc = if (daysWithDataMax > 0) {
+                    (100F * daysWithData.toFloat() / daysWithDataMax.toFloat()).toInt()
+                } else {
+                    // no data for this day
+                    0
+                }
+
+                Toast.makeText(
+                    applicationContext,
+                    "$startTimeString - $endTimeString ($durationString) - ${pc}%",
+                    Toast.LENGTH_LONG
+                ).show()
+                lastToastShown = System.currentTimeMillis()
+            }
+
+            override fun onNothingSelected() {}
+        })
+
+        val set1 = BarDataSet(values, "")
+        set1.colors = allColors
+        set1.setDrawValues(false) // usually too many values
+        set1.isHighlightEnabled = true
+        set1.setDrawIcons(false)
+
+        val data = BarData(set1)
+        data.setValueTextSize(12f)
+
+        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()
+    }
+
+    // Sleep pattern bars that do not use time slots.
+    // This is useful/nicer for bars that only represent data of a singular days.
+    fun showSleepPatternBarGraphDaily(state: GraphState) {
+        val ranges = toSleepRanges(state.events)
+        val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), FloatArray(0)) })
+
+        // stack awake/sleep durations
+        fun stackValuePattern(index: Int, spanBegin: Long, spanEnd: Long, begin: Long, end: Long) {
+            assert(begin in spanBegin..spanEnd)
+            assert(end in spanBegin..spanEnd)
+            assert(begin <= end)
+
+            val x = values[index].x
+            val yVals  = values[index].yVals // alternating sleep/awake durations
+            val y = yVals.fold(0F) { acc, next -> acc + next }
+
+            // y value is seconds when last awake
+            val awakeDuration = max(begin - spanBegin - y.toLong(), 0L)
+            val sleepDuration = end - begin
+
+            if ((awakeDuration + sleepDuration) > (spanEnd - spanBegin)) {
+                Log.e(TAG, "Invalid sleep duration, exceeds day/week or month bounds => ignore value")
+                return
+            }
+
+            // update value
+            val newYVals = appendToFloatArray(yVals, awakeDuration.toFloat(), sleepDuration.toFloat())
+            assert(index == x.toInt())
+            values[index] = BarEntry(index.toFloat(), newYVals)
+        }
+
+        for (range in ranges) {
+            // a sleep event can span to another day
+            // distribute sleep time over the days
+            val startUnix = range.start
+            val endUnix = range.end
+            val begIndex = unixToSpan(startUnix)
+            val endIndex = unixToSpan(endUnix)
+            var mid = startUnix
+
+            for (i in begIndex..endIndex) {
+                // i is the days/weeks/months since unix epoch
+                val spanBegin = spanToUnix(i)
+                val spanEnd =  spanToUnix(i + 1)
+                val sleepBegin = max(mid, spanBegin)
+                val sleepEnd = min(endUnix, spanEnd)
+                val index = i - state.startSpan
+                val duration = sleepEnd - sleepBegin
+
+                state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
+                stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
+
+                mid = sleepEnd
+            }
+        }
+
+        // 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 {
+            override fun onValueSelected(e: Entry?, h: Highlight?) {
+                if (e == null || h == null) {
+                    return
+                }
+
+                val index = e.x.toInt()
+                if (index !in 0..values.size) {
+                    return
+                }
+
+                val value = values[index]
+                if (value.yVals == null || h.stackIndex !in 0..value.yVals.size) {
+                    return
+                }
+
+                if ((lastToastShown + TOAST_FREQUENCY_MS) > System.currentTimeMillis()) {
+                    // only show one Toast message after another
+                    return
+                }
+
+                val duration = value.yVals[h.stackIndex].toInt()
+                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() }
+                val endUnix = startUnix + duration
+
+                val format = SimpleDateFormat("HH:mm", Locale.getDefault())
+                val startTimeString = format.format(startUnix * 1000).toString()
+                val endTimeString = format.format(endUnix * 1000).toString()
+                Toast.makeText(applicationContext, "$startTimeString - $endTimeString ($durationString)", Toast.LENGTH_LONG).show()
+                lastToastShown = System.currentTimeMillis()
+            }
+
+            override fun onNothingSelected() {}
+        })
+
+        val data = BarData(set1)
+        data.setValueTextSize(12f)
+
+        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) })
+
+        for (range in ranges) {
+            // a sleep event can span to another day
+            // distribute sleep time over the days
+            val startUnix = range.start
+            val endUnix = range.end
+            val begIndex = unixToSpan(startUnix)
+            val endIndex = unixToSpan(endUnix)
+            var mid = startUnix
+
+            for (i in begIndex..endIndex) {
+                // i is the days/weeks/months since unix epoch
+                val spanBegin = spanToUnix(i)
+                val spanEnd =  spanToUnix(i + 1)
+                val sleepBegin = max(mid, spanBegin)
+                val sleepEnd = min(endUnix, spanEnd)
+                val index = i - state.startSpan
+                val duration = sleepEnd - sleepBegin
+
+                state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
+
+                if (graphTypeSelection == GraphType.SLEEP_SUM) {
+                    values[index].y += duration.toFloat()
+                } else if (graphTypeSelection == GraphType.SLEEP_EVENTS) {
+                    values[index].y += 1F
+                } else {
+                    Log.e(TAG, "Unexpected graph type.")
+                    return
+                }
+
+                mid = sleepEnd
+            }
+        }
+
+        for (index in values.indices) {
+            val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
+            if (daysWithData == 0) {
+                assert(values[index].y == 0F)
+            } else {
+                values[index].y /= daysWithData
+            }
+        }
+
+        val set1 = BarDataSet(values, "")
+        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 + DateUtils.formatTimeDuration(applicationContext, value.toLong())
+                    }
+                    else -> {
+                        Log.e(TAG, "unhandled graphTypeSelection $graphTypeSelection")
+                        prefix + value.toInt().toString()
+                    }
+                }
+            }
+        })
+
+        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()
+    }
+
+    fun showBottleBarGraph(state: GraphState) {
+        val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
+
+        for (event in state.events) {
+            val index = unixToSpan(event.time) - state.startSpan
+
+            state.dayCounter.setDaysWithData(event.time, event.time)
+
+            if (graphTypeSelection == GraphType.BOTTLE_EVENTS) {
+                values[index].y += 1F
+            } else if (graphTypeSelection == GraphType.BOTTLE_SUM) {
+                values[index].y += event.quantity.toFloat()
+            } else {
+                Log.e(TAG, "unhandled graphTypeSelection: $graphTypeSelection")
+                return
+            }
+        }
+
+        for (index in values.indices) {
+            val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
+            if (daysWithData == 0) {
+                assert(values[index].y == 0F)
+            } else {
+                values[index].y /= daysWithData
+            }
+        }
+
+        val set1 = BarDataSet(values, "")
+        set1.setDrawValues(true)
+        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.BOTTLE_EVENTS -> {
+                        prefix + value.toInt().toString()
+                    }
+                    GraphType.BOTTLE_SUM -> {
+                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.BABY_BOTTLE, value.toInt())
+                    }
+                    else -> {
+                        Log.e(TAG, "unhandled graphTypeSelection")
+                        prefix + value.toInt()
+                    }
+                }
+            }
+        })
+
+        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()
+    }
+
+    class DayCounter(val startDays: Int, val stopDays: Int) {
+        val daysWithData = BooleanArray(stopDays - startDays + 1)
+
+        // count days in a span that have data
+        // e.g. return 7 (days) for applied span of a week where there is data for every day 
+        fun countDaysWithData(beginUnix: Long, endUnix: Long): Int {
+            val beginDays = unixToDays(beginUnix)
+            val endDays = unixToDays(endUnix)
+            var count = 0
+            for (i in (beginDays - startDays)..<(endDays - startDays)) {
+                count += if (daysWithData[i]) { 1 } else { 0 }
+            }
+            return count
+        }
+
+        fun setDaysWithData(beginUnix: Long, endUnix: Long) {
+            val beginDays = unixToDays(beginUnix)
+            val endDays = unixToDays(endUnix)
+            assert(beginDays <= endDays)
+            assert(startDays <= beginDays)
+            for (i in (beginDays - startDays)..(endDays - startDays)) {
+                daysWithData[i] = true
+            }
+        }
+    }
+
+    data class GraphState(val events: List<LunaEvent>, val dayCounter: DayCounter, val startUnix: Long, val endUnix: Long, val startSpan: Int, val endSpan: Int)
+
+    fun showGraph() {
+        barChart.fitScreen()
+        barChart.data?.clearValues()
+        barChart.xAxis.valueFormatter = null
+        barChart.notifyDataSetChanged()
+        barChart.clear()
+        barChart.invalidate()
+
+        val type = when (graphTypeSelection) {
+            GraphType.BOTTLE_EVENTS,
+            GraphType.BOTTLE_SUM -> LunaEvent.Type.BABY_BOTTLE
+            GraphType.SLEEP_EVENTS,
+            GraphType.SLEEP_SUM,
+            GraphType.SLEEP_PATTERN -> LunaEvent.Type.SLEEP
+        }
+
+        val events = MainActivity.allEvents.filter { it.type == type }.sortedBy { it.time }
+
+        if (events.isEmpty()) {
+            barChart.visibility = View.GONE
+            noDataTextView.visibility = View.VISIBLE
+            return
+        } else {
+            barChart.visibility = View.VISIBLE
+            noDataTextView.visibility = View.GONE
+        }
+
+        // unix time span of all events
+        val startUnix = events.minOf { it.time }
+        val endUnix = System.currentTimeMillis() / 1000
+
+        // convert to days, weeks or months
+        val startSpan = unixToSpan(startUnix)
+        val endSpan = unixToSpan(endUnix)
+
+        // days when the a day/week/month starts/ends
+        val startDays = unixToDays(spanToUnix(startSpan))
+        val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next span
+        val dayCounter = DayCounter(startDays, endDays)
+
+        // print dates
+        barChart.xAxis.valueFormatter = object: ValueFormatter() {
+            override fun getFormattedValue(value: Float): String {
+                val index = value.toInt()
+                val unixSeconds = spanToUnix(startSpan + index)
+
+                val dateTime = Calendar.getInstance()
+                dateTime.time = Date(1000L * unixSeconds)
+                val year = dateTime.get(Calendar.YEAR)
+                val month = dateTime.get(Calendar.MONTH) + 1 // month starts at 0
+                val week = dateTime.get(Calendar.WEEK_OF_YEAR)
+                val day = dateTime.get(Calendar.DAY_OF_MONTH)
+
+                // Adjust years if the first week of a year starts in the previous year.
+                val years = if (month == 12 && week == 1) {
+                    year + 1
+                } else {
+                    year
+                }
+
+                val days = "%02d".format(day)
+                val weeks = "%02d".format(week)
+                val months = "%02d".format(month)
+
+                return when (timeRangeSelection) {
+                    TimeRange.DAY -> "$days/$months/$years"
+                    TimeRange.WEEK -> "$weeks/$years"
+                    TimeRange.MONTH -> "$months/$years"
+                }
+            }
+        }
+
+        val state = GraphState(events, dayCounter, startUnix, endUnix, startSpan, endSpan)
+
+        when (graphTypeSelection) {
+            GraphType.BOTTLE_EVENTS,
+            GraphType.BOTTLE_SUM -> showBottleBarGraph(state)
+            GraphType.SLEEP_EVENTS,
+            GraphType.SLEEP_SUM -> showSleepBarGraph(state)
+            GraphType.SLEEP_PATTERN -> if (timeRangeSelection == TimeRange.DAY) {
+                // specialized pattern bar for daily view (optional)
+                showSleepPatternBarGraphDaily(state)
+            } else {
+                showSleepPatternBarGraphSlotted(state)
+            }
+        }
+    }
+
+    private interface SpinnerItemSelected {
+        fun call(newValue: String?)
+    }
+
+    private fun setupSpinner(
+        currentValue: String,
+        spinnerId: Int,
+        arrayId: Int,
+        arrayValuesId: Int,
+        callback: SpinnerItemSelected
+    ) {
+        val arrayValues = resources.getStringArray(arrayValuesId)
+        val spinner = findViewById<Spinner>(spinnerId)
+        val spinnerAdapter =
+            ArrayAdapter.createFromResource(this, arrayId, R.layout.statistics_spinner_item)
+
+        spinner.adapter = spinnerAdapter
+        spinner.setSelection(arrayValues.indexOf(currentValue))
+        spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+            var check = 0
+            override fun onItemSelected(parent: AdapterView<*>?, view: View?, pos: Int, id: Long) {
+                if (pos >= arrayValues.size) {
+                    Toast.makeText(
+                        this@LongTermStatisticsActivity,
+                        "pos out of bounds: $arrayValues", Toast.LENGTH_SHORT
+                    ).show()
+                    return
+                }
+                if (check++ > 0) {
+                    callback.call(arrayValues[pos])
+                }
+            }
+
+            override fun onNothingSelected(parent: AdapterView<*>?) {
+                // ignore
+            }
+        }
+    }
+
+    companion object {
+        const val TAG = "LongTermStatisticsActivity"
+
+        // 15 min steps
+        const val SLEEP_PATTERN_GRANULARITY = 15 * 60
+
+        // Time between toast messages (to prevent jams)
+        const val TOAST_FREQUENCY_MS = 3500
+
+        // color gradient
+        val SLEEP_PATTERN_COLORS = arrayOf(
+            "#FFFFFF".toColorInt(), "#EEF5F7".toColorInt(), "#DDEBEF".toColorInt(), "#CCE2E7".toColorInt(),
+            "#BBD8DF".toColorInt(), "#AACED7".toColorInt(), "#99C4CF".toColorInt(), "#88BAC7".toColorInt(),
+            "#77B1BF".toColorInt(), "#66A7B7".toColorInt(), "#559DAF".toColorInt(), "#4493A7".toColorInt(),
+            "#33899F".toColorInt(), "#228097".toColorInt(), "#11768F".toColorInt(), "#006C87".toColorInt()
+        )
+
+        var graphTypeSelection = GraphType.SLEEP_SUM
+        var timeRangeSelection = TimeRange.DAY
+
+        private val dateTime = Calendar.getInstance() // scratch pad
+
+        // convert month to seconds since epoch
+        fun unixToMonths(seconds: Long): Int {
+            dateTime.time = Date(seconds * 1000)
+            val years = dateTime.get(Calendar.YEAR)
+            val months = dateTime.get(Calendar.MONTH)
+            return 12 * years + months
+        }
+
+        // convert month to seconds since epoch
+        fun monthsToUnix(months: Int): Long {
+            dateTime.time = Date(0)
+            dateTime.set(Calendar.YEAR, months / 12)
+            dateTime.set(Calendar.MONTH, months % 12)
+            dateTime.set(Calendar.HOUR, 0)
+            dateTime.set(Calendar.MINUTE, 0)
+            dateTime.set(Calendar.SECOND, 0)
+            return dateTime.time.time / 1000
+        }
+
+        // convert seconds to weeks since epoch
+        fun unixToWeeks(seconds: Long): Int {
+            dateTime.time = Date(seconds * 1000)
+            val years = dateTime.get(Calendar.YEAR) - 1970
+            val weeks = dateTime.get(Calendar.WEEK_OF_YEAR)
+            val month = dateTime.get(Calendar.MONTH) + 1 // month starts at 0
+
+            if (month == 12 && weeks == 1) {
+                // The first week if the year might start in the previous year.
+                return 52 * (years + 1) + weeks
+            }
+
+            return 52 * years + weeks
+        }
+
+        // convert weeks to seconds since epoch
+        fun weeksToUnix(weeks: Int): Long {
+            dateTime.time = Date(0)
+            dateTime.set(Calendar.YEAR, 1970 + weeks / 52)
+            dateTime.set(Calendar.WEEK_OF_YEAR, weeks % 52)
+            dateTime.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
+            dateTime.set(Calendar.HOUR, 0)
+            dateTime.set(Calendar.MINUTE, 0)
+            dateTime.set(Calendar.SECOND, 0)
+            return dateTime.time.time / 1000
+        }
+
+        // convert seconds to days since epoch
+        fun unixToDays(seconds: Long): Int {
+            dateTime.time = Date(seconds * 1000)
+            val years = dateTime.get(Calendar.YEAR)
+            val days = dateTime.get(Calendar.DAY_OF_YEAR)
+            return 365 * years + days
+        }
+
+        // convert days to seconds since epoch
+        fun daysToUnix(days: Int): Long {
+            dateTime.time = Date(0)
+            dateTime.set(Calendar.YEAR, days / 365)
+            dateTime.set(Calendar.DAY_OF_YEAR, days % 365)
+            dateTime.set(Calendar.HOUR, 0)
+            dateTime.set(Calendar.MINUTE, 0)
+            dateTime.set(Calendar.SECOND, 0)
+            return dateTime.time.time / 1000
+        }
+
+        fun appendToFloatArray(array: FloatArray, vararg values: Float): FloatArray {
+            // create new array
+            val newArray = FloatArray(array.size + values.size)
+            // copy old values
+            for (i in array.indices) {
+                newArray[i] = array[i]
+            }
+            // add new values
+            for (i in values.indices) {
+                newArray[array.size + i] = values[i]
+            }
+            return newArray
+        }
+
+        // for debugging
+        fun debugBarValues(values: ArrayList<BarEntry>) {
+            for (value in values) {
+                val yVals = value.yVals
+                if (yVals != null) {
+                    val y = yVals.fold(0F) { acc, next -> acc + next }
+                    val yVals = yVals.joinToString { it.toString() }
+                    Log.d(TAG, "value: ${value.x} $y ($yVals)")
+                } else {
+                    Log.d(TAG, "value: ${value.x} ${value.y}")
+                }
+            }
+        }
+    }
+}

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

@@ -15,6 +15,7 @@ import android.widget.AdapterView
 import android.widget.ArrayAdapter
 import android.widget.Button
 import android.widget.EditText
+import android.widget.LinearLayout
 import android.widget.NumberPicker
 import android.widget.PopupWindow
 import android.widget.Spinner
@@ -51,6 +52,9 @@ class MainActivity : AppCompatActivity() {
         const val TAG = "MainActivity"
         const val UPDATE_EVERY_SECS: Long = 30
         const val DEBUG_CHECK_LOGBOOK_CONSISTENCY = false
+        // list of all events
+        var allEvents = arrayListOf<LunaEvent>()
+        var currentPopupItems = listOf<LunaEvent.Type>()
     }
 
     var logbook: Logbook? = null
@@ -82,31 +86,13 @@ class MainActivity : AppCompatActivity() {
         recyclerView = findViewById(R.id.list_events)
         recyclerView.setLayoutManager(LinearLayoutManager(applicationContext))
 
+        populateHeaderMenu()
+
         // Set listeners
         findViewById<View>(R.id.logbooks_add_button).setOnClickListener {
             showAddLogbookDialog(true)
         }
-        findViewById<View>(R.id.button_bottle).setOnClickListener {
+
-            addBabyBottleEvent(LunaEvent(LunaEvent.TYPE_BABY_BOTTLE))
-        }
-        findViewById<View>(R.id.button_food).setOnClickListener {
-            addNoteEvent(LunaEvent(LunaEvent.TYPE_FOOD))
-        }
-        findViewById<View>(R.id.button_nipple_left).setOnClickListener {
-            addPlainEvent(LunaEvent(LunaEvent.TYPE_BREASTFEEDING_LEFT_NIPPLE))
-        }
-        findViewById<View>(R.id.button_nipple_both).setOnClickListener {
-            addPlainEvent(LunaEvent(LunaEvent.TYPE_BREASTFEEDING_BOTH_NIPPLE))
-        }
-        findViewById<View>(R.id.button_nipple_right).setOnClickListener {
-            addPlainEvent(LunaEvent(LunaEvent.TYPE_BREASTFEEDING_RIGHT_NIPPLE))
-        }
-        findViewById<View>(R.id.button_change_poo).setOnClickListener {
-            addAmountEvent(LunaEvent(LunaEvent.TYPE_DIAPERCHANGE_POO))
-        }
-        findViewById<View>(R.id.button_change_pee).setOnClickListener {
-            addAmountEvent(LunaEvent(LunaEvent.TYPE_DIAPERCHANGE_PEE))
-        }
         val moreButton = findViewById<View>(R.id.button_more)
         moreButton.setOnClickListener {
             showOverflowPopupWindow(moreButton)
@@ -122,9 +108,13 @@ class MainActivity : AppCompatActivity() {
             loadLogbookList()
         }
         findViewById<View>(R.id.button_sync).setOnClickListener {
+            if (logbook != null) {
+                loadLogbook(logbook!!.name)
+            } else {
                 loadLogbookList()
             }
         }
+    }
 
     private fun setListAdapter(items: ArrayList<LunaEvent>) {
         val adapter = LunaEventRecyclerAdapter(this, items)
@@ -146,7 +136,81 @@ class MainActivity : AppCompatActivity() {
         if (logbook == null)
             Log.w(TAG, "showLogbook(): logbook is null!")
 
-        setListAdapter(logbook?.logs ?: arrayListOf())
+        allEvents = logbook?.logs ?: arrayListOf()
+        setListAdapter(allEvents)
+
+        populateHeaderMenu()
+    }
+
+    private fun populateHeaderMenu() {
+        val settingsRepository = LocalSettingsRepository(this)
+        val dynamicMenu = settingsRepository.loadDynamicMenu()
+        val eventTypeStats = mutableMapOf<LunaEvent.Type, Int>()
+
+        if (dynamicMenu) {
+            // populate frequency map from all events of the last two weeks
+            val lastWeekTime = (System.currentTimeMillis() / 1000) - (14 * 24 * 60 * 60)
+            allEvents.forEach {
+                if (it.time > lastWeekTime) {
+                    eventTypeStats[it.type] = 1 + (eventTypeStats[it.type] ?: 0)
+                }
+            }
+        }
+
+        // sort all event types by frequency and ordinal
+        val eventTypesSorted = LunaEvent.Type.entries.toList().sortedWith(
+            compareBy({ -1 * (eventTypeStats[it] ?: 0) }, { it.ordinal })
+        ).filter { it != LunaEvent.Type.UNKNOWN }
+
+        val usedEventCount = eventTypeStats.count { it.value > 0 }
+        val maxButtonCount = if (dynamicMenu) { usedEventCount } else { 7 }
+
+        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(showCounter, eventTypesSorted.size)
     }
 
     override fun onStart() {
@@ -169,12 +233,6 @@ class MainActivity : AppCompatActivity() {
 
         signature = settingsRepository.loadSignature()
 
-        val noBreastfeeding = settingsRepository.loadNoBreastfeeding()
-        findViewById<View>(R.id.layout_nipples).visibility = when (noBreastfeeding) {
-            true -> View.GONE
-            false -> View.VISIBLE
-        }
-
         // Update list dates
         recyclerView.adapter?.notifyDataSetChanged()
 
@@ -193,10 +251,6 @@ class MainActivity : AppCompatActivity() {
         super.onStop()
     }
 
-    fun getAllEvents(): ArrayList<LunaEvent> {
-        return logbook?.logs ?: arrayListOf()
-    }
-
     fun addBabyBottleEvent(event: LunaEvent) {
         setToPreviousQuantity(event)
         askBabyBottleContent(event, true) {
@@ -207,19 +261,22 @@ class MainActivity : AppCompatActivity() {
     fun askBabyBottleContent(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_bottle, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
         val numberPicker = dialogView.findViewById<NumberPicker>(R.id.dialog_number_picker)
         numberPicker.minValue = 1 // "10"
-        numberPicker.maxValue = 25 // "250
+        numberPicker.maxValue = 34 // "340
-        numberPicker.displayedValues = ((10..250 step 10).map { it.toString() }.toTypedArray())
+        numberPicker.displayedValues = ((10..340 step 10).map { it.toString() }.toTypedArray())
         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 = datePickerHelper(event.time, dateTV)
+        val pickedTime = dateTimePicker(event.time, dateTV)
 
         if (!showTime) {
             dateTV.visibility = View.GONE
@@ -249,15 +306,18 @@ class MainActivity : AppCompatActivity() {
         // Show number picker dialog
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_weight, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
         val weightET = dialogView.findViewById<EditText>(R.id.dialog_number_edittext)
         weightET.setText(event.quantity.toString())
 
+        val unitTV = dialogView.findViewById<TextView>(R.id.dialog_number_unit)
+        unitTV.text = NumericUtils(this).measurement_unit_weight_base
+
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val pickedTime = datePickerHelper(event.time, dateTV)
+        val pickedTime = dateTimePicker(event.time, dateTV)
 
         if (!showTime) {
             dateTV.visibility = View.GONE
@@ -284,6 +344,53 @@ class MainActivity : AppCompatActivity() {
         alertDialog.show()
     }
 
+    fun addHeightEvent(event: LunaEvent) {
+        setToPreviousQuantity(event)
+        askHeightValue(event, true) { saveEvent(event) }
+    }
+
+    fun askHeightValue(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
+        // Show number picker dialog
+        val d = AlertDialog.Builder(this)
+        val dialogView = layoutInflater.inflate(R.layout.dialog_edit_height, null)
+        d.setTitle(event.getDialogTitle(this))
+        d.setMessage(event.getDialogMessage(this))
+        d.setView(dialogView)
+
+        val heightET = dialogView.findViewById<EditText>(R.id.dialog_number_edittext)
+        heightET.setText(event.quantity.toString())
+
+        val unitTV = dialogView.findViewById<TextView>(R.id.dialog_number_unit)
+        unitTV.text = NumericUtils(this).measurement_unit_height_base
+
+        val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
+        val pickedTime = dateTimePicker(event.time, dateTV)
+
+        if (!showTime) {
+            dateTV.visibility = View.GONE
+        }
+
+        d.setPositiveButton(android.R.string.ok) { dialogInterface, i ->
+            val height = heightET.text.toString().toIntOrNull()
+            if (height != null) {
+                event.time = pickedTime.time.time / 1000
+                event.quantity = height
+                onPositive()
+            } else {
+                Toast.makeText(this, R.string.toast_integer_error, Toast.LENGTH_SHORT).show()
+            }
+
+            dialogInterface.dismiss()
+        }
+
+        d.setNegativeButton(android.R.string.cancel) { dialogInterface, i ->
+            dialogInterface.dismiss()
+        }
+
+        val alertDialog = d.create()
+        alertDialog.show()
+    }
+
     fun addTemperatureEvent(event: LunaEvent) {
         setToPreviousQuantity(event)
         askTemperatureValue(event, true) { saveEvent(event) }
@@ -293,12 +400,12 @@ class MainActivity : AppCompatActivity() {
         // Show number picker dialog
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_temperature, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
         val tempSlider = dialogView.findViewById<Slider>(R.id.dialog_temperature_value)
-        val range = NumericUtils(this).getValidEventQuantityRange(LunaEvent.TYPE_TEMPERATURE)!!
+        val range = NumericUtils(this).getValidEventQuantityRange(LunaEvent.Type.TEMPERATURE)!!
         tempSlider.valueFrom = range.first.toFloat()
         tempSlider.valueTo = range.second.toFloat()
         tempSlider.value = if (event.quantity == 0) {
@@ -308,7 +415,7 @@ class MainActivity : AppCompatActivity() {
         }
 
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val pickedTime = datePickerHelper(event.time, dateTV)
+        val pickedTime = dateTimePicker(event.time, dateTV)
         if (!showTime) {
             dateTV.visibility = View.GONE
         }
@@ -332,7 +439,8 @@ class MainActivity : AppCompatActivity() {
         alertDialog.show()
     }
 
-    fun datePickerHelper(time: Long, dateTextView: TextView, onChange: (Long) -> Unit = {}): Calendar {
+    // Pick a date/time.
+    fun dateTimePicker(time: Long, dateTextView: TextView, onChange: (Long) -> Unit = {}): Calendar {
         dateTextView.text = DateUtils.formatDateTime(time)
 
         val dateTime = Calendar.getInstance()
@@ -363,89 +471,110 @@ class MainActivity : AppCompatActivity() {
         return dateTime
     }
 
-    fun saveEvent(event: LunaEvent) {
+    fun addDurationEvent(event: LunaEvent) {
-        if (!getAllEvents().contains(event)) {
+        askDurationEvent(event, true) { saveEvent(event) }
-            // new event
-            logEvent(event)
     }
 
-        logbook?.sort()
+    fun askDurationEvent(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
-        recyclerView.adapter?.notifyDataSetChanged()
-        saveLogbook()
-    }
-
-    fun addSleepEvent(event: LunaEvent) {
-        askSleepValue(event) { saveEvent(event) }
-    }
-
-    fun askSleepValue(event: LunaEvent, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_duration, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
-        d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
-        val durationTextView = dialogView.findViewById<TextView>(R.id.dialog_date_duration)
+        val durationTV = dialogView.findViewById<TextView>(R.id.dialog_date_duration)
+        val datePickerBeginTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker_begin)
+        val datePickerEndTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker_end)
+        val dateDelimiterTV = 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 datePicker = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
+        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 currentDurationTextColor = durationTV.currentTextColor
         val invalidDurationTextColor = ContextCompat.getColor(this, R.color.danger)
 
-        var duration = event.quantity
+        // in seconds
+        var durationStart = event.getStartTime()
+        var durationEnd = event.getEndTime()
 
-        fun isValidTime(timeSeconds: Long, durationSeconds: Int): Boolean {
+        fun isValidTime(timeUnix: Long): Boolean {
-            val now = Calendar.getInstance().time.time / 1000
+            val now = System.currentTimeMillis() / 1000
-            return (timeSeconds + durationSeconds) <= now && durationSeconds < (12 * 60 * 60)
+            return timeUnix in 1..now
         }
 
-        val onDateChange = { time: Long ->
+        fun isValidTimeSpan(timeBeginUnix: Long, timeEndUnix: Long): Boolean {
-            durationTextView.setTextColor(currentDurationTextColor)
+            return (timeBeginUnix <= timeEndUnix) && (timeEndUnix - timeBeginUnix) < (24 * 60 * 60)
+        }
 
-            if (duration == 0) {
+        fun updateFields() {
-                // baby is sleeping
+            datePickerBeginTV.text = DateUtils.formatDateTime(durationStart)
-                durationTextView.text = "💤"
+            datePickerEndTV.text = DateUtils.formatDateTime(durationEnd)
+
+            dateTimePicker(durationStart, datePickerBeginTV) { pickedTime: Long ->
+                durationStart = pickedTime
+                if (datePickerEndTV.visibility == View.GONE) {
+                    durationEnd = pickedTime
+                }
+                updateFields()
+            }
+
+            dateTimePicker(durationEnd, datePickerEndTV) { pickedTime: Long ->
+                durationEnd = pickedTime
+                updateFields()
+            }
+
+            durationTV.setTextColor(currentDurationTextColor)
+            val duration = durationEnd - durationStart
+            if (duration == 0L) {
+                // event is ongoing
+                durationTV.text = "💤"
+                dateDelimiterTV.visibility = View.GONE
+                datePickerEndTV.visibility = View.GONE
             } else {
-                durationTextView.text = DateUtils.formatTimeDuration(applicationContext, duration.toLong())
+                durationTV.text = DateUtils.formatTimeDuration(applicationContext, duration)
-                if (!isValidTime(time, duration)) {
+                if (!isValidTimeSpan(durationStart, durationEnd)) {
-                    durationTextView.setTextColor(invalidDurationTextColor)
+                    durationTV.setTextColor(invalidDurationTextColor)
-                }
                 }
+                dateDelimiterTV.visibility = View.VISIBLE
+                datePickerEndTV.visibility = View.VISIBLE
             }
 
-        val pickedDateTime = datePickerHelper(event.time, datePicker, onDateChange)
+            val colorBegin = if (isValidTime(durationStart)) { currentDurationTextColor } else { invalidDurationTextColor }
+            datePickerBeginTV.setTextColor(colorBegin)
 
-        onDateChange(pickedDateTime.time.time / 1000)
+            val colorEnd = if (isValidTime(durationEnd)) { currentDurationTextColor } else { invalidDurationTextColor }
-
+            datePickerEndTV.setTextColor(colorEnd)
-        fun adjust(minutes: Int) {
-            duration += minutes * 60
-            if (duration < 0) {
-                duration = 0
-            }
-            onDateChange(pickedDateTime.time.time / 1000)
         }
 
-        durationMinus5Button.setOnClickListener { adjust(-5) }
+        if (showTime) {
-        durationPlus5Button.setOnClickListener { adjust(5) }
+            dateDelimiterTV.visibility = View.GONE
+            datePickerEndTV.visibility = View.GONE
+            durationTV.visibility = View.GONE
+            durationButtons.visibility = View.GONE
+            //d.setMessage("")
+        } else {
+            dateDelimiterTV.visibility = View.VISIBLE
+            datePickerEndTV.visibility = View.VISIBLE
+            durationTV.visibility = View.VISIBLE
+            durationButtons.visibility = View.VISIBLE
+            d.setMessage(event.getDialogMessage(this))
+        }
+
+        updateFields()
+
+        durationClearButton.setOnClickListener {
+            durationEnd = durationStart
+            updateFields()
+        }
 
         durationNowButton.setOnClickListener {
-            val now = Calendar.getInstance().time.time / 1000
+            durationEnd = System.currentTimeMillis() / 1000
-            val start = pickedDateTime.time.time / 1000
+            updateFields()
-            if (now > start) {
-                duration = (now - start).toInt()
-                duration -= duration % 60 // prevent printing of seconds
-                onDateChange(pickedDateTime.time.time / 1000)
-            }
         }
 
         d.setPositiveButton(android.R.string.ok) { dialogInterface, i ->
-            val time = pickedDateTime.time.time / 1000
+            if (isValidTime(durationStart) && isValidTime(durationEnd) && isValidTimeSpan(durationStart, durationEnd)) {
-
+                event.time = durationStart
-            if (isValidTime(time, duration)) {
+                event.quantity = (durationEnd - durationStart).toInt()
-                event.time = time
-                event.quantity = duration
                 onPositive()
             } else {
                 Toast.makeText(this, R.string.toast_date_error, Toast.LENGTH_SHORT).show()
@@ -462,13 +591,14 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun addAmountEvent(event: LunaEvent) {
+        setToPreviousQuantity(event)
         askAmountValue(event, true) { saveEvent(event) }
     }
 
     fun askAmountValue(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_amount, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
@@ -478,11 +608,11 @@ class MainActivity : AppCompatActivity() {
             R.array.AmountLabels,
             android.R.layout.simple_spinner_dropdown_item
         )
-        // set pre-selected item and ensure the quantity to index is in bounds
+
         spinner.setSelection(event.quantity.coerceIn(0, spinner.count - 1))
 
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val pickedTime = datePickerHelper(event.time, dateTV)
+        val pickedTime = dateTimePicker(event.time, dateTV)
         if (!showTime) {
             dateTV.visibility = View.GONE
         }
@@ -510,12 +640,12 @@ class MainActivity : AppCompatActivity() {
     fun askDateValue(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_plain, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
 
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val pickedDateTime = datePickerHelper(event.time, dateTV)
+        val pickedDateTime = dateTimePicker(event.time, dateTV)
         if (!showTime) {
             dateTV.visibility = View.GONE
         }
@@ -539,18 +669,18 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun askNotes(event: LunaEvent, showTime: Boolean, onPositive: () -> Unit) {
-        val useQuantity = (event.type != LunaEvent.TYPE_NOTE && event.type != LunaEvent.TYPE_CUSTOM)
+        val useQuantity = (event.type != LunaEvent.Type.NOTE)
 
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_notes, null)
-        d.setTitle(event.getTypeDescription(this))
+        d.setTitle(event.getDialogTitle(this))
         d.setMessage(event.getDialogMessage(this))
         d.setView(dialogView)
         val notesET = dialogView.findViewById<EditText>(R.id.notes_edittext)
         val qtyET = dialogView.findViewById<EditText>(R.id.notes_qty_edittext)
 
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val pickedTime = datePickerHelper(event.time, dateTV)
+        val pickedTime = dateTimePicker(event.time, dateTV)
 
         if (!showTime) {
             dateTV.visibility = View.GONE
@@ -558,16 +688,13 @@ class MainActivity : AppCompatActivity() {
 
         val nextTextView = dialogView.findViewById<TextView>(R.id.notes_template_next)
         val prevTextView = dialogView.findViewById<TextView>(R.id.notes_template_prev)
-        val templates = getAllEvents().filter { it.type == event.type }.distinctBy { it.notes.trim() }.sortedBy { it.time }
+        val templates = allEvents.filter { it.type == event.type }.distinctBy { it.notes }.sortedBy { it.time }
 
         fun updateContent(current: LunaEvent) {
             val prevEvent = getPreviousSameEvent(current, templates)
             var nextEvent = getNextSameEvent(current, templates)
 
             notesET.setText(current.notes)
-            if (useQuantity) {
-                qtyET.setText(current.quantity.toString())
-            }
 
             if (nextEvent == null && current != event) {
                 nextEvent = event
@@ -576,9 +703,6 @@ class MainActivity : AppCompatActivity() {
             if (nextEvent != null) {
                 nextTextView.setOnClickListener {
                     notesET.setText(nextEvent.notes)
-                    if (useQuantity) {
-                        qtyET.setText(nextEvent.quantity.toString())
-                    }
                     updateContent(nextEvent)
                 }
                 nextTextView.alpha = 1.0f
@@ -590,9 +714,6 @@ class MainActivity : AppCompatActivity() {
             if (prevEvent != null) {
                 prevTextView.setOnClickListener {
                     notesET.setText(prevEvent.notes)
-                    if (useQuantity) {
-                        qtyET.setText(prevEvent.quantity.toString())
-                    }
                     updateContent(prevEvent)
                 }
                 prevTextView.alpha = 1.0f
@@ -613,7 +734,7 @@ class MainActivity : AppCompatActivity() {
         updateContent(event)
 
         d.setPositiveButton(android.R.string.ok) { dialogInterface, i ->
-            val notes = notesET.text.toString()
+            val notes = notesET.text.toString().trim()
 
             if (useQuantity) {
                 val quantity = qtyET.text.toString().toIntOrNull()
@@ -664,7 +785,7 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun setToPreviousQuantity(event: LunaEvent) {
-        val prev = getPreviousSameEvent(event, getAllEvents())
+        val prev = getPreviousSameEvent(event, allEvents)
         if (prev != null) {
             event.quantity = prev.quantity
         }
@@ -721,8 +842,8 @@ class MainActivity : AppCompatActivity() {
         val quantityTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_quantity)
         val notesTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_notes)
 
-        emojiTextView.text = event.getTypeEmoji(this)
+        emojiTextView.text = event.getHeaderEmoji(this)
-        descriptionTextView.text = event.getTypeDescription(this)
+        descriptionTextView.text = event.getDialogTitle(this)
 
         d.setView(dialogView)
 
@@ -761,8 +882,8 @@ class MainActivity : AppCompatActivity() {
         val updateValues = {
             quantityTextView.text = NumericUtils(this).formatEventQuantity(event)
             notesTextView.text = event.notes
-            if (event.type == LunaEvent.TYPE_SLEEP && event.quantity > 0) {
+            if (event.type == LunaEvent.Type.SLEEP && event.quantity > 0) {
-                dateEndTextView.text = DateUtils.formatDateTime(event.time + event.quantity)
+                dateEndTextView.text = DateUtils.formatDateTime(event.getEndTime())
                 dateEndTextView.visibility = View.VISIBLE
             } else {
                 dateEndTextView.visibility = View.GONE
@@ -776,29 +897,38 @@ class MainActivity : AppCompatActivity() {
         }
         updateValues()
 
-        datePickerHelper(event.time, dateTextView, { newTime: Long ->
+        dateTimePicker(event.time, dateTextView, { newTime: Long ->
             event.time = newTime
             updateValues()
         })
 
         quantityTextView.setOnClickListener {
             when (event.type) {
-                LunaEvent.TYPE_BABY_BOTTLE -> askBabyBottleContent(event, false, updateValues)
+                LunaEvent.Type.BABY_BOTTLE -> askBabyBottleContent(event, false, updateValues)
-                LunaEvent.TYPE_WEIGHT -> askWeightValue(event, false, updateValues)
+                LunaEvent.Type.WEIGHT -> askWeightValue(event, false, updateValues)
-                LunaEvent.TYPE_DIAPERCHANGE_POO,
+                LunaEvent.Type.HEIGHT -> askHeightValue(event, false, updateValues)
-                LunaEvent.TYPE_DIAPERCHANGE_PEE,
+                LunaEvent.Type.DIAPERCHANGE_POO,
-                LunaEvent.TYPE_PUKE -> askAmountValue(event, false, updateValues)
+                LunaEvent.Type.DIAPERCHANGE_PEE,
-                LunaEvent.TYPE_TEMPERATURE -> askTemperatureValue(event, false, updateValues)
+                LunaEvent.Type.PUKE -> askAmountValue(event, false, updateValues)
-                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
+                LunaEvent.Type.TEMPERATURE -> askTemperatureValue(event, false, updateValues)
-                LunaEvent.TYPE_SLEEP -> askSleepValue(event, updateValues)
+                LunaEvent.Type.FOOD,
+                LunaEvent.Type.MEDICINE,
+                LunaEvent.Type.NOTE -> askNotes(event, false, updateValues)
+                LunaEvent.Type.SLEEP -> askDurationEvent(event, false, updateValues)
+                else -> {
+                    Log.w(TAG, "Unexpected type: ${event.type}")
+                }
             }
         }
 
         notesTextView.setOnClickListener {
             when (event.type) {
-                LunaEvent.TYPE_FOOD,
+                LunaEvent.Type.FOOD,
-                LunaEvent.TYPE_MEDICINE,
+                LunaEvent.Type.MEDICINE,
-                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
+                LunaEvent.Type.NOTE -> askNotes(event, false, updateValues)
+                else -> {
+                    Log.w(TAG, "Unexpected type: ${event.type}")
+                }
             }
         }
 
@@ -809,14 +939,12 @@ class MainActivity : AppCompatActivity() {
             signatureTextEdit.visibility = View.VISIBLE
         }
 
-        val allEvents = getAllEvents()
-
         // create link to prevent event of the same type
         val previousTextView = dialogView.findViewById<TextView>(R.id.dialog_event_previous)
         val previousEvent = getPreviousSameEvent(event, allEvents)
         if (previousEvent != null) {
-            val emoji = previousEvent.getTypeEmoji(applicationContext)
+            val emoji = previousEvent.getHeaderEmoji(applicationContext)
-            val time = DateUtils.formatTimeDuration(applicationContext, event.time - previousEvent.time)
+            val time = DateUtils.formatTimeDuration(applicationContext, event.getStartTime() - previousEvent.getEndTime())
             previousTextView.text = String.format("⬅️ %s %s", emoji, time)
             previousTextView.setOnClickListener {
                 alertDialog.cancel()
@@ -830,8 +958,8 @@ class MainActivity : AppCompatActivity() {
         val nextTextView = dialogView.findViewById<TextView>(R.id.dialog_event_next)
         val nextEvent = getNextSameEvent(event, allEvents)
         if (nextEvent != null) {
-            val emoji = nextEvent.getTypeEmoji(applicationContext)
+            val emoji = nextEvent.getHeaderEmoji(applicationContext)
-            val time = DateUtils.formatTimeDuration(applicationContext, nextEvent.time - event.time)
+            val time = DateUtils.formatTimeDuration(applicationContext, nextEvent.getStartTime() - event.getEndTime())
             nextTextView.text = String.format("%s %s ➡️", time, emoji)
             nextTextView.setOnClickListener {
                 alertDialog.cancel()
@@ -1001,7 +1129,7 @@ class MainActivity : AppCompatActivity() {
 
                     if (DEBUG_CHECK_LOGBOOK_CONSISTENCY) {
                         for (e in logbook?.logs ?: listOf()) {
-                            val em = e.getTypeEmoji(this@MainActivity)
+                            val em = e.getHeaderEmoji(this@MainActivity)
                             if (em == getString(R.string.event_unknown_type)) {
                                 Log.e(TAG, "UNKNOWN: ${e.type}")
                             }
@@ -1056,23 +1184,6 @@ class MainActivity : AppCompatActivity() {
         })
     }
 
-    fun logEvent(event: LunaEvent) {
-        savingEvent(true)
-
-        event.signature = signature
-
-        setLoading(true)
-        logbook?.logs?.add(0, event)
-        recyclerView.adapter?.notifyItemInserted(0)
-        recyclerView.smoothScrollToPosition(0)
-        saveLogbook(event)
-
-        // Check logbook size to avoid OOM errors
-        if (logbook?.isTooBig() == true) {
-            askToTrimLogbook()
-        }
-    }
-
     fun deleteEvent(event: LunaEvent) {
         // Update view
         savingEvent(true)
@@ -1084,6 +1195,32 @@ class MainActivity : AppCompatActivity() {
         saveLogbook()
     }
 
+    fun saveEvent(event: LunaEvent) {
+        if (allEvents.contains(event)) {
+            // event was modified
+            logbook?.sort()
+            recyclerView.adapter?.notifyDataSetChanged()
+            saveLogbook()
+        } else {
+            // add new event
+            savingEvent(true)
+            setLoading(true)
+            if (signature.isNotEmpty()) {
+                event.signature = signature
+            }
+            logbook?.logs?.add(0, event)
+            logbook?.sort()
+            recyclerView.adapter?.notifyDataSetChanged()
+            recyclerView.smoothScrollToPosition(0)
+            saveLogbook(event)
+
+            // Check logbook size to avoid OOM errors
+            if (logbook?.isTooBig() == true) {
+                askToTrimLogbook()
+            }
+        }
+    }
+
     /**
      * Saves the logbook. If saving while adding an event, please specify the event so in case
      * of error can be removed from the list.
@@ -1186,6 +1323,30 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    private fun showCreateDialog(type: LunaEvent.Type) {
+        val event = LunaEvent(type)
+        when (type) {
+            LunaEvent.Type.BABY_BOTTLE -> addBabyBottleEvent(event)
+            LunaEvent.Type.WEIGHT -> addWeightEvent(event)
+            LunaEvent.Type.HEIGHT -> addHeightEvent(event)
+            LunaEvent.Type.BREASTFEEDING_LEFT_NIPPLE -> addPlainEvent(event)
+            LunaEvent.Type.BREASTFEEDING_BOTH_NIPPLE -> addPlainEvent(event)
+            LunaEvent.Type.BREASTFEEDING_RIGHT_NIPPLE -> addPlainEvent(event)
+            LunaEvent.Type.DIAPERCHANGE_POO -> addAmountEvent(event)
+            LunaEvent.Type.DIAPERCHANGE_PEE -> addAmountEvent(event)
+            LunaEvent.Type.MEDICINE -> addNoteEvent(event)
+            LunaEvent.Type.ENEMA -> addNoteEvent(event)
+            LunaEvent.Type.NOTE -> addNoteEvent(event)
+            LunaEvent.Type.COLIC -> addPlainEvent(event)
+            LunaEvent.Type.TEMPERATURE -> addTemperatureEvent(event)
+            LunaEvent.Type.FOOD -> addNoteEvent(event)
+            LunaEvent.Type.PUKE -> addAmountEvent(event)
+            LunaEvent.Type.BATH -> addPlainEvent(event)
+            LunaEvent.Type.SLEEP -> addDurationEvent(event)
+            LunaEvent.Type.UNKNOWN -> {} // ignore
+        }
+    }
+
     private fun showOverflowPopupWindow(anchor: View) {
         if (showingOverflowPopupWindow)
             return
@@ -1194,45 +1355,11 @@ class MainActivity : AppCompatActivity() {
             isOutsideTouchable = true
             val inflater = LayoutInflater.from(anchor.context)
             contentView = inflater.inflate(R.layout.more_events_popup, null)
-            contentView.findViewById<View>(R.id.button_medicine).setOnClickListener {
+
-                addNoteEvent(LunaEvent(LunaEvent.TYPE_MEDICINE))
+            // Add statistics (hard coded)
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_enema).setOnClickListener {
-                addPlainEvent(LunaEvent(LunaEvent.TYPE_ENEMA))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_note).setOnClickListener {
-                addNoteEvent(LunaEvent(LunaEvent.TYPE_NOTE))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_temperature).setOnClickListener {
-                addTemperatureEvent(LunaEvent(LunaEvent.TYPE_TEMPERATURE))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_puke).setOnClickListener {
-                addAmountEvent(LunaEvent(LunaEvent.TYPE_PUKE))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_sleep).setOnClickListener {
-                addSleepEvent(LunaEvent(LunaEvent.TYPE_SLEEP))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_colic).setOnClickListener {
-                addPlainEvent(LunaEvent(LunaEvent.TYPE_COLIC))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_scale).setOnClickListener {
-                addWeightEvent(LunaEvent(LunaEvent.TYPE_WEIGHT))
-                dismiss()
-            }
-            contentView.findViewById<View>(R.id.button_bath).setOnClickListener {
-                addPlainEvent(LunaEvent(LunaEvent.TYPE_BATH))
-                dismiss()
-            }
             contentView.findViewById<View>(R.id.button_statistics).setOnClickListener {
                 if (logbook != null && !pauseLogbookUpdate) {
-                    val i = Intent(applicationContext, StatisticsActivity::class.java)
+                    val i = Intent(applicationContext, LongTermStatisticsActivity::class.java)
                     i.putExtra("LOOGBOOK_NAME", logbook!!.name)
                     startActivity(i)
                 } else {
@@ -1240,6 +1367,20 @@ class MainActivity : AppCompatActivity() {
                 }
                 dismiss()
             }
+
+            val linearLayout = contentView.findViewById<LinearLayout>(R.id.layout_list)
+
+            // Add buttons to create other events
+            for (type in currentPopupItems) {
+                val view = layoutInflater.inflate(R.layout.more_events_popup_item, linearLayout, false)
+                val textView = view.findViewById<TextView>(R.id.tv)
+                textView.text = LunaEvent.getPopupItemTitle(applicationContext, type)
+                textView.setOnClickListener {
+                    showCreateDialog(type)
+                    dismiss()
+                }
+                linearLayout.addView(textView)
+            }
         }.also { popupWindow ->
             popupWindow.setOnDismissListener({
                 Handler(mainLooper).postDelayed({

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

@@ -4,6 +4,7 @@ import android.os.Bundle
 import android.view.View
 import android.widget.EditText
 import android.widget.RadioButton
+import android.widget.Spinner
 import android.widget.TextView
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
@@ -24,7 +25,7 @@ open class SettingsActivity : AppCompatActivity() {
     protected lateinit var textViewWebDAVUser: TextView
     protected lateinit var textViewWebDAVPass: TextView
     protected lateinit var progressIndicator: LinearProgressIndicator
-    protected lateinit var switchNoBreastfeeding: SwitchMaterial
+    protected lateinit var switchDynamicMenu: SwitchMaterial
     protected lateinit var textViewSignature: EditText
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -37,7 +38,7 @@ open class SettingsActivity : AppCompatActivity() {
         textViewWebDAVUser = findViewById(R.id.settings_data_webdav_user)
         textViewWebDAVPass = findViewById(R.id.settings_data_webdav_pass)
         progressIndicator = findViewById(R.id.progress_indicator)
-        switchNoBreastfeeding = findViewById(R.id.switch_no_breastfeeding)
+        switchDynamicMenu = findViewById(R.id.switch_dynamic_menu)
         textViewSignature = findViewById(R.id.settings_signature)
 
         findViewById<View>(R.id.settings_save).setOnClickListener({
@@ -54,7 +55,7 @@ open class SettingsActivity : AppCompatActivity() {
     fun loadSettings() {
         val dataRepo = settingsRepository.loadDataRepository()
         val webDavCredentials = settingsRepository.loadWebdavCredentials()
-        val noBreastfeeding = settingsRepository.loadNoBreastfeeding()
+        val dynamicMenu = settingsRepository.loadDynamicMenu()
         val signature = settingsRepository.loadSignature()
 
         when (dataRepo) {
@@ -63,7 +64,7 @@ open class SettingsActivity : AppCompatActivity() {
         }
 
         textViewSignature.setText(signature)
-        switchNoBreastfeeding.isChecked = noBreastfeeding
+        switchDynamicMenu.isChecked = dynamicMenu
 
         if (webDavCredentials != null) {
             textViewWebDAVUrl.text = webDavCredentials[0]
@@ -160,7 +161,7 @@ open class SettingsActivity : AppCompatActivity() {
             if (radioDataWebDAV.isChecked) LocalSettingsRepository.DATA_REPO.WEBDAV
             else LocalSettingsRepository.DATA_REPO.LOCAL_FILE
         )
-        settingsRepository.saveNoBreastfeeding(switchNoBreastfeeding.isChecked)
+        settingsRepository.saveDynamicMenu(switchDynamicMenu.isChecked)
         settingsRepository.saveSignature(textViewSignature.text.toString())
         settingsRepository.saveWebdavCredentials(
             textViewWebDAVUrl.text.toString(),

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

@@ -1,885 +0,0 @@
-package it.danieleverducci.lunatracker
-
-import android.graphics.Color
-import android.os.Bundle
-import android.util.Log
-import android.view.View
-import android.widget.AdapterView
-import android.widget.ArrayAdapter
-import android.widget.Spinner
-import android.widget.TextView
-import android.widget.Toast
-import androidx.appcompat.app.AppCompatActivity
-import com.github.mikephil.charting.charts.BarChart
-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.formatter.ValueFormatter
-import com.github.mikephil.charting.interfaces.datasets.IBarDataSet
-import com.thegrizzlylabs.sardineandroid.impl.SardineException
-import it.danieleverducci.lunatracker.MainActivity.Companion.TAG
-import it.danieleverducci.lunatracker.entities.Logbook
-import it.danieleverducci.lunatracker.entities.LunaEvent
-import it.danieleverducci.lunatracker.repository.FileLogbookRepository
-import it.danieleverducci.lunatracker.repository.LocalSettingsRepository
-import it.danieleverducci.lunatracker.repository.LogbookListObtainedListener
-import it.danieleverducci.lunatracker.repository.LogbookLoadedListener
-import it.danieleverducci.lunatracker.repository.LogbookRepository
-import it.danieleverducci.lunatracker.repository.WebDAVLogbookRepository
-import okio.IOException
-import org.json.JSONException
-import utils.DateUtils.Companion.formatTimeDuration
-import utils.NumericUtils
-import java.util.Calendar
-import java.util.Date
-import kotlin.math.max
-import kotlin.math.min
-
-abstract class LogbookBase: AppCompatActivity() {
-    var logbook: Logbook? = null
-    var logbookName: String? = null
-    lateinit var logbookRepo: LogbookRepository
-
-    fun initLogbookBase() {
-        Log.d(TAG, "LogbookBase init")
-        val settingsRepository = LocalSettingsRepository(this)
-        if (settingsRepository.loadDataRepository() == LocalSettingsRepository.DATA_REPO.WEBDAV) {
-            val webDavCredentials = settingsRepository.loadWebdavCredentials()
-            if (webDavCredentials == null) {
-                throw IllegalStateException("Corrupted local settings: repo is webdav, but no webdav login data saved")
-            }
-            logbookRepo = WebDAVLogbookRepository(
-                webDavCredentials[0],
-                webDavCredentials[1],
-                webDavCredentials[2]
-            )
-        } else {
-            logbookRepo = FileLogbookRepository()
-        }
-
-        if (logbook != null) {
-            // Already running: reload data for currently selected logbook
-            loadLogbook(logbook!!.name)
-        } else {
-            // First start: load logbook list
-            loadLogbookList()
-        }
-    }
-
-    abstract fun onLogbookReady()
-
-    fun loadLogbook(name: String) {
-        //if (savingEvent)
-        //    return
-
-        // Reset time counter
-        //handler.removeCallbacks(updateListRunnable)
-        //handler.postDelayed(updateListRunnable, UPDATE_EVERY_SECS*1000)
-
-        // Load data
-        //setLoading(true)
-        logbookRepo?.loadLogbook(this, name, object: LogbookLoadedListener{
-            override fun onLogbookLoaded(lb: Logbook) {
-                runOnUiThread({
-                    Log.d("StatisticsActivity", "logbook loaded!")
-                    //setLoading(false)
-                    //findViewById<View>(R.id.no_connection_screen).visibility = View.GONE
-                    logbook = lb
-
-                    //val events = logbook?.logs ?: arrayListOf()
-                    onLogbookReady()//updateGraph() //events) // showLogbook()
-/*
-                    if (DEBUG_CHECK_LOGBOOK_CONSISTENCY) {
-                        for (e in logbook?.logs ?: listOf()) {
-                            val em = e.getTypeEmoji(this@MainActivity)
-                            if (em == getString(R.string.event_unknown_type)) {
-                                Log.e(TAG, "UNKNOWN: ${e.type}")
-                            }
-                        }
-                    }
- */
-                })
-            }
-
-            override fun onIOError(error: IOException) {
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(getString(R.string.settings_network_error) + error.toString())
-                })
-            }
-
-            override fun onWebDAVError(error: SardineException) {
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(
-                        if(error.toString().contains("401")) {
-                            getString(R.string.settings_webdav_error_denied)
-                        } else if(error.toString().contains("503")) {
-                            getString(R.string.settings_webdav_error_server_offline)
-                        } else {
-                            getString(R.string.settings_webdav_error_generic) + error.toString()
-                        }
-                    )
-                })
-            }
-
-            override fun onJSONError(error: JSONException) {
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(getString(R.string.settings_json_error) + error.toString())
-                })
-            }
-
-            override fun onError(error: Exception) {
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(getString(R.string.settings_generic_error) + error.toString())
-                })
-            }
-        })
-    }
-
-    fun loadLogbookList() {
-        //setLoading(true)
-        logbookRepo?.listLogbooks(this, object: LogbookListObtainedListener {
-            override fun onLogbookListObtained(logbooksNames: ArrayList<String>) {
-                if (logbooksNames.isNotEmpty()) {
-                    loadLogbook(logbooksNames[0])
-                }
-                /*
-                runOnUiThread({
-                    if (logbooksNames.isEmpty()) {
-                        // First run, no logbook: create one
-                        //showAddLogbookDialog(false)
-                        return@runOnUiThread
-                    }
-                    // Show logbooks dropdown
-                    val spinner = findViewById<Spinner>(R.id.logbooks_spinner)
-                    val sAdapter = ArrayAdapter<String>(this@StatisticsActivity, android.R.layout.simple_spinner_item)
-                    sAdapter.setDropDownViewResource(R.layout.row_logbook_spinner)
-                    for (ln in logbooksNames) {
-                        sAdapter.add(
-                            ln.ifEmpty { getString(R.string.default_logbook_name) }
-                        )
-                    }
-                    spinner.adapter = sAdapter
-                    spinner.onItemSelectedListener = object: AdapterView.OnItemSelectedListener {
-                        override fun onItemSelected(
-                            parent: AdapterView<*>?,
-                            view: View?,
-                            position: Int,
-                            id: Long
-                        ) {
-                            // Changed logbook: empty list
-                            setListAdapter(arrayListOf())
-                            // Load logbook
-                            loadLogbook(logbooksNames.get(position))
-                        }
-
-                        override fun onNothingSelected(parent: AdapterView<*>?) {}
-                    }
-                })
-                */
-            }
-
-            override fun onIOError(error: IOException) {
-                Log.e(TAG, "Unable to load logbooks list (IOError): $error")
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(getString(R.string.settings_network_error) + error.toString())
-                })
-            }
-
-            override fun onWebDAVError(error: SardineException) {
-                Log.e(TAG, "Unable to load logbooks list (SardineException): $error")
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(
-                        if(error.toString().contains("401")) {
-                            getString(R.string.settings_webdav_error_denied)
-                        } else if(error.toString().contains("503")) {
-                            getString(R.string.settings_webdav_error_server_offline)
-                        } else {
-                            getString(R.string.settings_webdav_error_generic) + error.toString()
-                        }
-                    )
-                })
-            }
-
-            override fun onError(error: Exception) {
-                Log.e(TAG, "Unable to load logbooks list: $error")
-                runOnUiThread({
-                    //setLoading(false)
-                    onRepoError(getString(R.string.settings_generic_error) + error.toString())
-                })
-            }
-        })
-    }
-
-    fun onRepoError(message: String) {
-        runOnUiThread({
-            //setLoading(false)
-            //findViewById<View>(R.id.no_connection_screen).visibility = View.VISIBLE
-            //findViewById<TextView>(R.id.no_connection_screen_message).text = message
-            Toast.makeText(this, message, Toast.LENGTH_LONG).show()
-        })
-    }
-
-    fun getAllEvents(): ArrayList<LunaEvent> {
-        return logbook?.logs ?: arrayListOf()
-    }
-}
-
-open class StatisticsActivity : LogbookBase() {
-    lateinit var barChart: BarChart
-    lateinit var noDataTextView: TextView
-    lateinit var eventTypeSelection: Spinner
-    lateinit var dataTypeSelection: Spinner
-    lateinit var timeRangeSelection: Spinner
-
-    var eventTypeSelectionValue = "BOTTLE"
-    var dataTypeSelectionValue = "AMOUNT"
-    var timeRangeSelectionValue = "DAY"
-
-    override fun onLogbookReady() {
-        updateGraph()
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        setContentView(R.layout.activity_statistics)
-
-        logbookName = intent.getStringExtra("LOOGBOOK_NAME")
-        if (logbookName == null) {
-            finish()
-            return
-        }
-
-        noDataTextView = findViewById(R.id.no_data)
-
-        barChart = findViewById(R.id.bar_chart)
-        barChart.setBackgroundColor(Color.WHITE)
-        barChart.description.text = "$logbookName"
-        //barChart.description.isEnabled = false
-        barChart.axisLeft.setAxisMinimum(0F)
-
-        /*
-                barChart.setFitBars(true)
-                barChart.setMaxVisibleValueCount(30)
-
-                barChart.axisLeft.setDrawLabels(false)
-                barChart.axisRight.setDrawLabels(true)
-                barChart.xAxis.setDrawLabels(true)
-                barChart.legend.setEnabled(false)
-                barChart.setDrawValueAboveBar(true)
-                //barChart.setVisibleXRangeMaximum(30f)
-        */
-
-/*
-        val seekBar = findViewById<SeekBar>(R.id.seekBar);
-        seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
-            override fun onProgressChanged(
-                seekBar: SeekBar?,
-                progress: Int,
-                fromUser: Boolean
-            ) {
-                //tvX.setText(java.lang.String.valueOf(seekBar.getProgress()))
-                //tvY.setText(java.lang.String.valueOf(seekBarY.getProgress()))
-
-                //setData(seekBarX.getProgress(), seekBarY.getProgress())
-                barChart.setFitBars(true)
-                barChart.invalidate()
-            }
-            override fun onStartTrackingTouch(seekBar: SeekBar?) {}
-
-            override fun onStopTrackingTouch(seekBar: SeekBar?) {}
-        })
-*/
-/*
-        // if more than 60 entries are displayed in the barChart, no values will be
-        // drawn
-        //barChart.setMaxVisibleValueCount(60)
-
-        barChart.setScaleMinima(2f, 1f)
-
-        // scaling can now only be done on x- and y-axis separately
-        barChart.setPinchZoom(true)
-
-
-        // draw shadows for each bar that show the maximum value
-        barChart.setDrawBarShadow(true)
-        barChart.setDrawGridBackground(true)
-
-        val xl = barChart.getXAxis()
-        xl.position = XAxisPosition.BOTTOM
-        //xl.setTypeface(tfLight)
-        xl.setDrawAxisLine(true)
-        xl.setDrawGridLines(false)
-        //xl.setGranularity(10f)
-
-        //        yl.setInverted(true);
-        val yr = barChart.axisRight
-        //yr.setTypeface(tfLight)
-        yr.setDrawAxisLine(true)
-        yr.setDrawGridLines(false)
-        yr.setAxisMinimum(0f) // this replaces setStartAtZero(true)
-
-
-        //        yr.setInverted(true);
-        barChart.setFitBars(true)
-        barChart.animateY(500)
-*/
-        eventTypeSelection = findViewById(R.id.type_selection)
-        dataTypeSelection = findViewById(R.id.data_selection)
-        timeRangeSelection = findViewById(R.id.time_selection)
-
-        setupSpinner(eventTypeSelectionValue,
-            R.id.type_selection,
-            R.array.StatisticsTypeLabels,
-            R.array.StatisticsTypeValues,
-            object : SpinnerItemSelected {
-                override fun call(newValue: String?) {
-                    if (newValue != null) {
-                        eventTypeSelectionValue = newValue
-                        Log.d("event", "new value: $newValue")
-                        updateGraph()
-                    }
-                }
-            }
-        )
-
-        setupSpinner(dataTypeSelectionValue,
-            R.id.data_selection,
-            R.array.StatisticsDataLabels,
-            R.array.StatisticsDataValues,
-            object : SpinnerItemSelected {
-                override fun call(newValue: String?) {
-                    if (newValue != null) {
-                        dataTypeSelectionValue = newValue
-                        Log.d("event", "new value: $newValue")
-                        updateGraph()
-                    }
-                }
-            }
-        )
-
-       setupSpinner(timeRangeSelectionValue,
-            R.id.time_selection,
-            R.array.StatisticsTimeLabels,
-            R.array.StatisticsTimeValues,
-            object : SpinnerItemSelected {
-                override fun call(newValue: String?) {
-                    if (newValue != null) {
-                        timeRangeSelectionValue = newValue
-                        Log.d("event", "new value: $newValue")
-                        updateGraph()
-                    }
-                }
-            }
-        )
-
-       initLogbookBase()
-    }
-
-/*
-    fun massageData(): Triple<Float, Float, Float>
-        Triple(, ,)
-                    )
-*/
-
-    fun updateGraph() {
-        //eventTypeSelectionValue = "SLEEP"
-        //dataTypeSelectionValue = "AMOUNT"
-        //timeRangeSelectionValue = "DAY"
-
-        //val allEvents = getAllEvents()
-        //Log.d("StatisticsActivity", "updateGraph: allEvents: ${allEvents.size}")
-        Log.d("StatisticsActivity", "eventTypeSelectionValue: $eventTypeSelectionValue, dataTypeSelectionValue: $dataTypeSelectionValue, timeRange: $timeRangeSelectionValue")
-
-        // for quantity
-        fun formatEventValue(value: Float): String {
-            return when (eventTypeSelectionValue) {
-                "BOTTLE" -> {
-                    NumericUtils(applicationContext).formatEventQuantity(LunaEvent.TYPE_BABY_BOTTLE, value.toInt())
-                }
-                "SLEEP" -> {
-                    NumericUtils(applicationContext).formatEventQuantity(LunaEvent.TYPE_SLEEP, value.toInt())
-                }
-                else -> {
-                    Log.e(TAG, "invalid dataTypeSelectionValue: $dataTypeSelectionValue")
-                    "${value.toInt()}"
-                }
-            }
-        }
-
-        val eventType = when (eventTypeSelectionValue) {
-            "BOTTLE" -> LunaEvent.TYPE_BABY_BOTTLE
-            "SLEEP" -> LunaEvent.TYPE_SLEEP
-            else -> {
-                Log.e(TAG, "Invalid eventTypeSelectionValue: $eventTypeSelectionValue")
-                return
-            }
-        }
-        val allEvents = getAllEvents().filter { it.type == eventType }.sortedBy { it.time }
-
-        Log.d("StatisticsActivity", "events: ${allEvents.size}")
-
-        val values = ArrayList<BarEntry>()
-        val labels = ArrayList<String>()
-
-        val unixToSpan: ((Long) -> Int) = { unix ->
-            when (timeRangeSelectionValue) {
-                "DAY" -> unixToDays(unix)
-                "WEEK" -> unixToWeeks(unix)
-                "MONTH" -> unixToMonths(unix)
-                else -> {
-                    Log.e(TAG, "Invalid timeRangeSelectionValue: $timeRangeSelectionValue")
-                    0
-                }
-            }
-        }
-
-        val spanToUnix: ((Int) -> Long) = { span ->
-            when (timeRangeSelectionValue) {
-                "DAY" -> daysToUnix(span)
-                "WEEK" -> weeksToUnix(span)
-                "MONTH" -> monthToUnix(span)
-                else -> {
-                    Log.e(TAG, "Invalid timeRangeSelectionValue: $timeRangeSelectionValue")
-                    0
-                }
-            }
-        }
-
-        fun spanToLabel(span: Int): String {
-            //simpleDateFormat = SimpleDateFormat("dd/MM/yyyy")
-            //val dateTime = simpleDateFormat.format(Date(1000 * spanToUnix(span))).toString()
-
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(1000 * spanToUnix(span))
-            val year = dateTime.get(Calendar.YEAR)
-            val month = dateTime.get(Calendar.MONTH) + 1 // month starts at 0
-            val week = dateTime.get(Calendar.WEEK_OF_YEAR)
-            val day = dateTime.get(Calendar.DAY_OF_MONTH)
-            return when (timeRangeSelectionValue) {
-                "DAY" -> "$day/$month/$year"
-                "WEEK" -> "$week/$year"
-                "MONTH" -> "$month/$year"
-                else -> {
-                    Log.e(TAG, "Invalid timeRangeSelectionValue: $timeRangeSelectionValue")
-                    "?"
-                }
-            }
-        }
-/*
-        fun calcDay(seconds: Long): Long {
-            val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm")
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(seconds * 1000)
-            val before = formatter.format(dateTime.time)
-            dateTime.set(Calendar.SECOND, 0)
-            dateTime.set(Calendar.MINUTE, 0)
-            dateTime.set(Calendar.HOUR, 0)
-            dateTime.set(Calendar.HOUR_OF_DAY, 0)
-            val after = formatter.format(dateTime.time)
-            //Log.d(TAG, "calcDay: $before -> $after")
-            return dateTime.time.time / 1000
-        }
-*/
-
-        if (allEvents.isNotEmpty()) {
-            barChart.visibility = View.VISIBLE
-            noDataTextView.visibility = View.GONE
-
-            // unix time span of all events
-            val startUnix = allEvents.minOf { it.time }
-            val endUnix = if (dataTypeSelectionValue == "AMOUNT" && eventTypeSelectionValue == "SLEEP") {
-                allEvents.maxOf { it.time + it.quantity }
-            } else {
-                allEvents.maxOf { it.time }
-            }
-
-            // convert to days, weeks or months
-            val startSpan = unixToSpan(startUnix)
-            val endSpan = unixToSpan(endUnix)
-
-            //Log.d(TAG, "startSpan: $startSpan (${Date(1000 * allEvents.first().time)}), endSpan: $endSpan (${Date(1000 * allEvents.last().time)})")
-            //Log.d(TAG, "start: ${Date(1000 * spanToUnix(startSpan))}, end: ${Date(1000 * spanToUnix(endSpan))}")
-            for (span in startSpan..endSpan + 1) {
-                //Log.d(TAG, "step: ${Date(1000 * daysToUnix(span))}") // todo: checj month
-                values.add(BarEntry(values.size.toFloat(), 0F))
-                labels.add(spanToLabel(span))
-            }
-
-            for (event in allEvents) {
-                if (dataTypeSelectionValue == "AMOUNT") {
-                    if (eventTypeSelectionValue == "SLEEP") {
-                        // a sleep event can span to another day
-                        // distribute sleep time over the days
-
-                        // iterate over indexes
-
-                        // sleep covers a time range, distribute range of time spans
-                        //var mid = spanToUnix(startIndex)
-
-                        val startUnix = event.time
-                        val endUnix = event.time + event.quantity
-                        val begIndex = unixToSpan(startUnix)
-                        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) {
-                            val spanBegin = spanToUnix(i)
-                            val spanEnd =  spanToUnix(i + 1)
-                            Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, endUnix: ${Date(endUnix * 1000)}")
-                            val beg = max(mid, spanBegin)
-                            val end = min(endUnix, spanEnd)
-                            val index = i - startSpan
-                            val duration = end - beg
-                            Log.d(TAG, "[$index] beg: ${Date(beg * 1000)}, end: ${Date(end * 1000)}, ${formatTimeDuration(this, duration)}")
-
-                            values[index].y += duration
-                            mid = end
-                        }
-                    } else {
-                        val index = unixToSpan(event.time) - startSpan
-                        values[index].y += event.quantity
-                    }
-                } else {
-                    val index = unixToSpan(event.time) - startSpan
-                    values[index].y += 1
-                }
-            }
-        } else {
-            barChart.visibility = View.GONE
-            noDataTextView.visibility = View.VISIBLE
-        }
-
-        val set1 = BarDataSet(values, "sums") // change to "sums", "events", "" and set logbookName to
-
-        set1.setDrawValues(true)
-        set1.setDrawIcons(false)
-
-        //Log.d("StatisticsActivity", "values.size: ${values.size}, labels.size: ${labels.size}")
-        //Log.d("StatisticsActivity", "values: ${values}, labels: ${labels}")
-
-        /*
-        val set1: BarDataSet
-                if (barChart.data != null &&
-                    barChart.data.getDataSetCount() > 0
-                ) {
-                    set1 = barChart.data.getDataSetByIndex(0) as BarDataSet
-                    set1.setValues(values)
-                    barChart.data.notifyDataChanged()
-                    barChart.notifyDataSetChanged()
-                } else {
-            */
-
-
-            val dataSets = ArrayList<IBarDataSet?>()
-            dataSets.add(set1)
-
-            val data = BarData(dataSets)
-            //data.setValueTextSize(10f)
-            //data.setValueTypeface(tfLight)
-            //data.barWidth = 9f
-
-
-            data.setValueFormatter(object : ValueFormatter() {
-                override fun getFormattedValue(value: Float): String {
-                    if (dataTypeSelectionValue == "AMOUNT") {
-                        //Log.d(TAG, "formatEventValue: ${formatEventValue(value)}")
-                        //Log.d(TAG, "data.setValueFormatter")
-                        return formatEventValue(value)
-                    } else {
-                        return value.toInt().toString()
-                    }
-                }
-            })
-
-            //barChart.xAxis.setLabelsToSkip(0)
-
-            //val leftAxis = barChart.axisLeft
-            //barChart.xAxis.setLabelCount(values.size)
-            barChart.axisRight.setDrawLabels(false)
-            barChart.axisLeft.setDrawLabels(false)
-
-            barChart.xAxis.valueFormatter = object : ValueFormatter() {
-                override fun getFormattedValue(value: Float): String {
-                    //Log.d("labels", "labels: ${value.toInt()}")
-                    return labels.getOrElse(value.toInt(), {"?"})
-                }
-            }
-
-        //val labelsTmp = values.map { "${it.y.toInt()} ml" } // ArrayList<String>()
-        //Log.d("StatisticsActivity", "labels: $labelsTmp")
-        //barChart.xAxis.setGranularity(1f)
-        //barChart.xAxis.isGranularityEnabled = true
-        //barChart.xAxis.setValueFormatter(IndexAxisValueFormatter(labels))
-/*
-        barChart.axisRight.valueFormatter = object : ValueFormatter() {
-            override fun getFormattedValue(value: Float): String {
-                //Log.d(TAG, "formatEventValue: ${formatEventValue(value)}")
-                return formatEventValue(value)
-            }
-        }
-*/
-            //barChart.axisRight.setGranularity(1.0f)
-            //barChart.axisRight.isGranularityEnabled = true
-/*
-            barChart.getYLabels().valueFormatter = object : ValueFormatter() {
-                override fun getFormattedValue(value: Float): String {
-                    Log.d("StatisticsActivity", "y value: $value")
-                    return value.toString() + "ml"
-                }
-            }
-*/
-            //barChart.axisLeft.textColor = Color.WHITE
-            //barChart.axisRight.textColor = Color.WHITE
-            //barChart.setNoDataTextColor(Color.RED)
-            //barChart.setBackgroundColor()
-
-            //data.setValueTextSize(10f)
-            //data.setValueTypeface(tfLight)
-            //data.setBarWidth(9f)
-            //data.setValueTextColor(Color.WHITE)
-            data.setValueTextSize(12f)
-            barChart.setData(data)
-            barChart.invalidate()
-        //}
-    }
-
-    private interface SpinnerItemSelected {
-        fun call(newValue: String?)
-    }
-
-    private fun setupSpinner(
-        currentValue: String,
-        spinnerId: Int,
-        arrayId: Int,
-        arrayValuesId: Int,
-        callback: SpinnerItemSelected
-    ) {
-        val arrayValues = resources.getStringArray(arrayValuesId)
-        val spinner = findViewById<Spinner>(spinnerId)
-        val spinnerAdapter =
-            ArrayAdapter.createFromResource(this, arrayId, R.layout.statistics_spinner_item) //android.R.layout.simple_spinner_item) //android.R.layout.simple_list_item_single_choice) //R.layout.spinner_item_settings)
-
-        spinner.adapter = spinnerAdapter
-        spinner.setSelection(arrayValues.indexOf(currentValue))
-        spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
-            var check = 0
-            override fun onItemSelected(parent: AdapterView<*>?, view: View?, pos: Int, id: Long) {
-                if (pos >= arrayValues.size) {
-                    Toast.makeText(
-                        this@StatisticsActivity,
-                        "pos out of bounds: $arrayValues", Toast.LENGTH_SHORT
-                    ).show()
-                    return
-                }
-                if (check++ > 0) {
-                    callback.call(arrayValues[pos])
-                }
-            }
-
-            override fun onNothingSelected(parent: AdapterView<*>?) {
-                // ignore
-            }
-        }
-    }
-
-/*
-    fun loadSettings() {
-        val dataRepo = settingsRepository.loadDataRepository()
-        val webDavCredentials = settingsRepository.loadWebdavCredentials()
-        val noBreastfeeding = settingsRepository.loadNoBreastfeeding()
-        val signature = settingsRepository.loadSignature()
-
-        when (dataRepo) {
-            LocalSettingsRepository.DATA_REPO.LOCAL_FILE -> radioDataLocal.isChecked = true
-            LocalSettingsRepository.DATA_REPO.WEBDAV -> radioDataWebDAV.isChecked = true
-        }
-
-        textViewSignature.setText(signature)
-        switchNoBreastfeeding.isChecked = noBreastfeeding
-
-        if (webDavCredentials != null) {
-            textViewWebDAVUrl.text = webDavCredentials[0]
-            textViewWebDAVUser.text = webDavCredentials[1]
-            textViewWebDAVPass.text = webDavCredentials[2]
-        }
-    }
-
-    fun validateAndSave() {
-        if (radioDataLocal.isChecked) {
-            // No validation required, just save
-            saveSettings()
-            return
-        }
-
-        // Try to connect to WebDAV and check if the save file already exists
-        val webDAVLogbookRepo = WebDAVLogbookRepository(
-            textViewWebDAVUrl.text.toString(),
-            textViewWebDAVUser.text.toString(),
-            textViewWebDAVPass.text.toString()
-        )
-        progressIndicator.visibility = View.VISIBLE
-
-        webDAVLogbookRepo.listLogbooks(this, object: LogbookListObtainedListener{
-
-            override fun onLogbookListObtained(logbooksNames: ArrayList<String>) {
-                if (logbooksNames.isEmpty()) {
-                    // TODO: Ask the user if he wants to upload the local ones or to create a new one
-                    copyLocalLogbooksToWebdav(webDAVLogbookRepo, object: OnCopyLocalLogbooksToWebdavFinishedListener {
-
-                        override fun onCopyLocalLogbooksToWebdavFinished(errors: String?) {
-                            runOnUiThread({
-                                progressIndicator.visibility = View.INVISIBLE
-                                if (errors == null) {
-                                    saveSettings()
-                                    Toast.makeText(this@SettingsActivity, R.string.settings_webdav_creation_ok, Toast.LENGTH_SHORT).show()
-                                } else {
-                                    Toast.makeText(this@SettingsActivity, errors, Toast.LENGTH_SHORT).show()
-                                }
-                            })
-                        }
-
-                    })
-                } else {
-                    runOnUiThread({
-                        progressIndicator.visibility = View.INVISIBLE
-                        saveSettings()
-                        Toast.makeText(this@SettingsActivity, R.string.settings_webdav_creation_ok, Toast.LENGTH_SHORT).show()
-                    })
-                }
-            }
-
-            override fun onIOError(error: IOException) {
-                runOnUiThread({
-                    progressIndicator.visibility = View.INVISIBLE
-                    Toast.makeText(this@SettingsActivity, getString(R.string.settings_network_error) + error.toString(), Toast.LENGTH_SHORT).show()
-                })
-            }
-
-            override fun onWebDAVError(error: SardineException) {
-                runOnUiThread({
-                    progressIndicator.visibility = View.INVISIBLE
-                    if(error.toString().contains("401")) {
-                        Toast.makeText(this@SettingsActivity, getString(R.string.settings_webdav_error_denied), Toast.LENGTH_SHORT).show()
-                    } else {
-                        Toast.makeText(this@SettingsActivity, getString(R.string.settings_webdav_error_generic) + error.toString(), Toast.LENGTH_SHORT).show()
-                    }
-                })
-            }
-
-            override fun onError(error: Exception) {
-                runOnUiThread({
-                    progressIndicator.visibility = View.INVISIBLE
-                    Toast.makeText(this@SettingsActivity, getString(R.string.settings_generic_error) + error.toString(), Toast.LENGTH_SHORT).show()
-                })
-            }
-        })
-    }
-
-    fun saveSettings() {
-        settingsRepository.saveDataRepository(
-            if (radioDataWebDAV.isChecked) LocalSettingsRepository.DATA_REPO.WEBDAV
-            else LocalSettingsRepository.DATA_REPO.LOCAL_FILE
-        )
-        settingsRepository.saveNoBreastfeeding(switchNoBreastfeeding.isChecked)
-        settingsRepository.saveSignature(textViewSignature.text.toString())
-        settingsRepository.saveWebdavCredentials(
-            textViewWebDAVUrl.text.toString(),
-            textViewWebDAVUser.text.toString(),
-            textViewWebDAVPass.text.toString()
-        )
-        finish()
-    }
-
-    private fun copyLocalLogbooksToWebdav(webDAVLogbookRepository: WebDAVLogbookRepository, listener: OnCopyLocalLogbooksToWebdavFinishedListener) {
-        Thread(Runnable {
-            val errors = StringBuilder()
-            val fileLogbookRepo = FileLogbookRepository()
-            val logbooks = fileLogbookRepo.getAllLogbooks(this)
-            for (logbook in logbooks) {
-                // Copy only if does not already exist
-                val error = webDAVLogbookRepository.uploadLogbookIfNotExists(this, logbook.name)
-                if (error != null) {
-                    if (errors.isNotEmpty())
-                        errors.append("\n")
-                    errors.append(String.format(getString(R.string.settings_webdav_upload_error), logbook.name, error))
-                }
-            }
-            listener.onCopyLocalLogbooksToWebdavFinished(
-                if (errors.isEmpty()) null else errors.toString()
-            )
-        }).start()
-    }
-
-    private interface OnCopyLocalLogbooksToWebdavFinishedListener {
-        fun onCopyLocalLogbooksToWebdavFinished(errors: String?)
-    }
-    */
-
-    companion object {
-        fun unixToMonths(seconds: Long): Int {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(seconds * 1000)
-            val years = dateTime.get(Calendar.YEAR)
-            val months = dateTime.get(Calendar.MONTH)  // January is 0
-            return 12 * years + 1 + months
-        }
-
-        fun monthToUnix(months: Int): Long {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(0)
-            dateTime.set(Calendar.YEAR, months / 12)
-            dateTime.set(Calendar.MONTH, months % 12)
-            dateTime.set(Calendar.HOUR, 0)
-            dateTime.set(Calendar.MINUTE, 0)
-            dateTime.set(Calendar.SECOND, 0)
-            return dateTime.time.time / 1000
-        }
-
-        fun unixToWeeks(seconds: Long): Int {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(seconds * 1000)
-            val years = dateTime.get(Calendar.YEAR)
-            val weeks = dateTime.get(Calendar.WEEK_OF_YEAR)
-            return 52 * years + weeks
-        }
-
-        fun weeksToUnix(weeks: Int): Long {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(0)
-            dateTime.set(Calendar.YEAR, weeks / 52)
-            dateTime.set(Calendar.DAY_OF_YEAR, weeks % 52)
-            dateTime.set(Calendar.HOUR, 0)
-            dateTime.set(Calendar.MINUTE, 0)
-            dateTime.set(Calendar.SECOND, 0)
-            return dateTime.time.time / 1000
-        }
-
-        fun unixToDays(seconds: Long): Int {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(seconds * 1000)
-            val years = dateTime.get(Calendar.YEAR)
-            val days = dateTime.get(Calendar.DAY_OF_YEAR)
-            return 365 * years + days
-        }
-
-        // convert from days to Date
-        fun daysToUnix(days: Int): Long {
-            val dateTime = Calendar.getInstance()
-            dateTime.time = Date(0)
-            dateTime.set(Calendar.YEAR, days / 365)
-            dateTime.set(Calendar.DAY_OF_YEAR, days % 365)
-            dateTime.set(Calendar.HOUR, 0)
-            dateTime.set(Calendar.MINUTE, 0)
-            dateTime.set(Calendar.SECOND, 0)
-            return dateTime.time.time / 1000
-        }
-    }
-}

app/src/main/java/it/danieleverducci/lunatracker/adapters/LunaEventRecyclerAdapter.kt

@@ -52,19 +52,18 @@ class LunaEventRecyclerAdapter: RecyclerView.Adapter<LunaEventRecyclerAdapter.Lu
         )
         holder.quantity.setTextColor(ContextCompat.getColor(context, R.color.textColor))
         // Contents
-        holder.type.text = item.getTypeEmoji(context)
+        holder.type.text = item.getHeaderEmoji(context)
         holder.description.text = when (item.type) {
-            LunaEvent.TYPE_MEDICINE -> item.notes
+            LunaEvent.Type.MEDICINE -> item.notes
-            LunaEvent.TYPE_NOTE -> item.notes
+            LunaEvent.Type.NOTE -> item.notes
-            LunaEvent.TYPE_CUSTOM -> item.notes
+            else -> item.getRowItemTitle(context)
-            else -> item.getTypeDescription(context)
         }
-        holder.time.text = DateUtils.formatTimeAgo(context, item.time)
+        holder.time.text = DateUtils.formatTimeAgo(context, item.getEndTime())
         var quantityText = numericUtils.formatEventQuantity(item)
 
         // if the event is weight, show difference with the last one
-        if (item.type == LunaEvent.TYPE_WEIGHT) {
+        if (item.type == LunaEvent.Type.WEIGHT) {
-            val lastWeight = getPreviousWeightEvent(position)
+            val lastWeight = getPreviousEvent(position, LunaEvent.Type.WEIGHT)
             if (lastWeight != null) {
                 val differenceInWeight = item.quantity - lastWeight.quantity
                 val sign = if (differenceInWeight > 0) "+" else ""
@@ -75,6 +74,19 @@ class LunaEventRecyclerAdapter: RecyclerView.Adapter<LunaEventRecyclerAdapter.Lu
             }
         }
 
+        // if the event is height, show difference with the last one
+        if (item.type == LunaEvent.Type.HEIGHT) {
+            val lastHeight = getPreviousEvent(position, LunaEvent.Type.HEIGHT)
+            if (lastHeight != null) {
+                val differenceInHeight = item.quantity - lastHeight.quantity
+                val sign = if (differenceInHeight > 0) "+" else ""
+                quantityText += "\n($sign$differenceInHeight)"
+                if (differenceInHeight < 0) {
+                    holder.quantity.setTextColor(ContextCompat.getColor(context, R.color.danger))
+                }
+            }
+        }
+
         holder.quantity.text = quantityText
 
         // Listeners
@@ -89,12 +101,12 @@ class LunaEventRecyclerAdapter: RecyclerView.Adapter<LunaEventRecyclerAdapter.Lu
         return items.size
     }
 
-    private fun getPreviousWeightEvent(startFromPosition: Int): LunaEvent? {
+    private fun getPreviousEvent(startFromPosition: Int, type: LunaEvent.Type): LunaEvent? {
         if (startFromPosition == items.size - 1)
             return null
         for (pos in startFromPosition + 1 until items.size) {
             val item = items.get(pos)
-            if (item.type != LunaEvent.TYPE_WEIGHT)
+            if (item.type != type)
                 continue
             return item
         }

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

@@ -12,25 +12,25 @@ import java.util.Date
  * release, it is simply ignored by previous ones).
  */
 class LunaEvent: Comparable<LunaEvent> {
-
+    enum class Type {
-    companion object {
+        BABY_BOTTLE,
-        const val TYPE_BABY_BOTTLE = "BABY_BOTTLE"
+        FOOD,
-        const val TYPE_WEIGHT = "WEIGHT"
+        BREASTFEEDING_LEFT_NIPPLE,
-        const val TYPE_BREASTFEEDING_LEFT_NIPPLE = "BREASTFEEDING_LEFT_NIPPLE"
+        BREASTFEEDING_BOTH_NIPPLE,
-        const val TYPE_BREASTFEEDING_BOTH_NIPPLE = "BREASTFEEDING_BOTH_NIPPLE"
+        BREASTFEEDING_RIGHT_NIPPLE,
-        const val TYPE_BREASTFEEDING_RIGHT_NIPPLE = "BREASTFEEDING_RIGHT_NIPPLE"
+        DIAPERCHANGE_POO,
-        const val TYPE_DIAPERCHANGE_POO = "DIAPERCHANGE_POO"
+        DIAPERCHANGE_PEE,
-        const val TYPE_DIAPERCHANGE_PEE = "DIAPERCHANGE_PEE"
+        SLEEP,
-        const val TYPE_MEDICINE = "MEDICINE"
+        WEIGHT,
-        const val TYPE_ENEMA = "ENEMA"
+        HEIGHT,
-        const val TYPE_NOTE = "NOTE"
+        MEDICINE,
-        const val TYPE_CUSTOM = "CUSTOM"
+        ENEMA,
-        const val TYPE_COLIC = "COLIC"
+        NOTE,
-        const val TYPE_TEMPERATURE = "TEMPERATURE"
+        COLIC,
-        const val TYPE_FOOD = "FOOD"
+        TEMPERATURE,
-        const val TYPE_PUKE = "PUKE"
+        PUKE,
-        const val TYPE_BATH = "BATH"
+        BATH,
-        const val TYPE_SLEEP = "SLEEP"
+        UNKNOWN
     }
 
     private val jo: JSONObject
@@ -40,10 +40,16 @@ class LunaEvent: Comparable<LunaEvent> {
         set(value) {
             jo.put("time", value)
         }
-    var type: String
+    var type: Type
-        get(): String = jo.getString("type")
+        get(): Type {
+            return try {
+                Type.valueOf(jo.getString("type"))
+            } catch (_: Exception) {
+                Type.UNKNOWN
+            }
+        }
         set(value) {
-            jo.put("type", value)
+            jo.put("type", value.name)
         }
     var quantity: Int
         get() = jo.optInt("quantity")
@@ -81,81 +87,45 @@ class LunaEvent: Comparable<LunaEvent> {
         this.signature = event.signature
     }
 
-    constructor(type: String) {
+    constructor(type: Type) {
         this.jo = JSONObject()
         this.time = System.currentTimeMillis() / 1000
         this.type = type
     }
 
-    constructor(type: String, quantity: Int) {
+    constructor(type: Type, quantity: Int) {
         this.jo = JSONObject()
         this.time = System.currentTimeMillis() / 1000
         this.type = type
         this.quantity = quantity
     }
 
-    fun getTypeEmoji(context: Context): String {
+    fun getHeaderEmoji(context: Context): String {
-        return context.getString(
+        return getHeaderEmoji(context, type)
-            when (type) {
-                TYPE_BABY_BOTTLE -> R.string.event_bottle_type
-                TYPE_WEIGHT -> R.string.event_weight_type
-                TYPE_BREASTFEEDING_LEFT_NIPPLE -> R.string.event_breastfeeding_left_type
-                TYPE_BREASTFEEDING_BOTH_NIPPLE -> R.string.event_breastfeeding_both_type
-                TYPE_BREASTFEEDING_RIGHT_NIPPLE -> R.string.event_breastfeeding_right_type
-                TYPE_DIAPERCHANGE_POO -> R.string.event_diaperchange_poo_type
-                TYPE_DIAPERCHANGE_PEE -> R.string.event_diaperchange_pee_type
-                TYPE_MEDICINE -> R.string.event_medicine_type
-                TYPE_ENEMA -> R.string.event_enema_type
-                TYPE_NOTE -> R.string.event_note_type
-                TYPE_TEMPERATURE -> R.string.event_temperature_type
-                TYPE_COLIC -> R.string.event_colic_type
-                TYPE_FOOD -> R.string.event_food_type
-                TYPE_PUKE -> R.string.event_puke_type
-                TYPE_BATH -> R.string.event_bath_type
-                TYPE_SLEEP -> R.string.event_sleep_type
-                else -> R.string.event_unknown_type
-            }
-        )
     }
 
-    fun getTypeDescription(context: Context): String {
+    fun getDialogTitle(context: Context): String {
-        return context.getString(
+        return getDialogTitle(context, type)
-            when (type) {
-                TYPE_BABY_BOTTLE -> R.string.event_bottle_desc
-                TYPE_WEIGHT -> R.string.event_weight_desc
-                TYPE_BREASTFEEDING_LEFT_NIPPLE -> R.string.event_breastfeeding_left_desc
-                TYPE_BREASTFEEDING_BOTH_NIPPLE -> R.string.event_breastfeeding_both_desc
-                TYPE_BREASTFEEDING_RIGHT_NIPPLE -> R.string.event_breastfeeding_right_desc
-                TYPE_DIAPERCHANGE_POO -> R.string.event_diaperchange_poo_desc
-                TYPE_DIAPERCHANGE_PEE -> R.string.event_diaperchange_pee_desc
-                TYPE_MEDICINE -> R.string.event_medicine_desc
-                TYPE_ENEMA -> R.string.event_enema_desc
-                TYPE_NOTE -> R.string.event_note_desc
-                TYPE_TEMPERATURE -> R.string.event_temperature_desc
-                TYPE_COLIC -> R.string.event_colic_desc
-                TYPE_FOOD -> R.string.event_food_desc
-                TYPE_PUKE -> R.string.event_puke_desc
-                TYPE_BATH -> R.string.event_bath_desc
-                TYPE_SLEEP -> R.string.event_sleep_desc
-                else -> R.string.event_unknown_desc
-            }
-        )
     }
 
-    fun getDialogMessage(context: Context): String? {
+    fun getRowItemTitle(context: Context): String {
-        return context.getString(
+        return getPopupItemTitle(context, type).split(" ", limit = 2).last() // remove emoji
-            when(type) {
+    }
-                TYPE_BABY_BOTTLE -> R.string.log_bottle_dialog_description
+
-                TYPE_MEDICINE -> R.string.log_medicine_dialog_description
+    fun getDialogMessage(context: Context): String {
-                TYPE_TEMPERATURE -> R.string.log_temperature_dialog_description
+        return getDialogMessage(context, type)
-                TYPE_DIAPERCHANGE_POO,
+    }
-                TYPE_DIAPERCHANGE_PEE,
+
-                TYPE_PUKE -> R.string.log_amount_dialog_description
+    fun getStartTime(): Long {
-                TYPE_WEIGHT -> R.string.log_weight_dialog_description
+        return time
-                TYPE_SLEEP -> R.string.log_sleep_dialog_description
+    }
-                else -> R.string.log_unknown_dialog_description
+
+    fun getEndTime(): Long {
+        return if (type == Type.SLEEP) {
+            time + quantity
+        } else {
+            time
         }
-        )
     }
 
     fun toJson(): JSONObject {
@@ -169,4 +139,99 @@ class LunaEvent: Comparable<LunaEvent> {
     override fun compareTo(other: LunaEvent): Int {
         return (this.time - other.time).toInt()
     }
+
+    companion object {
+        fun getHeaderEmoji(context: Context, type: Type): String {
+            return context.getString(
+                when (type) {
+                    Type.BABY_BOTTLE -> R.string.event_bottle_type
+                    Type.WEIGHT -> R.string.event_weight_type
+                    Type.HEIGHT -> R.string.event_height_type
+                    Type.BREASTFEEDING_LEFT_NIPPLE -> R.string.event_breastfeeding_left_type
+                    Type.BREASTFEEDING_BOTH_NIPPLE -> R.string.event_breastfeeding_both_type
+                    Type.BREASTFEEDING_RIGHT_NIPPLE -> R.string.event_breastfeeding_right_type
+                    Type.DIAPERCHANGE_POO -> R.string.event_diaperchange_poo_type
+                    Type.DIAPERCHANGE_PEE -> R.string.event_diaperchange_pee_type
+                    Type.MEDICINE -> R.string.event_medicine_type
+                    Type.ENEMA -> R.string.event_enema_type
+                    Type.NOTE -> R.string.event_note_type
+                    Type.TEMPERATURE -> R.string.event_temperature_type
+                    Type.COLIC -> R.string.event_colic_type
+                    Type.FOOD -> R.string.event_food_type
+                    Type.PUKE -> R.string.event_puke_type
+                    Type.BATH -> R.string.event_bath_type
+                    Type.SLEEP -> R.string.event_sleep_type
+                    Type.UNKNOWN -> R.string.event_unknown_type
+                }
+            )
+        }
+
+        fun getDialogMessage(context: Context, type: Type): String {
+            return context.getString(
+                when (type) {
+                    Type.BABY_BOTTLE -> R.string.log_bottle_dialog_description
+                    Type.MEDICINE -> R.string.log_medicine_dialog_description
+                    Type.TEMPERATURE -> R.string.log_temperature_dialog_description
+                    Type.DIAPERCHANGE_POO,
+                    Type.DIAPERCHANGE_PEE,
+                    Type.PUKE -> R.string.log_amount_dialog_description
+                    Type.WEIGHT -> R.string.log_weight_dialog_description
+                    Type.HEIGHT -> R.string.log_height_dialog_description
+                    Type.SLEEP -> R.string.log_duration_dialog_description
+                    else -> R.string.log_unknown_dialog_description
+                }
+            )
+        }
+
+        fun getDialogTitle(context: Context, type: Type): String {
+            return context.getString(
+                when (type) {
+                    Type.BABY_BOTTLE -> R.string.event_bottle_desc
+                    Type.WEIGHT -> R.string.event_weight_desc
+                    Type.HEIGHT -> R.string.event_height_desc
+                    Type.BREASTFEEDING_LEFT_NIPPLE -> R.string.event_breastfeeding_left_desc
+                    Type.BREASTFEEDING_BOTH_NIPPLE -> R.string.event_breastfeeding_both_desc
+                    Type.BREASTFEEDING_RIGHT_NIPPLE -> R.string.event_breastfeeding_right_desc
+                    Type.DIAPERCHANGE_POO -> R.string.event_diaperchange_poo_desc
+                    Type.DIAPERCHANGE_PEE -> R.string.event_diaperchange_pee_desc
+                    Type.MEDICINE -> R.string.event_medicine_desc
+                    Type.ENEMA -> R.string.event_enema_desc
+                    Type.NOTE -> R.string.event_note_desc
+                    Type.TEMPERATURE -> R.string.event_temperature_desc
+                    Type.COLIC -> R.string.event_colic_desc
+                    Type.FOOD -> R.string.event_food_desc
+                    Type.PUKE -> R.string.event_puke_desc
+                    Type.BATH -> R.string.event_bath_desc
+                    Type.SLEEP -> R.string.event_sleep_desc
+                    Type.UNKNOWN -> R.string.event_unknown_desc
+                }
+            )
+        }
+
+        // Entries for for popup list
+        fun getPopupItemTitle(context: Context, type: Type): String {
+            return context.getString(
+                when (type) {
+                    Type.BABY_BOTTLE -> R.string.event_type_item_bottle
+                    Type.WEIGHT -> R.string.event_type_item_weight
+                    Type.HEIGHT -> R.string.event_type_item_height
+                    Type.BREASTFEEDING_LEFT_NIPPLE -> R.string.event_type_item_breastfeeding_left
+                    Type.BREASTFEEDING_BOTH_NIPPLE -> R.string.event_type_item_breastfeeding_both
+                    Type.BREASTFEEDING_RIGHT_NIPPLE -> R.string.event_type_item_breastfeeding_right
+                    Type.DIAPERCHANGE_POO -> R.string.event_type_item_diaperchange_poo
+                    Type.DIAPERCHANGE_PEE -> R.string.event_type_item_diaperchange_pee
+                    Type.MEDICINE -> R.string.event_type_item_medicine
+                    Type.ENEMA -> R.string.event_type_item_enema
+                    Type.NOTE -> R.string.event_type_item_note
+                    Type.TEMPERATURE -> R.string.event_type_item_temperature
+                    Type.COLIC -> R.string.event_type_item_colic
+                    Type.FOOD -> R.string.event_type_item_food
+                    Type.PUKE -> R.string.event_type_item_puke
+                    Type.BATH -> R.string.event_type_item_bath
+                    Type.SLEEP -> R.string.event_type_item_sleep
+                    Type.UNKNOWN -> R.string.event_type_item_unknown
+                }
+            )
+        }
+    }
 }

app/src/main/java/it/danieleverducci/lunatracker/repository/LocalSettingsRepository.kt

@@ -13,7 +13,7 @@ class LocalSettingsRepository(val context: Context) {
         const val SHARED_PREFS_DAV_URL = "webdav_url"
         const val SHARED_PREFS_DAV_USER = "webdav_user"
         const val SHARED_PREFS_DAV_PASS = "webdav_password"
-        const val SHARED_PREFS_NO_BREASTFEEDING = "no_breastfeeding"
+        const val SHARED_PREFS_DYNAMIC_MENU = "dynamic_menu"
         const val SHARED_PREFS_SIGNATURE = "signature"
     }
     enum class DATA_REPO {LOCAL_FILE, WEBDAV}
@@ -31,12 +31,12 @@ class LocalSettingsRepository(val context: Context) {
         return sharedPreferences.getString(SHARED_PREFS_SIGNATURE, "") ?: ""
     }
 
-    fun saveNoBreastfeeding(content: Boolean) {
+    fun saveDynamicMenu(content: Boolean) {
-        sharedPreferences.edit { putBoolean(SHARED_PREFS_NO_BREASTFEEDING, content) }
+        sharedPreferences.edit { putBoolean(SHARED_PREFS_DYNAMIC_MENU, content) }
     }
 
-    fun loadNoBreastfeeding(): Boolean {
+    fun loadDynamicMenu(): Boolean {
-        return sharedPreferences.getBoolean(SHARED_PREFS_NO_BREASTFEEDING, false)
+        return sharedPreferences.getBoolean(SHARED_PREFS_DYNAMIC_MENU, false)
     }
 
     fun saveDataRepository(repo: DATA_REPO) {

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()
@@ -56,11 +61,11 @@ class DateUtils {
                 return builder.toString()
             }
 
-            if (years > 0) {
+            if (years != 0L) {
                 return format(years, days, R.string.year_ago, R.string.years_ago, R.string.day_ago, R.string.days_ago)
-            } else if (days > 0) {
+            } else if (days != 0L) {
                 return format(days, hours, R.string.day_ago, R.string.days_ago, R.string.hour_ago, R.string.hours_ago)
-            } else if (hours > 0) {
+            } else if (hours != 0L) {
                 return format(hours, minutes, R.string.hour_ago, R.string.hours_ago, R.string.minute_ago, R.string.minutes_ago)
             } else {
                 return format(minutes, seconds, R.string.minute_ago, R.string.minute_ago, R.string.second_ago, R.string.seconds_ago)

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

@@ -11,10 +11,10 @@ import utils.DateUtils.Companion.formatTimeDuration
 import java.text.NumberFormat
 
 class NumericUtils (val context: Context) {
-    val numberFormat: NumberFormat
     val measurement_unit_liquid_base: String
     val measurement_unit_weight_base: String
     val measurement_unit_weight_tiny: String
+    val measurement_unit_height_base: String
     val measurement_unit_temperature_base: String
 
     private fun isMetricSystem(): Boolean {
@@ -35,7 +35,6 @@ class NumericUtils (val context: Context) {
     }
 
     init {
-        this.numberFormat = NumberFormat.getInstance()
         this.measurement_unit_liquid_base = context.getString(
             if (isMetricSystem())
                 R.string.measurement_unit_liquid_base_metric
@@ -54,6 +53,12 @@ class NumericUtils (val context: Context) {
             else
                 R.string.measurement_unit_weight_tiny_imperial
         )
+        this.measurement_unit_height_base = context.getString(
+            if (isMetricSystem())
+                R.string.measurement_unit_height_base_metric
+            else
+                R.string.measurement_unit_height_base_imperial
+        )
         this.measurement_unit_temperature_base = context.getString(
             if (isMetricSystem())
                 R.string.measurement_unit_temperature_base_metric
@@ -66,51 +71,52 @@ class NumericUtils (val context: Context) {
         return formatEventQuantity(event.type, event.quantity)
     }
 
-    fun formatEventQuantity(type: String, quantity: Int): String {
+    fun formatEventQuantity(type: LunaEvent.Type, quantity: Int): String {
         val formatted = StringBuilder()
         if (quantity > 0) {
             formatted.append(when (type) {
-                LunaEvent.TYPE_TEMPERATURE ->
+                LunaEvent.Type.TEMPERATURE ->
                     (quantity / 10.0f).toString()
-                LunaEvent.TYPE_DIAPERCHANGE_POO,
+                LunaEvent.Type.DIAPERCHANGE_POO,
-                LunaEvent.TYPE_DIAPERCHANGE_PEE,
+                LunaEvent.Type.DIAPERCHANGE_PEE,
-                LunaEvent.TYPE_PUKE -> {
+                LunaEvent.Type.PUKE -> {
                     val array = context.resources.getStringArray(R.array.AmountLabels)
                     return array.getOrElse(quantity) {
                         Log.e("NumericUtils", "Invalid index $quantity")
                         return ""
                     }
                 }
-                LunaEvent.TYPE_SLEEP -> formatTimeDuration(context, quantity.toLong())
+                LunaEvent.Type.SLEEP -> formatTimeDuration(context, quantity.toLong())
                 else -> quantity
             })
 
             formatted.append(" ")
             formatted.append(
                 when (type) {
-                    LunaEvent.TYPE_BABY_BOTTLE -> measurement_unit_liquid_base
+                    LunaEvent.Type.BABY_BOTTLE -> measurement_unit_liquid_base
-                    LunaEvent.TYPE_WEIGHT -> measurement_unit_weight_base
+                    LunaEvent.Type.WEIGHT -> measurement_unit_weight_base
-                    LunaEvent.TYPE_MEDICINE -> measurement_unit_weight_tiny
+                    LunaEvent.Type.HEIGHT -> measurement_unit_height_base
-                    LunaEvent.TYPE_TEMPERATURE -> measurement_unit_temperature_base
+                    LunaEvent.Type.MEDICINE -> measurement_unit_weight_tiny
+                    LunaEvent.Type.TEMPERATURE -> measurement_unit_temperature_base
                     else -> ""
                 }
             )
         } else {
             formatted.append(when (type) {
-                LunaEvent.TYPE_SLEEP -> "💤" // baby is sleeping
+                LunaEvent.Type.SLEEP -> "💤" // baby is sleeping
                 else -> ""
             })
         }
-        return formatted.toString()
+        return formatted.toString().trim()
     }
 
     /**
      * Returns a valid quantity range for the event type.
      * @return min, max, normal
      */
-    fun getValidEventQuantityRange(lunaEventType: String): Triple<Int, Int, Int>? {
+    fun getValidEventQuantityRange(lunaEventType: LunaEvent.Type): Triple<Int, Int, Int>? {
         return when (lunaEventType) {
-            LunaEvent.TYPE_TEMPERATURE -> {
+            LunaEvent.Type.TEMPERATURE -> {
                 if (isMetricSystem())
                     Triple(
                         context.resources.getInteger(R.integer.human_body_temp_min_metric),

app/src/main/res/drawable/ic_more.xml

@@ -1,5 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#000000" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
-      
-    <path android:fillColor="@android:color/white" android:pathData="M12,8c1.1,0 2,-0.9 2,-2s-0.9,-2 -2,-2 -2,0.9 -2,2 0.9,2 2,2zM12,10c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2zM12,16c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2z"/>
-    
-</vector>

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

@@ -86,15 +86,16 @@
             android:orientation="vertical">
 
             <LinearLayout
+                android:id="@+id/linear_layout_row1"
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
                 android:orientation="horizontal">
 
                 <TextView
-                    android:id="@+id/button_bottle"
+                    android:id="@+id/button1_row1"
                     android:layout_width="0dp"
                     android:layout_height="wrap_content"
-                    android:layout_weight="2"
+                    android:layout_weight="1"
                     android:layout_margin="5dp"
                     android:background="@drawable/button_background"
                     android:gravity="center_horizontal"
@@ -102,7 +103,7 @@
                     android:text="@string/event_bottle_type"/>
 
                 <TextView
-                    android:id="@+id/button_food"
+                    android:id="@+id/button2_row1"
                     android:layout_width="0dp"
                     android:layout_height="wrap_content"
                     android:layout_weight="1"
@@ -115,80 +116,77 @@
             </LinearLayout>
 
             <LinearLayout
-                android:layout_width="match_parent"
+                android:id="@+id/linear_layout_row2"
-                android:layout_height="wrap_content"
-                android:id="@+id/layout_nipples">
-
-                <TextView
-                    android:id="@+id/button_nipple_left"
-                    android:layout_width="0dp"
-                    android:layout_height="wrap_content"
-                    android:layout_margin="5dp"
-                    android:layout_weight="1"
-                    android:background="@drawable/button_background"
-                    android:gravity="center_horizontal"
-                    android:textSize="30sp"
-                    android:text="🤱⬅️"/>
-
-                <TextView
-                    android:id="@+id/button_nipple_both"
-                    android:layout_width="0dp"
-                    android:layout_height="wrap_content"
-                    android:layout_margin="5dp"
-                    android:layout_weight="1"
-                    android:background="@drawable/button_background"
-                    android:gravity="center_horizontal"
-                    android:textSize="30sp"
-                    android:text="🤱↔️"/>
-
-                <TextView
-                    android:id="@+id/button_nipple_right"
-                    android:layout_width="0dp"
-                    android:layout_height="wrap_content"
-                    android:layout_margin="5dp"
-                    android:layout_weight="1"
-                    android:background="@drawable/button_background"
-                    android:gravity="center_horizontal"
-                    android:textSize="30sp"
-                    android:text="🤱➡️️"/>
-
-            </LinearLayout>
-
-            <LinearLayout
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content">
 
                 <TextView
-                    android:id="@+id/button_change_poo"
+                    android:id="@+id/button1_row2"
                     android:layout_width="0dp"
                     android:layout_height="wrap_content"
                     android:layout_margin="5dp"
-                    android:layout_weight="2"
-                    android:background="@drawable/button_background"
-                    android:gravity="center_horizontal"
-                    android:textSize="30sp"
-                    android:text="🚼 💩"/>
-
-                <TextView
-                    android:id="@+id/button_change_pee"
-                    android:layout_width="0dp"
-                    android:layout_height="wrap_content"
-                    android:layout_margin="5dp"
-                    android:layout_weight="2"
-                    android:background="@drawable/button_background"
-                    android:gravity="center_horizontal"
-                    android:textSize="30sp"
-                    android:text="🚼 💧"/>
-
-                <ImageView
-                    android:id="@+id/button_more"
-                    android:layout_width="0dp"
-                    android:layout_height="match_parent"
-                    android:layout_margin="5dp"
                     android:layout_weight="1"
                     android:background="@drawable/button_background"
                     android:gravity="center_horizontal"
-                    android:src="@drawable/ic_more"
+                    android:textSize="30sp"/>
+
+                <TextView
+                    android:id="@+id/button2_row2"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="5dp"
+                    android:layout_weight="1"
+                    android:background="@drawable/button_background"
+                    android:gravity="center_horizontal"
+                    android:textSize="30sp"/>
+
+                <TextView
+                    android:id="@+id/button3_row2"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="5dp"
+                    android:layout_weight="1"
+                    android:background="@drawable/button_background"
+                    android:gravity="center_horizontal"
+                    android:textSize="30sp"/>
+
+            </LinearLayout>
+
+            <LinearLayout
+                android:id="@+id/linear_layout_row3"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content">
+
+                <TextView
+                    android:id="@+id/button1_row3"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="5dp"
+                    android:layout_weight="2"
+                    android:background="@drawable/button_background"
+                    android:gravity="center_horizontal"
+                    android:textSize="30sp"/>
+
+                <TextView
+                    android:id="@+id/button2_row3"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="5dp"
+                    android:layout_weight="2"
+                    android:background="@drawable/button_background"
+                    android:gravity="center_horizontal"
+                    android:textSize="30sp"/>
+
+                <TextView
+                    android:id="@+id/button_more"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="5dp"
+                    android:layout_weight="1"
+                    android:background="@drawable/button_background"
+                    android:gravity="center_horizontal"
+                    android:textSize="30sp"
+                    android:text="☰"
                     app:tint="@android:color/darker_gray"/>
 
             </LinearLayout>
@@ -261,6 +259,7 @@
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_marginTop="10dp"
+            android:layout_marginHorizontal="10dp"
             android:gravity="center_horizontal"
             android:text="@string/no_connection_explain"/>
 

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

@@ -137,7 +137,7 @@
         <TextView
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginStart="30dp"
+            android:layout_marginStart="20dp"
             android:layout_marginTop="5dp"
             android:text="@string/settings_signature_desc"/>
 
@@ -149,13 +149,13 @@
 
             <TextView
                 android:layout_width="0dp"
-                android:layout_weight="1"
                 android:layout_height="wrap_content"
+                android:layout_weight="1"
                 android:textStyle="bold"
-                android:text="@string/settings_no_breastfeeding" />
+                android:text="@string/settings_dynamic_menu" />
 
             <com.google.android.material.switchmaterial.SwitchMaterial
-                android:id="@+id/switch_no_breastfeeding"
+                android:id="@+id/switch_dynamic_menu"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_marginEnd="20dp"
@@ -166,9 +166,9 @@
         <TextView
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginStart="30dp"
+            android:layout_marginStart="20dp"
             android:layout_marginTop="5dp"
-            android:text="@string/settings_no_breastfeeding_desc"/>
+            android:text="@string/settings_dynamic_menu_desc"/>
 
         <LinearLayout
             android:layout_width="match_parent"

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

@@ -21,7 +21,7 @@
             android:layout_height="match_parent"
             android:visibility="gone"
             android:gravity="center"
-            android:text="No Data"/>
+            android:text="@string/statistics_no_data"/>
 
     </FrameLayout>
 
@@ -29,26 +29,21 @@
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_weight="0"
-        android:layout_marginTop="10dp"
         android:orientation="horizontal">
 
         <Spinner
-            android:id="@+id/type_selection"
+            android:id="@+id/graph_type_selection"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_weight="1" />
+            android:layout_weight="1"
+            android:gravity="center"/>
 
         <Spinner
-            android:id="@+id/data_selection"
+            android:id="@+id/time_range_selection"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_weight="1"/>
+            android:layout_weight="1"
-
+            android:gravity="center"/>
-        <Spinner
-            android:id="@+id/time_selection"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_weight="1"/>
 
     </LinearLayout>
 

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

@@ -11,45 +11,65 @@
         android:id="@+id/dialog_date_duration"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
+        android:layout_marginTop="10dp"
         android:textSize="20sp"
         android:text="💤"/>
 
     <LinearLayout
-        android:layout_width="match_parent"
+        android:id="@+id/duration_buttons"
         android:layout_height="wrap_content"
+        android:layout_width="match_parent"
         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="-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/now"/>
+            android:text="@string/dialog_duration_button_now"/>
 
         <Button
-            android:id="@+id/dialog_date_duration_plus5"
+            android:id="@+id/dialog_date_duration_clear"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_weight="1"
-            android:text="+5"/>
+            android:text="@string/dialog_duration_button_clear"/>
 
     </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"
+            android:id="@+id/dialog_date_picker_begin"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-        android:layout_gravity="center"
+            android:gravity="center"
-        android:layout_marginTop="20dp"/>
+            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/layout/dialog_edit_height.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_gravity="center"
+        android:gravity="center"
+        android:orientation="horizontal">
+
+        <EditText
+            android:id="@+id/dialog_number_edittext"
+            android:layout_width="150dp"
+            android:layout_height="wrap_content"
+            android:inputType="number"
+            android:hint="0"
+            android:background="@drawable/textview_background"/>
+
+        <TextView
+            android:id="@+id/dialog_number_unit"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:text="cm"/>
+
+    </LinearLayout>
+
+    <TextView
+        android:id="@+id/dialog_date_picker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:layout_marginTop="20dp"/>
+
+</LinearLayout>

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

@@ -21,6 +21,7 @@
             android:background="@drawable/textview_background"/>
 
         <TextView
+            android:id="@+id/dialog_number_unit"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginStart="10dp"

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

@@ -6,6 +6,7 @@
     android:background="@color/transparent">
 
     <LinearLayout
+        android:id="@+id/layout_list"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="vertical">
@@ -14,102 +15,12 @@
                 android:id="@+id/button_statistics"
                 android:layout_width="match_parent"
                 android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
                 android:padding="10dp"
                 android:background="@drawable/dropdown_list_item_background"
                 style="@style/OverflowMenuText"
                 android:text="📊 Statistics"/>
 
-            <TextView
+                <!-- Other buttons are inserted dynamically -->
-                android:id="@+id/button_medicine"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_medicine"/>
-
-            <TextView
-                android:id="@+id/button_note"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_note"/>
-
-            <TextView
-                android:id="@+id/button_temperature"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_temperature"/>
-
-            <TextView
-                android:id="@+id/button_puke"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_puke"/>
-
-            <TextView
-                android:id="@+id/button_sleep"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_sleep"/>
-
-            <TextView
-                android:id="@+id/button_colic"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_colic"/>
-
-            <TextView
-                android:id="@+id/button_scale"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_weight"/>
-
-            <TextView
-                android:id="@+id/button_bath"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_bath"/>
-
-            <TextView
-                android:id="@+id/button_enema"
-                android:layout_width="match_parent"
-                android:layout_height="match_parent"
-                android:layout_marginTop="10dp"
-                android:padding="10dp"
-                android:background="@drawable/dropdown_list_item_background"
-                style="@style/OverflowMenuText"
-                android:text="@string/overflow_event_enema"/>
-
     </LinearLayout>
 
 </ScrollView>

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

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TextView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/tv"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_marginTop="10dp"
+    android:padding="10dp"
+    android:background="@drawable/dropdown_list_item_background"
+    style="@style/OverflowMenuText"
+    android:text="Item Template"/>

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

@@ -18,13 +18,6 @@
     <string name="event_colic_desc">Blähungskolik</string>
     <string name="event_unknown_desc"></string>
 
-    <string name="overflow_event_weight">⚖️ Gewicht</string>
-    <string name="overflow_event_medicine">💊 Medikament</string>
-    <string name="overflow_event_enema">🪠 Einlauf</string>
-    <string name="overflow_event_note">📝 Notiz</string>
-    <string name="overflow_event_temperature">🌡️ Temperatur</string>
-    <string name="overflow_event_colic">💨 Blähungskolik</string>
-
     <string name="toast_event_added">Ereignis gespeichert</string>
     <string name="toast_logbook_saved">Logbuch gespeichert</string>
     <string name="toast_event_add_error">Ereignis konnte nicht protokolliert werden</string>
@@ -42,7 +35,6 @@
     <string name="no_connection_retry">Erneut versuchen</string>
 
     <string name="settings_title">Einstellungen</string>
-    <string name="settings_no_breastfeeding">Kein Stillen</string>
     <string name="settings_storage">Speicherort für Daten auswählen</string>
     <string name="settings_storage_local">Auf dem Gerät</string>
     <string name="settings_storage_local_desc">Datenschutzfreundlichste Lösung: Deine Daten verlassen dein Gerät nicht</string>

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

@@ -18,13 +18,6 @@
     <string name="event_colic_desc">Colique gazeuse</string>
     <string name="event_unknown_desc"></string>
 
-    <string name="overflow_event_weight">⚖️ Poids</string>
-    <string name="overflow_event_medicine">💊 Médicament</string>
-    <string name="overflow_event_enema">🪠 Lavement</string>
-    <string name="overflow_event_note">📝 Note</string>
-    <string name="overflow_event_temperature">🌡️ Température</string>
-    <string name="overflow_event_colic">💨 Colique gazeuse</string>
-
     <string name="toast_event_added">Entrée ajoutée</string>
     <string name="toast_logbook_saved">Journal ajouté</string>
     <string name="toast_event_add_error">Impossible d\'enregistrer cette entrée</string>

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

@@ -3,13 +3,6 @@
     <string name="title">🌜 LunaTracker 🌛</string>
     <string name="logbook">Diario di bordo</string>
 
-    <string name="overflow_event_weight">⚖️ Peso</string>
-    <string name="overflow_event_medicine">💊 Medicina</string>
-    <string name="overflow_event_enema">🪠 Clistere</string>
-    <string name="overflow_event_note">📝 Nota</string>
-    <string name="overflow_event_temperature">🌡️ Temperatura</string>
-    <string name="overflow_event_colic">💨 Colichette</string>
-
     <string name="event_bottle_desc">Biberon</string>
     <string name="event_food_desc">Cibo</string>
     <string name="event_weight_desc">Pesata</string>

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

@@ -8,23 +8,19 @@
     </string-array>
 
     <string-array name="StatisticsTypeLabels">
-        <item>Bottle</item>
+        <item>@string/statistics_bottle_sum</item>
-        <item>Sleep</item>
+        <item>@string/statistics_bottle_events</item>
+        <item>@string/statistics_sleep_sum</item>
+        <item>@string/statistics_sleep_events</item>
+        <item>@string/statistics_sleep_pattern</item>
     </string-array>
 
     <string-array name="StatisticsTypeValues">
-        <item>BOTTLE</item>
+        <item>BOTTLE_SUM</item>
-        <item>SLEEP</item>
+        <item>BOTTLE_EVENTS</item>
-    </string-array>
+        <item>SLEEP_SUM</item>
-
+        <item>SLEEP_EVENTS</item>
-    <string-array name="StatisticsDataLabels">
+        <item>SLEEP_PATTERN</item>
-        <item>Event</item>
-        <item>Amount</item>
-    </string-array>
-
-    <string-array name="StatisticsDataValues">
-        <item>EVENT</item>
-        <item>AMOUNT</item>
     </string-array>
 
     <string-array name="StatisticsTimeLabels">
@@ -38,12 +34,4 @@
         <item>WEEK</item>
         <item>MONTH</item>
     </string-array>
-
-<!--
-    <string-array name="speakerphoneModeValues">
-        <item>auto</item>
-        <item>on</item>
-        <item>off</item>
-    </string-array>
--->
 </resources>

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

@@ -3,12 +3,14 @@
     <string name="title">🌜 LunaTracker 🌛</string>
     <string name="logbook">Logged events</string>
 
+    <!-- menu header items -->
     <string name="event_bottle_type" translatable="false">🍼</string>
     <string name="event_food_type" translatable="false">🥣</string>
     <string name="event_weight_type" translatable="false">⚖️</string>
-    <string name="event_breastfeeding_left_type" translatable="false">🤱 ←</string>
+    <string name="event_height_type" translatable="false">📏</string>
-    <string name="event_breastfeeding_both_type" translatable="false">🤱 ↔</string>
+    <string name="event_breastfeeding_left_type" translatable="false">🤱⬅️</string>
-    <string name="event_breastfeeding_right_type" translatable="false">🤱 →</string>
+    <string name="event_breastfeeding_both_type" translatable="false">🤱↔️</string>
+    <string name="event_breastfeeding_right_type" translatable="false">🤱➡️️</string>
     <string name="event_diaperchange_poo_type" translatable="false">🚼 💩</string>
     <string name="event_diaperchange_pee_type" translatable="false">🚼 💧</string>
     <string name="event_medicine_type" translatable="false">💊</string>
@@ -19,16 +21,38 @@
     <string name="event_puke_type" translatable="false">🤮</string>
     <string name="event_bath_type" translatable="false">🛁</string>
     <string name="event_sleep_type" translatable="false">💤</string>
-    <string name="event_unknown_type" translatable="false">\?</string>
+    <string name="event_unknown_type" translatable="false">❓</string>
 
-    <string name="event_bottle_desc">Baby bottle</string>
+    <!-- dropdown menu item -->
+    <string name="event_type_item_bottle">🍼 Bottle</string>
+    <string name="event_type_item_food">🥣 Food</string>
+    <string name="event_type_item_weight">⚖️ Weight</string>
+    <string name="event_type_item_height">📏 Height</string>
+    <string name="event_type_item_breastfeeding_left">🤱⬅️ Nursing</string>
+    <string name="event_type_item_breastfeeding_both">🤱↔️ Nursing</string>
+    <string name="event_type_item_breastfeeding_right">🤱➡️️ Nursing</string>
+    <string name="event_type_item_diaperchange_poo">🚼💩 Diaper</string>
+    <string name="event_type_item_diaperchange_pee">🚼💧 Diaper</string>
+    <string name="event_type_item_medicine">💊 Medicine</string>
+    <string name="event_type_item_enema">🪠 Enema</string>
+    <string name="event_type_item_note">📝 Note</string>
+    <string name="event_type_item_temperature">🌡️ Temperature</string>
+    <string name="event_type_item_colic">💨 Colic</string>
+    <string name="event_type_item_puke">🤮 Puke</string>
+    <string name="event_type_item_sleep">💤 Sleep</string>
+    <string name="event_type_item_bath">🛁 Bath</string>
+    <string name="event_type_item_unknown">❓ Unknown</string>
+
+    <!-- dialog titles -->
+    <string name="event_bottle_desc">Milk Bottle</string>
     <string name="event_food_desc">Food</string>
     <string name="event_weight_desc">Weight</string>
-    <string name="event_breastfeeding_left_desc">Breastfeeding (left)</string>
+    <string name="event_height_desc">Height</string>
-    <string name="event_breastfeeding_both_desc">Breastfeeding</string>
+    <string name="event_breastfeeding_left_desc">Nursing (left)</string>
-    <string name="event_breastfeeding_right_desc">Breastfeeding (right)</string>
+    <string name="event_breastfeeding_both_desc">Nursing (both)</string>
-    <string name="event_diaperchange_poo_desc">Diaper chg (poo)</string>
+    <string name="event_breastfeeding_right_desc">Nursing (right)</string>
-    <string name="event_diaperchange_pee_desc">Diaper chg (pee)</string>
+    <string name="event_diaperchange_poo_desc">Diaper Change (poo)</string>
+    <string name="event_diaperchange_pee_desc">Diaper Change (pee)</string>
     <string name="event_medicine_desc">Medicine</string>
     <string name="event_enema_desc">Enema</string>
     <string name="event_note_desc">Note</string>
@@ -37,17 +61,7 @@
     <string name="event_puke_desc">Puke</string>
     <string name="event_bath_desc">Bath</string>
     <string name="event_sleep_desc">Sleep</string>
-    <string name="event_unknown_desc"></string>
+    <string name="event_unknown_desc">Unknown</string>
-
-    <string name="overflow_event_weight">⚖️ Weight</string>
-    <string name="overflow_event_medicine">💊 Medicine</string>
-    <string name="overflow_event_enema">🪠 Enema</string>
-    <string name="overflow_event_note">📝 Note</string>
-    <string name="overflow_event_temperature">🌡️ Temperature</string>
-    <string name="overflow_event_colic">💨 Gaseous colic</string>
-    <string name="overflow_event_puke">🤮 Puke</string>
-    <string name="overflow_event_sleep">💤 Sleep</string>
-    <string name="overflow_event_bath">🛁 Bath</string>
 
     <string name="toast_event_added">Event logged</string>
     <string name="toast_logbook_saved">Logbook saved</string>
@@ -78,7 +92,10 @@
     <string name="no_connection_retry">Retry</string>
 
     <string name="statistics_title">Statistics</string>
+    <string name="statistics_no_data">No Data</string>
 
+    <string name="settings_dynamic_menu">Dynamic Menu</string>
+    <string name="settings_dynamic_menu_desc">Populate the header menu with the most used events.</string>
     <string name="settings_title">Settings</string>
     <string name="settings_signature">Signature</string>
     <string name="settings_signature_desc">Attach a signature to each event you create and for others to see. Useful if multiple people add events.</string>
@@ -97,8 +114,6 @@
     <string name="settings_webdav_error_generic">Error while trying to access WebDAV:</string>
     <string name="settings_webdav_creation_error_generic">Unable to save a file on the WebDAV server:</string>
     <string name="settings_webdav_creation_ok">Successfully connected with the WebDAV server</string>
-    <string name="settings_no_breastfeeding">No Breastfeeding</string>
-    <string name="settings_no_breastfeeding_desc">Hide the Breastfeeding buttons for when they are not needed.</string>
     <string name="settings_json_error">There\'s a save file on the server, but it is corrupted or unreadable. Please delete it </string>
     <string name="settings_generic_error">Error: </string>
     <string name="settings_webdav_upload_error">Error while uploading local logbook %1$s to webdav: %2$s</string>
@@ -118,17 +133,27 @@
     <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_height_dialog_description">Insert the height:</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>
     <string name="measurement_unit_weight_tiny_metric" translatable="false">mg</string>
+    <string name="measurement_unit_height_base_metric" translatable="false">cm</string>
     <string name="measurement_unit_liquid_base_imperial" translatable="false">fl oz.</string>
     <string name="measurement_unit_weight_base_imperial" translatable="false">oz</string>
     <string name="measurement_unit_weight_tiny_imperial" translatable="false">gr</string>
+    <string name="measurement_unit_height_base_imperial" translatable="false">in</string>
     <string name="measurement_unit_temperature_base_imperial" translatable="false">°F</string>
     <string name="measurement_unit_temperature_base_metric" translatable="false">°C</string>
 
+    <string name="statistics_bottle_events">Bottle Events</string>
+    <string name="statistics_bottle_sum">Bottle Per Day</string>
+    <string name="statistics_medicine_events">Medicine Events</string>
+    <string name="statistics_sleep_sum">Sleep Per Day</string>
+    <string name="statistics_sleep_events">Sleep Events</string>
+    <string name="statistics_sleep_pattern">Sleep Pattern</string>
+
     <string name="row_luna_event_description">Description</string>
     <string name="row_luna_event_quantity">Qty</string>
     <string name="row_luna_event_time">Time</string>
@@ -141,6 +166,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>

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

@@ -4,6 +4,11 @@
     <style name="Theme.LunaTracker" parent="Theme.AppCompat.NoActionBar">
         <item name="colorAccent">@color/accent</item>
         <item name="android:textColor">@color/textColor</item>
+
+        <!-- make the screen not overlap with the system bars -->
+        <item name="android:fitsSystemWindows">true</item>
+        <item name="android:windowTranslucentStatus">true</item>
+        <item name="android:windowTranslucentNavigation">true</item>
     </style>
 
     <style name="OverflowMenuText">

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-agp = "8.12.0"
+agp = "8.13.0"
 kotlin = "2.0.0"
 coreKtx = "1.10.1"
 junit = "4.13.2"
@@ -13,6 +13,7 @@ mpandroidchart = "v4.2.2"
 mpandroidchartVersion = "v3.1.0"
 recyclerview = "1.3.2"
 material = "1.12.0"
+sardineAndroid = "v0.9"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -34,6 +35,7 @@ androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version
 material = { group = "com.google.android.material", name = "material", version.ref = "material" }
 mpandroidchart = { module = "com.github.PhilJay:MPAndroidChart", version.ref = "mpandroidchart" }
 mpandroidchart-vv310 = { module = "com.github.PhilJay:MPAndroidChart", version.ref = "mpandroidchartVersion" }
+sardine-android = { module = "com.github.thegrizzlylabs:sardine-android", version.ref = "sardineAndroid" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }