@shaykec/app-agent 1.0.4 → 1.0.6

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/LocalStorageProvider.kt

@@ -0,0 +1,301 @@
+package com.appship.family.data.local
+
+import android.content.Context
+import com.appship.family.data.*
+import com.appship.family.data.DataRepository
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.util.Calendar
+import java.util.Date
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores family members, chores, rewards, calendar events, milestones, photos, and location updates in a local SQLite database.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val context: Context,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _members = MutableStateFlow<List<FamilyMember>>(emptyList())
+    override val members: StateFlow<List<FamilyMember>> = _members.asStateFlow()
+
+    override val chores: List<Chore>
+        get() = runBlocking {
+            dao.getAllChores().map { it.toChore() }
+        }
+
+    override val rewards: List<Reward>
+        get() = runBlocking {
+            dao.getAllRewards().map { it.toReward() }
+        }
+
+    override val calendarEvents: List<CalendarEvent>
+        get() = runBlocking {
+            dao.getAllEvents().map { it.toCalendarEvent() }
+        }
+
+    override val milestones: List<Milestone>
+        get() = runBlocking {
+            dao.getAllMilestones().map { it.toMilestone() }
+        }
+
+    override val photos: List<Photo>
+        get() = runBlocking {
+            dao.getAllPhotos().map { it.toPhoto() }
+        }
+
+    override val locationUpdates: List<LocationUpdate>
+        get() = runBlocking {
+            dao.getAllLocationUpdates().map { it.toLocationUpdate() }
+        }
+
+    override fun createMember(member: FamilyMember) {
+        scope.launch {
+            dao.insertMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun updateMember(member: FamilyMember) {
+        scope.launch {
+            dao.updateMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun deleteMember(member: FamilyMember) {
+        scope.launch {
+            dao.deleteMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun memberById(id: String): FamilyMember? {
+        return runBlocking {
+            dao.getMemberById(id)?.toFamilyMember()
+        }
+    }
+
+    override fun createChore(chore: Chore) {
+        scope.launch {
+            dao.insertChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun updateChore(chore: Chore) {
+        scope.launch {
+            dao.updateChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun deleteChore(chore: Chore) {
+        scope.launch {
+            dao.deleteChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun completeChore(chore: Chore, memberId: String) {
+        scope.launch {
+            val updated = chore.copy(
+                isCompleted = true,
+                completedAt = Date(),
+                completedBy = memberId
+            )
+            dao.updateChore(ChoreEntity.fromChore(updated))
+
+            // Award points
+            memberById(memberId)?.let { member ->
+                updateMember(member.copy(points = member.points + chore.points))
+            }
+        }
+    }
+
+    override fun choresForMember(memberId: String): List<Chore> {
+        return runBlocking {
+            dao.getChoresByMember(memberId).map { it.toChore() }
+        }
+    }
+
+    override fun pendingChores(): List<Chore> {
+        return runBlocking {
+            dao.getPendingChores().map { it.toChore() }
+        }
+    }
+
+    override fun createReward(reward: Reward) {
+        scope.launch {
+            dao.insertReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun updateReward(reward: Reward) {
+        scope.launch {
+            dao.updateReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun deleteReward(reward: Reward) {
+        scope.launch {
+            dao.deleteReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun redeemReward(reward: Reward, memberId: String): Boolean {
+        return runBlocking {
+            val member = memberById(memberId) ?: return@runBlocking false
+            if (member.points < reward.pointsCost || reward.isRedeemed) return@runBlocking false
+
+            val updatedReward = reward.copy(
+                isRedeemed = true,
+                redeemedBy = memberId,
+                redeemedAt = Date()
+            )
+            dao.updateReward(RewardEntity.fromReward(updatedReward))
+
+            updateMember(member.copy(points = member.points - reward.pointsCost))
+            true
+        }
+    }
+
+    override fun availableRewards(): List<Reward> {
+        return runBlocking {
+            dao.getAvailableRewards().map { it.toReward() }
+        }
+    }
+
+    override fun createEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.insertEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun updateEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.updateEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun deleteEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.deleteEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun eventsForDate(date: Date): List<CalendarEvent> {
+        return runBlocking {
+            val calendar = Calendar.getInstance()
+            calendar.time = date
+            val dayOfYear = calendar.get(Calendar.DAY_OF_YEAR)
+            val year = calendar.get(Calendar.YEAR)
+
+            dao.getAllEvents().map { it.toCalendarEvent() }.filter {
+                val eventCalendar = Calendar.getInstance()
+                eventCalendar.time = it.date
+                eventCalendar.get(Calendar.DAY_OF_YEAR) == dayOfYear &&
+                        eventCalendar.get(Calendar.YEAR) == year
+            }
+        }
+    }
+
+    override fun createMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.insertMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun updateMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.updateMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun deleteMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.deleteMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun milestonesForMember(memberId: String): List<Milestone> {
+        return runBlocking {
+            dao.getMilestonesByMember(memberId).map { it.toMilestone() }
+        }
+    }
+
+    override fun createPhoto(photo: Photo) {
+        scope.launch {
+            dao.insertPhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun updatePhoto(photo: Photo) {
+        scope.launch {
+            dao.updatePhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun deletePhoto(photo: Photo) {
+        scope.launch {
+            dao.deletePhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun reset() {
+        scope.launch {
+            // Clear all data
+            dao.getAllMembers().forEach { dao.deleteMember(it) }
+            dao.getAllChores().forEach { dao.deleteChore(it) }
+            dao.getAllRewards().forEach { dao.deleteReward(it) }
+            dao.getAllEvents().forEach { dao.deleteEvent(it) }
+            dao.getAllMilestones().forEach { dao.deleteMilestone(it) }
+            dao.getAllPhotos().forEach { dao.deletePhoto(it) }
+            dao.getAllLocationUpdates().forEach { dao.deleteLocationUpdate(it) }
+            refreshMembers()
+        }
+    }
+
+    fun loadData() {
+        scope.launch {
+            refreshMembers()
+        }
+    }
+
+    private suspend fun refreshMembers() {
+        _members.value = dao.getAllMembers().map { it.toFamilyMember() }
+    }
+
+    companion object {
+        @Volatile
+        private var INSTANCE: LocalStorageProvider? = null
+
+        /**
+         * Initialize with Android context. Call from Application.onCreate().
+         */
+        fun initialize(context: Context) {
+            if (INSTANCE == null) {
+                synchronized(this) {
+                    if (INSTANCE == null) {
+                        val db = AppDatabase.getInstance(context)
+                        INSTANCE = LocalStorageProvider(db.appDao(), context).also {
+                            it.loadData()
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Returns the singleton instance. Must call [initialize] first.
+         */
+        fun getInstance(): LocalStorageProvider {
+            return INSTANCE ?: error(
+                "LocalStorageProvider not initialized. Call LocalStorageProvider.initialize(context) first."
+            )
+        }
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/LocationUpdateEntity.kt

@@ -0,0 +1,39 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.LocationUpdate
+import java.util.Date
+
+/**
+ * Room entity for LocationUpdate persistence.
+ */
+@Entity(tableName = "location_updates")
+data class LocationUpdateEntity(
+    @PrimaryKey val id: String,
+    val memberId: String = "",
+    val latitude: Double = 0.0,
+    val longitude: Double = 0.0,
+    val timestampMillis: Long = System.currentTimeMillis(),
+    val address: String? = null
+) {
+    fun toLocationUpdate(): LocationUpdate = LocationUpdate(
+        id = id,
+        memberId = memberId,
+        latitude = latitude,
+        longitude = longitude,
+        timestamp = Date(timestampMillis),
+        address = address
+    )
+
+    companion object {
+        fun fromLocationUpdate(location: LocationUpdate): LocationUpdateEntity = LocationUpdateEntity(
+            id = location.id,
+            memberId = location.memberId,
+            latitude = location.latitude,
+            longitude = location.longitude,
+            timestampMillis = location.timestamp.time,
+            address = location.address
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/MilestoneEntity.kt

@@ -0,0 +1,45 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.Milestone
+import java.util.Date
+
+/**
+ * Room entity for Milestone persistence.
+ */
+@Entity(tableName = "milestones")
+data class MilestoneEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String? = null,
+    val dateMillis: Long = System.currentTimeMillis(),
+    val imageURL: String? = null,
+    val memberId: String = "",
+    val category: String? = null,
+    val createdAtMillis: Long = System.currentTimeMillis()
+) {
+    fun toMilestone(): Milestone = Milestone(
+        id = id,
+        title = title,
+        description = description,
+        date = Date(dateMillis),
+        imageURL = imageURL,
+        memberId = memberId,
+        category = category,
+        createdAt = Date(createdAtMillis)
+    )
+
+    companion object {
+        fun fromMilestone(milestone: Milestone): MilestoneEntity = MilestoneEntity(
+            id = milestone.id,
+            title = milestone.title,
+            description = milestone.description,
+            dateMillis = milestone.date.time,
+            imageURL = milestone.imageURL,
+            memberId = milestone.memberId,
+            category = milestone.category,
+            createdAtMillis = milestone.createdAt.time
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/PhotoEntity.kt

@@ -0,0 +1,51 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.Photo
+import com.google.gson.Gson
+import java.util.Date
+
+/**
+ * Room entity for Photo persistence.
+ */
+@Entity(tableName = "photos")
+data class PhotoEntity(
+    @PrimaryKey val id: String,
+    val imageURL: String = "",
+    val thumbnailURL: String? = null,
+    val caption: String? = null,
+    val uploadedBy: String = "",
+    val uploadedAtMillis: Long = System.currentTimeMillis(),
+    val tagsJson: String = "[]"
+) {
+    fun toPhoto(): Photo = Photo(
+        id = id,
+        imageURL = imageURL,
+        thumbnailURL = thumbnailURL,
+        caption = caption,
+        uploadedBy = uploadedBy,
+        uploadedAt = Date(uploadedAtMillis),
+        tags = parseJsonArray(tagsJson)
+    )
+
+    private fun parseJsonArray(json: String): List<String> {
+        return try {
+            Gson().fromJson(json, Array<String>::class.java)?.toList() ?: emptyList()
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    companion object {
+        fun fromPhoto(photo: Photo): PhotoEntity = PhotoEntity(
+            id = photo.id,
+            imageURL = photo.imageURL,
+            thumbnailURL = photo.thumbnailURL,
+            caption = photo.caption,
+            uploadedBy = photo.uploadedBy,
+            uploadedAtMillis = photo.uploadedAt.time,
+            tagsJson = Gson().toJson(photo.tags)
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/RewardEntity.kt

@@ -0,0 +1,48 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.Reward
+import java.util.Date
+
+/**
+ * Room entity for Reward persistence.
+ */
+@Entity(tableName = "rewards")
+data class RewardEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String? = null,
+    val pointsCost: Int = 0,
+    val imageURL: String? = null,
+    val isRedeemed: Boolean = false,
+    val redeemedBy: String? = null,
+    val redeemedAtMillis: Long? = null,
+    val createdAtMillis: Long = System.currentTimeMillis()
+) {
+    fun toReward(): Reward = Reward(
+        id = id,
+        title = title,
+        description = description,
+        pointsCost = pointsCost,
+        imageURL = imageURL,
+        isRedeemed = isRedeemed,
+        redeemedBy = redeemedBy,
+        redeemedAt = redeemedAtMillis?.let { Date(it) },
+        createdAt = Date(createdAtMillis)
+    )
+
+    companion object {
+        fun fromReward(reward: Reward): RewardEntity = RewardEntity(
+            id = reward.id,
+            title = reward.title,
+            description = reward.description,
+            pointsCost = reward.pointsCost,
+            imageURL = reward.imageURL,
+            isRedeemed = reward.isRedeemed,
+            redeemedBy = reward.redeemedBy,
+            redeemedAtMillis = reward.redeemedAt?.time,
+            createdAtMillis = reward.createdAt.time
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/features/calendar/CalendarScreen.kt

@@ -11,18 +11,20 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
 import com.appship.family.data.CalendarEvent
-import com.appship.family.mock.MockDataProvider
+import com.appship.family.data.DataSourceResolver
+import com.appship.family.core.components.EmptyStateView
+import com.appship.family.core.components.EmptyStatePresets
 import java.util.*
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun CalendarScreen() {
-    val dataProvider = MockDataProvider.shared
-    val events by dataProvider.calendarEvents.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val events = remember { repository.calendarEvents }
     var selectedDate by remember { mutableStateOf(Date()) }
     var showingAddEvent by remember { mutableStateOf(false) }
     
-    val eventsForDate = dataProvider.eventsForDate(selectedDate)
+    val eventsForDate = repository.eventsForDate(selectedDate)
     
     Scaffold(
         topBar = {
@@ -49,14 +51,23 @@ fun CalendarScreen() {
                 modifier = Modifier.padding(vertical = 8.dp)
             )
             
-            LazyColumn(
-                verticalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                itemsIndexed(eventsForDate) { index, event ->
-                    EventCard(
-                        event = event,
-                        modifier = Modifier.testTag("calendar_event_${index}_card")
+            if (eventsForDate.isEmpty()) {
+                EmptyStateView(
+                    config = EmptyStatePresets.noItems(
+                        message = "No events scheduled for this date",
+                        onAdd = { showingAddEvent = true }
                     )
+                )
+            } else {
+                LazyColumn(
+                    verticalArrangement = Arrangement.spacedBy(12.dp)
+                ) {
+                    itemsIndexed(eventsForDate) { index, event ->
+                        EventCard(
+                            event = event,
+                            modifier = Modifier.testTag("calendar_event_${index}_card")
+                        )
+                    }
                 }
             }
         }
@@ -66,7 +77,7 @@ fun CalendarScreen() {
         AddEventDialog(
             onDismiss = { showingAddEvent = false },
             onSave = { event ->
-                dataProvider.createEvent(event)
+                repository.createEvent(event)
                 showingAddEvent = false
             }
         )

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/features/chores/ChoreBoardScreen.kt

@@ -11,14 +11,16 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
 import com.appship.family.data.Chore
-import com.appship.family.mock.MockDataProvider
+import com.appship.family.data.DataSourceResolver
+import com.appship.family.core.components.EmptyStateView
+import com.appship.family.core.components.EmptyStatePresets
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ChoreBoardScreen() {
-    val dataProvider = MockDataProvider.shared
-    val chores by dataProvider.chores.collectAsState()
-    val members by dataProvider.members.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val chores = remember { repository.chores }
+    val members by repository.members.collectAsState()
     var showingAddChore by remember { mutableStateOf(false) }
     
     val pendingChores = chores.filter { !it.isCompleted }
@@ -36,25 +38,37 @@ fun ChoreBoardScreen() {
             }
         }
     ) { paddingValues ->
-        LazyColumn(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(paddingValues)
-                .padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(12.dp)
-        ) {
-            itemsIndexed(pendingChores) { index, chore ->
-                val member = members.firstOrNull { it.id == chore.assignedTo }
-                ChoreCard(
-                    chore = chore,
-                    member = member,
-                    onComplete = {
-                        member?.let {
-                            dataProvider.completeChore(chore, it.id)
-                        }
-                    },
-                    modifier = Modifier.testTag("chore_board_chore_${index}_card")
-                )
+        if (pendingChores.isEmpty()) {
+            EmptyStateView(
+                config = EmptyStatePresets.noItems(
+                    message = "All done! No pending chores",
+                    onAdd = { showingAddChore = true }
+                ),
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues)
+            )
+        } else {
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues)
+                    .padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp)
+            ) {
+                itemsIndexed(pendingChores) { index, chore ->
+                    val member = members.firstOrNull { it.id == chore.assignedTo }
+                    ChoreCard(
+                        chore = chore,
+                        member = member,
+                        onComplete = {
+                            member?.let {
+                                repository.completeChore(chore, it.id)
+                            }
+                        },
+                        modifier = Modifier.testTag("chore_board_chore_${index}_card")
+                    )
+                }
             }
         }
     }
@@ -63,7 +77,7 @@ fun ChoreBoardScreen() {
         AddChoreDialog(
             onDismiss = { showingAddChore = false },
             onSave = { chore ->
-                dataProvider.createChore(chore)
+                repository.createChore(chore)
                 showingAddChore = false
             }
         )

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/features/familyhub/FamilyHubScreen.kt

@@ -13,15 +13,15 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
+import com.appship.family.data.DataSourceResolver
 import com.appship.family.data.FamilyMember
-import com.appship.family.mock.MockDataProvider
 import com.appship.family.features.members.MemberProfileScreen
 
 @Composable
 fun FamilyHubScreen(navController: NavController) {
-    val dataProvider = MockDataProvider.shared
-    val members by dataProvider.members.collectAsState()
-    val chores by dataProvider.chores.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val members by repository.members.collectAsState()
+    val chores = repository.chores
     var selectedMember by remember { mutableStateOf<FamilyMember?>(null) }
     
     Column(

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/features/gallery/GalleryScreen.kt

@@ -11,14 +11,14 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
+import com.appship.family.data.DataSourceResolver
 import com.appship.family.data.Photo
-import com.appship.family.mock.MockDataProvider
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun GalleryScreen() {
-    val dataProvider = MockDataProvider.shared
-    val photos by dataProvider.photos.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val photos = repository.photos
     var showingAddPhoto by remember { mutableStateOf(false) }
     
     Scaffold(