Phase 2: Presence/absence tracking (#7)

Adds attendance tracking and the "how many classes can I still miss"
count, ported from the legacy app.

## What's new
- **Presence** table (`subjectId`, `date`) + a v2→v3 SQLDelight
migration so existing installs upgrade cleanly. `PresenceRepository`
records/clears attendance and exposes it per subject.
- **`AbsenceCalculator`** (pure, heavily unit-tested): a scheduled class
counts as *missed* unless attendance was recorded for that day; only
classes strictly before today are counted, so today's still-confirmable
class never shows as a miss.
- `SubjectsViewModel` exposes a `SubjectSummary` per subject (missed
count, remaining allowance, has-class-today, present-today).
- `SubjectsPage` shows **"Faltas: missed/max"** (red once the allowance
is used up) and a **"Presente hoje"** switch for subjects with a class
today.

## Tests
- `AbsenceCalculatorTest` — no class times, brand-new subject, weekly
misses, recorded attendance, multiple class times, negative remaining.
- `PresenceRepositoryTest` — record/clear/toggle, dedupe per day.
- `SubjectsViewModelTest` — summaries, attendance lowering the count,
today's toggle.

## Screenshot
<img
src="https://github.com/JopiterApp/JopiterAndroid/raw/5455587cf7ca90dea1204a49e5c9edd245ddc621/docs/screenshots/07-presence-tracking.png"
width="280">

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01X5cqJDzZvxqTxMTWcN2jvm

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: LeoColman

app/src/main/java/app/jopiter/subject/AbsenceCalculator.kt

@@ -0,0 +1,48 @@
+/*
+* Jopiter App
+* Copyright (C) 2026 Leonardo Colman Lopes
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+package app.jopiter.subject
+
+import app.jopiter.subject.model.Subject
+import java.time.DayOfWeek
+import java.time.LocalDate
+import java.time.temporal.TemporalAdjusters.nextOrSame
+
+/**
+ * Counts missed classes the way the legacy app did: a scheduled class is "missed" unless the student
+ * recorded attendance ([attendedDates]) for that day. Only classes strictly before [today] are
+ * counted, so today's still-confirmable class never shows as a miss.
+ */
+object AbsenceCalculator {
+
+  fun missedClasses(subject: Subject, attendedDates: Set<LocalDate>, today: LocalDate): Int =
+    scheduledOccurrences(subject, today).count { it !in attendedDates }
+
+  /** Allowed misses still available. Negative once the subject's limit has been exceeded. */
+  fun remainingMisses(subject: Subject, attendedDates: Set<LocalDate>, today: LocalDate): Int =
+    subject.maxMissedClasses - missedClasses(subject, attendedDates, today)
+
+  private fun scheduledOccurrences(subject: Subject, today: LocalDate): List<LocalDate> =
+    subject.classTimes.flatMap { occurrences(it.dayOfWeek, subject.creationDate, today) }
+
+  private fun occurrences(day: DayOfWeek, from: LocalDate, until: LocalDate): List<LocalDate> {
+    val firstOccurrence = from.with(nextOrSame(day))
+    return generateSequence(firstOccurrence) { it.plusWeeks(1) }
+      .takeWhile { it.isBefore(until) }
+      .toList()
+  }
+}

app/src/main/java/app/jopiter/subject/SubjectModule.kt

@@ -18,14 +18,16 @@
 package app.jopiter.subject
 
 import app.jopiter.Database
+import app.jopiter.subject.repository.PresenceRepository
 import app.jopiter.subject.repository.SubjectRepository
 import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.core.parameter.parametersOf
 import org.koin.dsl.module
 
 val subjectModule = module {
   single { SubjectRepository(get<Database>().subjectQueries, get<Database>().classTimeQueries) }
-  viewModel { SubjectsViewModel(get()) }
+  single { PresenceRepository(get<Database>().presenceQueries) }
+  viewModel { SubjectsViewModel(get(), get()) }
   viewModel { parameters -> SubjectEditViewModel(get(), parameters.get()) }
 }
 

app/src/main/java/app/jopiter/subject/SubjectsPage.kt

@@ -22,6 +22,7 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
@@ -32,6 +33,7 @@ import androidx.compose.material.FloatingActionButton
 import androidx.compose.material.Icon
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Scaffold
+import androidx.compose.material.Switch
 import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
@@ -46,7 +48,6 @@ import androidx.compose.ui.unit.dp
 import app.jopiter.R
 import app.jopiter.common.TimeFormat
 import app.jopiter.common.displayNameRes
-import app.jopiter.subject.model.Subject
 import org.koin.androidx.compose.koinViewModel
 
 @Composable
@@ -55,7 +56,7 @@ fun SubjectsPage(
   onEditSubject: (Long) -> Unit,
   viewModel: SubjectsViewModel = koinViewModel()
 ) {
-  val subjects by viewModel.subjects.collectAsState()
+  val summaries by viewModel.summaries.collectAsState()
 
   Scaffold(
     floatingActionButton = {
@@ -64,7 +65,7 @@ fun SubjectsPage(
       }
     }
   ) { padding ->
-    if (subjects.isEmpty()) {
+    if (summaries.isEmpty()) {
       Box(Modifier.fillMaxSize().padding(padding), contentAlignment = Alignment.Center) {
         Text(stringResource(R.string.no_subjects), Modifier.testTag("no_subjects"))
       }
@@ -74,29 +75,33 @@ fun SubjectsPage(
         contentPadding = PaddingValues(8.dp),
         verticalArrangement = Arrangement.spacedBy(8.dp)
       ) {
-        items(subjects, key = { it.id }) { subject ->
-          SubjectCard(subject) { onEditSubject(subject.id) }
+        items(summaries, key = { it.subject.id }) { summary ->
+          SubjectCard(
+            summary = summary,
+            onClick = { onEditSubject(summary.subject.id) },
+            onTogglePresence = { viewModel.toggleTodayPresence(summary.subject.id) }
+          )
         }
       }
     }
   }
 }
 
 @Composable
-private fun SubjectCard(subject: Subject, onClick: () -> Unit) {
+private fun SubjectCard(summary: SubjectSummary, onClick: () -> Unit, onTogglePresence: () -> Unit) {
   Card(
     Modifier.fillMaxWidth().clickable(onClick = onClick).testTag("subject_card"),
     elevation = 2.dp
   ) {
     Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
-      Text(subject.name, style = MaterialTheme.typography.h6)
+      Text(summary.subject.name, style = MaterialTheme.typography.h6)
 
-      val subtitle = listOf(subject.code, subject.classroom, subject.lecturer)
+      val subtitle = listOf(summary.subject.code, summary.subject.classroom, summary.subject.lecturer)
         .filter { it.isNotBlank() }
         .joinToString(" · ")
       if (subtitle.isNotBlank()) Text(subtitle, style = MaterialTheme.typography.body2)
 
-      subject.classTimes.forEach { classTime ->
+      summary.subject.classTimes.forEach { classTime ->
         Text(
           stringResource(
             R.string.class_time_summary,
@@ -107,6 +112,31 @@ private fun SubjectCard(subject: Subject, onClick: () -> Unit) {
           style = MaterialTheme.typography.body2
         )
       }
+
+      AbsencesText(summary.missed, summary.subject.maxMissedClasses, summary.remaining)
+      if (summary.hasClassToday) PresenceToggle(summary.presentToday, onTogglePresence)
     }
   }
 }
+
+@Composable
+private fun AbsencesText(missed: Int, maxMissed: Int, remaining: Int) {
+  Text(
+    stringResource(R.string.absences_format, missed, maxMissed),
+    color = if (remaining <= 0) MaterialTheme.colors.error else MaterialTheme.colors.primary,
+    style = MaterialTheme.typography.subtitle2,
+    modifier = Modifier.testTag("absences")
+  )
+}
+
+@Composable
+private fun PresenceToggle(presentToday: Boolean, onTogglePresence: () -> Unit) {
+  Row(Modifier.fillMaxWidth(), Arrangement.SpaceBetween, Alignment.CenterVertically) {
+    Text(stringResource(R.string.present_today), style = MaterialTheme.typography.body2)
+    Switch(
+      checked = presentToday,
+      onCheckedChange = { onTogglePresence() },
+      modifier = Modifier.testTag("presence_toggle")
+    )
+  }
+}

app/src/main/java/app/jopiter/subject/SubjectsViewModel.kt

@@ -20,20 +20,47 @@ package app.jopiter.subject
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.jopiter.subject.model.Subject
+import app.jopiter.subject.repository.PresenceRepository
 import app.jopiter.subject.repository.SubjectRepository
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
+import java.time.LocalDate
 
-/** Exposes the list of subjects (with their class times) for the Subjects screen. */
+/** A subject plus its attendance status, for display on the Subjects screen. */
+data class SubjectSummary(
+  val subject: Subject,
+  val missed: Int,
+  val remaining: Int,
+  val hasClassToday: Boolean,
+  val presentToday: Boolean
+)
+
+/** Exposes subjects with their missed-class counts and a per-day presence toggle. */
 class SubjectsViewModel(
-  private val repository: SubjectRepository
+  private val subjectRepository: SubjectRepository,
+  private val presenceRepository: PresenceRepository,
+  private val today: () -> LocalDate = LocalDate::now
 ) : ViewModel() {
 
-  val subjects: StateFlow<List<Subject>> =
-    repository.subjects.stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MS), emptyList())
+  val summaries: StateFlow<List<SubjectSummary>> =
+    combine(subjectRepository.subjects, presenceRepository.attendanceBySubject) { subjects, attendance ->
+      val day = today()
+      subjects.map { subject -> subject.summarize(attendance[subject.id].orEmpty(), day) }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MS), emptyList())
+
+  fun delete(subject: Subject) = subjectRepository.delete(subject.id)
+
+  fun toggleTodayPresence(subjectId: Long) = presenceRepository.togglePresent(subjectId, today())
 
-  fun delete(subject: Subject) = repository.delete(subject.id)
+  private fun Subject.summarize(attended: Set<LocalDate>, day: LocalDate) = SubjectSummary(
+    subject = this,
+    missed = AbsenceCalculator.missedClasses(this, attended, day),
+    remaining = AbsenceCalculator.remainingMisses(this, attended, day),
+    hasClassToday = classTimes.any { it.dayOfWeek == day.dayOfWeek },
+    presentToday = day in attended
+  )
 
   private companion object {
     const val STOP_TIMEOUT_MS = 5000L

app/src/main/java/app/jopiter/subject/repository/PresenceRepository.kt

@@ -0,0 +1,46 @@
+/*
+* Jopiter App
+* Copyright (C) 2026 Leonardo Colman Lopes
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+package app.jopiter.subject.repository
+
+import app.cash.sqldelight.coroutines.asFlow
+import app.cash.sqldelight.coroutines.mapToList
+import app.jopiter.PresenceQueries
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import java.time.LocalDate
+
+/** Stores the dates a student attended a subject's classes (its "presences"). */
+class PresenceRepository(private val queries: PresenceQueries) {
+
+  @Suppress("InjectDispatcher")
+  val attendanceBySubject: Flow<Map<Long, Set<LocalDate>>> =
+    queries.selectAll().asFlow().mapToList(Dispatchers.IO).map { rows ->
+      rows.groupBy({ it.subjectId }, { LocalDate.parse(it.date) }).mapValues { (_, dates) -> dates.toSet() }
+    }
+
+  fun isPresent(subjectId: Long, date: LocalDate): Boolean =
+    queries.isPresent(subjectId, date.toString()).executeAsOne() > 0
+
+  fun setPresent(subjectId: Long, date: LocalDate, present: Boolean) {
+    if (present) queries.insert(subjectId, date.toString()) else queries.delete(subjectId, date.toString())
+  }
+
+  fun togglePresent(subjectId: Long, date: LocalDate) =
+    setPresent(subjectId, date, present = !isPresent(subjectId, date))
+}

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

@@ -37,6 +37,8 @@
     <string name="subject_max_missed_label">Faltas permitidas</string>
     <string name="class_times_label">Horários</string>
     <string name="add_class_time">Adicionar horário</string>
+    <string name="absences_format">Faltas: %1$d/%2$d</string>
+    <string name="present_today">Presente hoje</string>
     <string name="remove">Remover</string>
     <string name="save">Salvar</string>
     <string name="cancel">Cancelar</string>

app/src/main/sqldelight/app/jopiter/Presence.sq

@@ -0,0 +1,26 @@
+CREATE TABLE Presence(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    subjectId INTEGER NOT NULL,
+    date TEXT NOT NULL,
+    FOREIGN KEY(subjectId) REFERENCES Subject(id) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+CREATE UNIQUE INDEX presence_subject_date_idx ON Presence(subjectId, date);
+
+selectAll:
+SELECT * FROM Presence;
+
+selectBySubject:
+SELECT * FROM Presence WHERE subjectId = ?;
+
+insert:
+INSERT OR IGNORE INTO Presence(subjectId, date) VALUES (?, ?);
+
+delete:
+DELETE FROM Presence WHERE subjectId = ? AND date = ?;
+
+deleteBySubject:
+DELETE FROM Presence WHERE subjectId = ?;
+
+isPresent:
+SELECT COUNT(*) FROM Presence WHERE subjectId = ? AND date = ?;

app/src/main/sqldelight/app/jopiter/migrations/2.sqm

@@ -0,0 +1,9 @@
+-- Migrate schema version 2 -> 3: add attendance (Presence) records per subject and date.
+CREATE TABLE Presence(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    subjectId INTEGER NOT NULL,
+    date TEXT NOT NULL,
+    FOREIGN KEY(subjectId) REFERENCES Subject(id) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+CREATE UNIQUE INDEX presence_subject_date_idx ON Presence(subjectId, date);

app/src/test/java/app/jopiter/subject/AbsenceCalculatorTest.kt

@@ -0,0 +1,71 @@
+/*
+* Jopiter App
+* Copyright (C) 2026 Leonardo Colman Lopes
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+package app.jopiter.subject
+
+import app.jopiter.subject.model.ClassTime
+import app.jopiter.subject.model.Subject
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import java.time.DayOfWeek
+import java.time.DayOfWeek.MONDAY
+import java.time.DayOfWeek.WEDNESDAY
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.temporal.TemporalAdjusters.nextOrSame
+
+class AbsenceCalculatorTest : FunSpec({
+
+  val monday: LocalDate = LocalDate.of(2026, 6, 1).with(nextOrSame(MONDAY))
+
+  fun subject(maxMissed: Int = 8, creation: LocalDate = monday, days: List<DayOfWeek> = listOf(MONDAY)) =
+    Subject(
+      id = 1,
+      name = "Cálculo",
+      maxMissedClasses = maxMissed,
+      creationDate = creation,
+      classTimes = days.map { ClassTime(it, LocalTime.of(8, 0), LocalTime.of(10, 0)) }
+    )
+
+  test("a subject without class times never has missed classes") {
+    AbsenceCalculator.missedClasses(subject(days = emptyList()), emptySet(), monday.plusWeeks(4)) shouldBe 0
+  }
+
+  test("a brand new subject has no past classes to miss") {
+    AbsenceCalculator.missedClasses(subject(), emptySet(), monday) shouldBe 0
+  }
+
+  test("each past weekly class is missed when attendance was never recorded") {
+    // The classes on monday, +1w and +2w are in the past; the +3w class is 'today' and is not counted.
+    AbsenceCalculator.missedClasses(subject(), emptySet(), monday.plusWeeks(3)) shouldBe 3
+  }
+
+  test("recorded attendance is not counted as a miss") {
+    val attended = setOf(monday, monday.plusWeeks(1))
+    AbsenceCalculator.missedClasses(subject(), attended, monday.plusWeeks(3)) shouldBe 1
+  }
+
+  test("occurrences of every class time are counted") {
+    val twiceAWeek = subject(days = listOf(MONDAY, WEDNESDAY))
+    AbsenceCalculator.missedClasses(twiceAWeek, emptySet(), monday.plusWeeks(3)) shouldBe 6
+  }
+
+  test("remaining misses subtracts from the allowance and may go negative") {
+    AbsenceCalculator.remainingMisses(subject(maxMissed = 8), emptySet(), monday.plusWeeks(3)) shouldBe 5
+    AbsenceCalculator.remainingMisses(subject(maxMissed = 2), emptySet(), monday.plusWeeks(3)) shouldBe -1
+  }
+})