statistics

app/build.gradle.kts

@@ -60,4 +60,7 @@ 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)
+    //implementation project(':MPChartLib')
 }

app/src/main/AndroidManifest.xml

@@ -30,6 +30,10 @@
             android:name=".SettingsActivity"
             android:label="@string/settings_title"
             android:theme="@style/Theme.LunaTracker"/>
+        <activity
+            android:name=".StatisticsActivity"
+            android:label="@string/statistics_title"
+            android:theme="@style/Theme.LunaTracker"/>
     </application>
 
 </manifest>

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

@@ -6,12 +6,14 @@ import android.content.DialogInterface
 import android.content.Intent
 import android.os.Bundle
 import android.os.Handler
+import android.text.Editable
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
+import android.widget.Button
 import android.widget.EditText
 import android.widget.NumberPicker
 import android.widget.PopupWindow
@@ -330,7 +332,7 @@ class MainActivity : AppCompatActivity() {
         alertDialog.show()
     }
 
-    fun datePickerHelper(time: Long, dateTextView: TextView): Calendar {
+    fun datePickerHelper(time: Long, dateTextView: TextView, onChange: (Long) -> Unit = {}): Calendar {
         dateTextView.text = DateUtils.formatDateTime(time)
 
         val dateTime = Calendar.getInstance()
@@ -349,6 +351,7 @@ class MainActivity : AppCompatActivity() {
                     { _, hour, minute ->
                         dateTime.set(year, month, day, hour, minute)
                         dateTextView.text = DateUtils.formatDateTime(dateTime.time.time / 1000)
+                        onChange.invoke(dateTime.time.time / 1000)
                     },
                     startHour,
                     startMinute,
@@ -371,6 +374,93 @@ class MainActivity : AppCompatActivity() {
         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.setMessage(event.getDialogMessage(this))
+        d.setView(dialogView)
+
+        val durationTextView = dialogView.findViewById<TextView>(R.id.dialog_date_duration)
+        val durationNowButton = dialogView.findViewById<Button>(R.id.dialog_date_duration_now)
+        val datePicker = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
+        val durationMinus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_minus5)
+        val durationPlus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_plus5)
+
+        val currentDurationTextColor = durationTextView.currentTextColor
+        val invalidDurationTextColor = ContextCompat.getColor(this, R.color.danger)
+
+        var duration = event.quantity
+
+        fun isValidTime(timeSeconds: Long, durationSeconds: Int): Boolean {
+            val now = Calendar.getInstance().time.time / 1000
+            return (timeSeconds + durationSeconds) <= now && durationSeconds < (12 * 60 * 60)
+        }
+
+        val onDateChange = { time: Long ->
+            durationTextView.setTextColor(currentDurationTextColor)
+
+            if (duration == 0) {
+                // baby is sleeping
+                durationTextView.text = "💤"
+            } else {
+                durationTextView.text = DateUtils.formatTimeDuration(applicationContext, duration.toLong())
+                if (!isValidTime(time, duration)) {
+                    durationTextView.setTextColor(invalidDurationTextColor)
+                }
+            }
+        }
+
+        val pickedDateTime = datePickerHelper(event.time, datePicker, onDateChange)
+
+        onDateChange(pickedDateTime.time.time / 1000)
+
+        fun adjust(minutes: Int) {
+            duration += minutes * 60
+            if (duration < 0) {
+                duration = 0
+            }
+            onDateChange(pickedDateTime.time.time / 1000)
+        }
+
+        durationMinus5Button.setOnClickListener { adjust(-5) }
+        durationPlus5Button.setOnClickListener { adjust(5) }
+
+        durationNowButton.setOnClickListener {
+            val now = Calendar.getInstance().time.time / 1000
+            val start = pickedDateTime.time.time / 1000
+            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(time, duration)) {
+                event.time = time
+                event.quantity = duration
+                onPositive()
+            } else {
+                Toast.makeText(this, R.string.toast_date_error, Toast.LENGTH_SHORT).show()
+            }
+            dialogInterface.dismiss()
+        }
+
+        d.setNegativeButton(android.R.string.cancel) { dialogInterface, i ->
+            dialogInterface.dismiss()
+        }
+
+        val alertDialog = d.create()
+        alertDialog.show()
+    }
+
     fun addAmountEvent(event: LunaEvent) {
         askAmountValue(event, true) { saveEvent(event) }
     }
@@ -468,11 +558,11 @@ 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 }
 
         fun updateContent(current: LunaEvent) {
-            val allEvents = getAllEvents()
-            val prevEvent = getPreviousSameEvent(current, allEvents)
-            var nextEvent = getNextSameEvent(current, allEvents)
+            val prevEvent = getPreviousSameEvent(current, templates)
+            var nextEvent = getNextSameEvent(current, templates)
 
             notesET.setText(current.notes)
             if (useQuantity) {
@@ -580,7 +670,7 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
-    fun getPreviousSameEvent(event: LunaEvent, items: ArrayList<LunaEvent>): LunaEvent? {
+    fun getPreviousSameEvent(event: LunaEvent, items: List<LunaEvent>): LunaEvent? {
         var previousEvent: LunaEvent? = null
         for (item in items) {
             if (item.type == event.type && item.time < event.time) {
@@ -594,7 +684,7 @@ class MainActivity : AppCompatActivity() {
         return previousEvent
     }
 
-    fun getNextSameEvent(event: LunaEvent, items: ArrayList<LunaEvent>): LunaEvent? {
+    fun getNextSameEvent(event: LunaEvent, items: List<LunaEvent>): LunaEvent? {
         var nextEvent: LunaEvent? = null
         for (item in items) {
             if (item.type == event.type && item.time > event.time) {
@@ -611,6 +701,12 @@ class MainActivity : AppCompatActivity() {
     fun showEventDetailDialog(originalEvent: LunaEvent) {
         val event = LunaEvent(originalEvent)
 
+        fun eventValuesChanged(): Boolean {
+            return (event.time != originalEvent.time
+                || event.quantity != originalEvent.quantity
+                || event.notes != originalEvent.notes)
+        }
+
         // Do not update list while the detail is shown, to avoid changing the object below while it is changed by the user
         pauseLogbookUpdate = true
 
@@ -621,39 +717,13 @@ class MainActivity : AppCompatActivity() {
         val emojiTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_emoji)
         val descriptionTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_description)
         val dateTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_date)
+        val dateEndTextView = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_date_end)
         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)
         descriptionTextView.text = event.getTypeDescription(this)
 
-        val pickedTime = datePickerHelper(event.time, dateTextView)
-        val updateValues = {
-            quantityTextView.text = NumericUtils(this).formatEventQuantity(event)
-            notesTextView.text = event.notes
-        }
-        updateValues()
-
-        quantityTextView.setOnClickListener {
-            when (event.type) {
-                LunaEvent.TYPE_BABY_BOTTLE -> askBabyBottleContent(event, false, updateValues)
-                LunaEvent.TYPE_WEIGHT -> askWeightValue(event, false, updateValues)
-                LunaEvent.TYPE_DIAPERCHANGE_POO,
-                LunaEvent.TYPE_DIAPERCHANGE_PEE,
-                LunaEvent.TYPE_PUKE -> askAmountValue(event, false, updateValues)
-                LunaEvent.TYPE_TEMPERATURE -> askTemperatureValue(event, false, updateValues)
-                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
-            }
-        }
-
-        notesTextView.setOnClickListener {
-            when (event.type) {
-                LunaEvent.TYPE_FOOD,
-                LunaEvent.TYPE_MEDICINE,
-                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
-            }
-        }
-
         d.setView(dialogView)
 
         d.setNeutralButton(R.string.dialog_event_detail_delete_button) { dialogInterface, i ->
@@ -661,12 +731,8 @@ class MainActivity : AppCompatActivity() {
             dialogInterface.dismiss()
         }
 
-        d.setPositiveButton(R.string.dialog_event_detail_close_button) { dialogInterface, i ->
-            event.time = pickedTime.time.time / 1000
-
-            if (event.time != originalEvent.time
-                    || event.quantity != originalEvent.quantity
-                    || event.notes != originalEvent.notes) {
+        d.setNegativeButton(R.string.dialog_event_detail_save_button) { dialogInterface, i ->
+            if (eventValuesChanged()) {
                 originalEvent.time = event.time
                 originalEvent.quantity = event.quantity
                 originalEvent.notes = event.notes
@@ -676,6 +742,10 @@ class MainActivity : AppCompatActivity() {
             dialogInterface.dismiss()
         }
 
+        d.setPositiveButton(R.string.dialog_event_detail_close_button) { dialogInterface, i ->
+            dialogInterface.dismiss()
+        }
+
         val alertDialog = d.create()
         alertDialog.show()
 
@@ -688,6 +758,50 @@ class MainActivity : AppCompatActivity() {
             pauseLogbookUpdate = false
         }
 
+        val updateValues = {
+            quantityTextView.text = NumericUtils(this).formatEventQuantity(event)
+            notesTextView.text = event.notes
+            if (event.type == LunaEvent.TYPE_SLEEP && event.quantity > 0) {
+                dateEndTextView.text = DateUtils.formatDateTime(event.time + event.quantity)
+                dateEndTextView.visibility = View.VISIBLE
+            } else {
+                dateEndTextView.visibility = View.GONE
+            }
+
+            alertDialog.getButton(DialogInterface.BUTTON_NEGATIVE).visibility = if (eventValuesChanged()) {
+                View.VISIBLE
+            } else {
+                View.GONE
+            }
+        }
+        updateValues()
+
+        datePickerHelper(event.time, dateTextView, { newTime: Long ->
+            event.time = newTime
+            updateValues()
+        })
+
+        quantityTextView.setOnClickListener {
+            when (event.type) {
+                LunaEvent.TYPE_BABY_BOTTLE -> askBabyBottleContent(event, false, updateValues)
+                LunaEvent.TYPE_WEIGHT -> askWeightValue(event, false, updateValues)
+                LunaEvent.TYPE_DIAPERCHANGE_POO,
+                LunaEvent.TYPE_DIAPERCHANGE_PEE,
+                LunaEvent.TYPE_PUKE -> askAmountValue(event, false, updateValues)
+                LunaEvent.TYPE_TEMPERATURE -> askTemperatureValue(event, false, updateValues)
+                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
+                LunaEvent.TYPE_SLEEP -> askSleepValue(event, updateValues)
+            }
+        }
+
+        notesTextView.setOnClickListener {
+            when (event.type) {
+                LunaEvent.TYPE_FOOD,
+                LunaEvent.TYPE_MEDICINE,
+                LunaEvent.TYPE_NOTE -> askNotes(event, false, updateValues)
+            }
+        }
+
         // show optional signature
         if (event.signature.isNotEmpty()) {
             val signatureTextEdit = dialogView.findViewById<TextView>(R.id.dialog_event_detail_type_signature)
@@ -1100,6 +1214,10 @@ class MainActivity : AppCompatActivity() {
                 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()
@@ -1112,6 +1230,16 @@ class MainActivity : AppCompatActivity() {
                 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)
+                    i.putExtra("LOOGBOOK_NAME", logbook!!.name)
+                    startActivity(i)
+                } else {
+                    Toast.makeText(applicationContext, "No logbook selected!", Toast.LENGTH_SHORT).show()
+                }
+                dismiss()
+            }
         }.also { popupWindow ->
             popupWindow.setOnDismissListener({
                 Handler(mainLooper).postDelayed({

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

@@ -0,0 +1,885 @@
+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/entities/LunaEvent.kt

@@ -30,6 +30,7 @@ class LunaEvent: Comparable<LunaEvent> {
         const val TYPE_FOOD = "FOOD"
         const val TYPE_PUKE = "PUKE"
         const val TYPE_BATH = "BATH"
+        const val TYPE_SLEEP = "SLEEP"
     }
 
     private val jo: JSONObject
@@ -111,6 +112,7 @@ class LunaEvent: Comparable<LunaEvent> {
                 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
             }
         )
@@ -134,6 +136,7 @@ class LunaEvent: Comparable<LunaEvent> {
                 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
             }
         )
@@ -149,6 +152,7 @@ class LunaEvent: Comparable<LunaEvent> {
                 TYPE_DIAPERCHANGE_PEE,
                 TYPE_PUKE -> R.string.log_amount_dialog_description
                 TYPE_WEIGHT -> R.string.log_weight_dialog_description
+                TYPE_SLEEP -> R.string.log_sleep_dialog_description
                 else -> R.string.log_unknown_dialog_description
             }
         )

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

@@ -62,10 +62,8 @@ class DateUtils {
                 return format(days, hours, R.string.day_ago, R.string.days_ago, R.string.hour_ago, R.string.hours_ago)
             } else if (hours > 0) {
                 return format(hours, minutes, R.string.hour_ago, R.string.hours_ago, R.string.minute_ago, R.string.minutes_ago)
-            } else if (minutes > 0) {
-                return format(minutes, seconds, R.string.minute_ago, R.string.minute_ago, R.string.second_ago, R.string.seconds_ago)
             } else {
-                return context.getString(R.string.now)
+                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

@@ -7,6 +7,7 @@ import android.os.Build
 import android.util.Log
 import it.danieleverducci.lunatracker.R
 import it.danieleverducci.lunatracker.entities.LunaEvent
+import utils.DateUtils.Companion.formatTimeDuration
 import java.text.NumberFormat
 
 class NumericUtils (val context: Context) {
@@ -62,27 +63,31 @@ class NumericUtils (val context: Context) {
     }
 
     fun formatEventQuantity(event: LunaEvent): String {
+        return formatEventQuantity(event.type, event.quantity)
+    }
+
+    fun formatEventQuantity(type: String, quantity: Int): String {
         val formatted = StringBuilder()
-        if (event.quantity > 0) {
-            formatted.append(when (event.type) {
+        if (quantity > 0) {
+            formatted.append(when (type) {
                 LunaEvent.TYPE_TEMPERATURE ->
-                    (event.quantity / 10.0f).toString()
+                    (quantity / 10.0f).toString()
                 LunaEvent.TYPE_DIAPERCHANGE_POO,
                 LunaEvent.TYPE_DIAPERCHANGE_PEE,
                 LunaEvent.TYPE_PUKE -> {
                     val array = context.resources.getStringArray(R.array.AmountLabels)
-                    return array.getOrElse(event.quantity) {
-                        Log.e("NumericUtils", "Invalid index ${event.quantity}")
+                    return array.getOrElse(quantity) {
+                        Log.e("NumericUtils", "Invalid index $quantity")
                         return ""
                     }
                 }
-                else ->
-                    event.quantity
+                LunaEvent.TYPE_SLEEP -> formatTimeDuration(context, quantity.toLong())
+                else -> quantity
             })
 
             formatted.append(" ")
             formatted.append(
-                when (event.type) {
+                when (type) {
                     LunaEvent.TYPE_BABY_BOTTLE -> measurement_unit_liquid_base
                     LunaEvent.TYPE_WEIGHT -> measurement_unit_weight_base
                     LunaEvent.TYPE_MEDICINE -> measurement_unit_weight_tiny
@@ -90,6 +95,11 @@ class NumericUtils (val context: Context) {
                     else -> ""
                 }
             )
+        } else {
+            formatted.append(when (type) {
+                LunaEvent.TYPE_SLEEP -> "💤" // baby is sleeping
+                else -> ""
+            })
         }
         return formatted.toString()
     }

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

@@ -0,0 +1,55 @@
+<?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"
+    android:padding="10dp">
+
+    <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_weight="1">
+
+        <com.github.mikephil.charting.charts.HorizontalBarChart
+            android:id="@+id/bar_chart"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+
+        <TextView
+            android:id="@+id/no_data"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:visibility="gone"
+            android:gravity="center"
+            android:text="No Data"/>
+
+    </FrameLayout>
+
+    <LinearLayout
+        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:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1" />
+
+        <Spinner
+            android:id="@+id/data_selection"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"/>
+
+        <Spinner
+            android:id="@+id/time_selection"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"/>
+
+    </LinearLayout>
+
+</LinearLayout>

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

@@ -0,0 +1,55 @@
+<?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:layout_gravity="center"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/dialog_date_duration"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textSize="20sp"
+        android:text="💤"/>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        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"/>
+
+        <Button
+            android:id="@+id/dialog_date_duration_plus5"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="+5"/>
+
+    </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_event_details.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:orientation="vertical"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
@@ -46,6 +45,18 @@
         android:textSize="28sp"
         android:text="@string/dialog_event_detail_quantity"/>
 
+    <TextView
+        android:id="@+id/dialog_event_detail_type_date_end"
+        android:layout_width="wrap_content"
+        android:layout_height="40dp"
+        android:layout_gravity="center_horizontal"
+        android:gravity="center_vertical"
+        android:drawablePadding="10dp"
+        android:drawableTint="@color/accent"
+        android:visibility="gone"
+        android:textSize="16sp"
+        android:textStyle="bold"/>
+
     <ScrollView
         android:layout_width="match_parent"
         android:layout_height="200dp"

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

@@ -10,10 +10,21 @@
         android:layout_height="wrap_content"
         android:orientation="vertical">
 
+            <TextView
+                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
                 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"
@@ -49,6 +60,16 @@
                 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"

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

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TextView  
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent" 
+    android:layout_height="wrap_content"
+    android:textSize="20sp"
+    android:gravity="center"
+    android:padding="5dip" />

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

@@ -6,4 +6,44 @@
         <item>@string/amount_normal</item>
         <item>@string/amount_plenty</item>
     </string-array>
+
+    <string-array name="StatisticsTypeLabels">
+        <item>Bottle</item>
+        <item>Sleep</item>
+    </string-array>
+
+    <string-array name="StatisticsTypeValues">
+        <item>BOTTLE</item>
+        <item>SLEEP</item>
+    </string-array>
+
+    <string-array name="StatisticsDataLabels">
+        <item>Event</item>
+        <item>Amount</item>
+    </string-array>
+
+    <string-array name="StatisticsDataValues">
+        <item>EVENT</item>
+        <item>AMOUNT</item>
+    </string-array>
+
+    <string-array name="StatisticsTimeLabels">
+        <item>Day</item>
+        <item>Week</item>
+        <item>Month</item>
+    </string-array>
+
+    <string-array name="StatisticsTimeValues">
+        <item>DAY</item>
+        <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

@@ -18,6 +18,7 @@
     <string name="event_colic_type" translatable="false">💨</string>
     <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_bottle_desc">Baby bottle</string>
@@ -35,6 +36,7 @@
     <string name="event_colic_desc">Gaseous colic</string>
     <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="overflow_event_weight">⚖️ Weight</string>
@@ -44,12 +46,14 @@
     <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>
     <string name="toast_event_add_error">Unable to log the event</string>
     <string name="toast_integer_error">Invalid value. Insert an integer.</string>
+    <string name="toast_date_error">Invalid date.</string>
 
     <string name="now">now</string>
     <string name="second_ago">sec</string>
@@ -73,6 +77,8 @@
     <string name="no_connection_go_to_settings">Settings</string>
     <string name="no_connection_retry">Retry</string>
 
+    <string name="statistics_title">Statistics</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>
@@ -112,6 +118,7 @@
     <string name="log_temperature_dialog_description">Select the temperature:</string>
     <string name="log_unknown_dialog_description"></string>
     <string name="log_weight_dialog_description">Insert the weight:</string>
+    <string name="log_sleep_dialog_description">Set sleep duration:</string>
 
     <string name="measurement_unit_liquid_base_metric" translatable="false">ml</string>
     <string name="measurement_unit_weight_base_metric" translatable="false">g</string>
@@ -127,7 +134,8 @@
     <string name="row_luna_event_time">Time</string>
 
     <string name="dialog_event_detail_title">Event detail</string>
-    <string name="dialog_event_detail_close_button">OK</string>
+    <string name="dialog_event_detail_close_button">Close</string>
+    <string name="dialog_event_detail_save_button">Save</string>
     <string name="dialog_event_detail_delete_button">Delete</string>
     <string name="dialog_event_detail_quantity">Quantity</string>
     <string name="dialog_event_detail_notes">Notes</string>

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-agp = "8.13.0"
+agp = "8.12.0"
 kotlin = "2.0.0"
 coreKtx = "1.10.1"
 junit = "4.13.2"
@@ -9,6 +9,8 @@ lifecycleRuntimeKtx = "2.6.1"
 activityCompose = "1.8.0"
 composeBom = "2024.04.01"
 appcompat = "1.7.0"
+mpandroidchart = "v4.2.2"
+mpandroidchartVersion = "v3.1.0"
 recyclerview = "1.3.2"
 material = "1.12.0"
 
@@ -30,6 +32,8 @@ androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit
 androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
 androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
 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" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

settings.gradle.kts

@@ -16,7 +16,7 @@ dependencyResolutionManagement {
     repositories {
         google()
         mavenCentral()
-        maven(url = "https://jitpack.io")
+        maven(url = uri("https://jitpack.io"))
     }
 }