@shaykec/app-agent 1.0.4 → 1.0.6

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/data/local/PlaybackHistoryEntity.kt

@@ -0,0 +1,46 @@
+package com.appship.media.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.media.data.models.MediaItem
+import com.appship.media.data.models.PlaybackHistoryItem
+import com.google.gson.Gson
+import java.util.Date
+
+/**
+ * Room entity for PlaybackHistoryItem persistence.
+ */
+@Entity(tableName = "playback_history")
+data class PlaybackHistoryEntity(
+    @PrimaryKey val id: String,
+    val mediaItemJson: String = "{}",
+    val lastPlayedAt: Long = System.currentTimeMillis(),
+    val progress: Long = 0L,
+    val completed: Boolean = false
+) {
+    fun toPlaybackHistoryItem(): PlaybackHistoryItem? {
+        return try {
+            val item = Gson().fromJson(mediaItemJson, MediaItem::class.java)
+            PlaybackHistoryItem(
+                id = id,
+                mediaItem = item,
+                lastPlayedAt = lastPlayedAt,
+                progress = progress,
+                completed = completed
+            )
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    companion object {
+        fun fromPlaybackHistoryItem(historyItem: PlaybackHistoryItem): PlaybackHistoryEntity =
+            PlaybackHistoryEntity(
+                id = historyItem.id,
+                mediaItemJson = Gson().toJson(historyItem.mediaItem),
+                lastPlayedAt = historyItem.lastPlayedAt,
+                progress = historyItem.progress,
+                completed = historyItem.completed
+            )
+    }
+}

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/data/local/PlaylistEntity.kt

@@ -0,0 +1,64 @@
+package com.appship.media.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.media.data.models.MediaItem
+import com.appship.media.data.models.Playlist
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for Playlist persistence.
+ */
+@Entity(tableName = "playlists")
+data class PlaylistEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val description: String? = null,
+    val artworkUrl: String? = null,
+    val itemsJson: String = "[]",
+    val createdAt: Long = System.currentTimeMillis(),
+    val updatedAt: Long = System.currentTimeMillis(),
+    val isPublic: Boolean = false,
+    val playCount: Int = 0
+) {
+    fun toPlaylist(mediaItems: List<MediaItem>): Playlist {
+        val itemIds = parseItemIds()
+        val items = itemIds.mapNotNull { itemId ->
+            mediaItems.firstOrNull { it.id == itemId }
+        }
+        return Playlist(
+            id = id,
+            name = name,
+            description = description,
+            artworkUrl = artworkUrl,
+            items = items,
+            createdAt = createdAt,
+            updatedAt = updatedAt,
+            isPublic = isPublic,
+            playCount = playCount
+        )
+    }
+
+    private fun parseItemIds(): List<String> {
+        return try {
+            Gson().fromJson(itemsJson, object : TypeToken<List<String>>() {}.type) ?: emptyList()
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    companion object {
+        fun fromPlaylist(playlist: Playlist): PlaylistEntity = PlaylistEntity(
+            id = playlist.id,
+            name = playlist.name,
+            description = playlist.description,
+            artworkUrl = playlist.artworkUrl,
+            itemsJson = Gson().toJson(playlist.items.map { it.id }),
+            createdAt = playlist.createdAt,
+            updatedAt = playlist.updatedAt,
+            isPublic = playlist.isPublic,
+            playCount = playlist.playCount
+        )
+    }
+}

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/features/browse/BrowseScreen.kt

@@ -5,6 +5,7 @@ import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
@@ -13,7 +14,8 @@ import androidx.compose.ui.unit.dp
 fun BrowseScreen(
     onItemClick: (String) -> Unit
 ) {
-    val categories = com.appship.media.mock.MockDataProvider.categories
+    val repository = remember { com.appship.media.data.DataSourceResolver.repository }
+    val categories = repository.categories
     
     LazyVerticalGrid(
         columns = GridCells.Fixed(2),

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/features/detail/DetailScreen.kt

@@ -6,6 +6,7 @@ import androidx.compose.material.icons.filled.Download
 import androidx.compose.material.icons.filled.PlaylistAdd
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.unit.dp
@@ -16,7 +17,8 @@ fun DetailScreen(
     onBackClick: () -> Unit,
     onPlayClick: () -> Unit
 ) {
-    val item = com.appship.media.mock.MockDataProvider.mediaItem(itemId) ?: return
+    val repository = remember { com.appship.media.data.DataSourceResolver.repository }
+    val item = repository.mediaItem(itemId) ?: return
     
     Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
         Text(item.title, style = MaterialTheme.typography.titleLarge)

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/features/home/HomeScreen.kt

@@ -96,10 +96,11 @@ fun HomeScreen(
 
 @HiltViewModel
 class HomeViewModel @Inject constructor() : androidx.lifecycle.ViewModel() {
+    val repository = com.appship.media.data.DataSourceResolver.repository
     val featuredItems = androidx.compose.runtime.mutableStateOf(
-        com.appship.media.mock.MockDataProvider.featuredItems()
+        repository.featuredItems()
     )
     val categories = androidx.compose.runtime.mutableStateOf(
-        com.appship.media.mock.MockDataProvider.categories
+        repository.categories
     )
 }

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/features/settings/SettingsScreen.kt

@@ -6,6 +6,8 @@ import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
+import com.appship.media.core.components.EmptyStateView
+import com.appship.media.core.components.EmptyStatePresets
 
 @Composable
 fun SettingsScreen(

package/templates/android/MediaTemplate/app/src/main/kotlin/com/appship/media/mock/MockDataProvider.kt

@@ -1,147 +1,307 @@
 package com.appship.media.mock
 
+import com.appship.media.AppConfig
+import com.appship.media.data.DataRepository
 import com.appship.media.data.models.*
 import java.util.*
 
 // CUSTOMIZE:API - Replace mock data with real API calls
-object MockDataProvider {
+object MockDataProvider : DataRepository {
+    
+    // MARK: - Default Seed Data
     private val defaultCategories = listOf(
-        MediaCategory(id = "1", name = "Music", icon = "music_note", itemCount = 156),
-        MediaCategory(id = "2", name = "Podcasts", icon = "mic", itemCount = 342),
-        MediaCategory(id = "3", name = "Audiobooks", icon = "book", itemCount = 89),
-        MediaCategory(id = "4", name = "Videos", icon = "play_circle", itemCount = 124),
-        MediaCategory(id = "5", name = "Articles", icon = "article", itemCount = 267),
-        MediaCategory(id = "6", name = "Recipes", icon = "restaurant_menu", itemCount = 98)
+        MediaCategory("1", "Music", "music_note", itemCount = 45),
+        MediaCategory("2", "Podcasts", "mic", itemCount = 32),
+        MediaCategory("3", "Audiobooks", "book", itemCount = 28),
+        MediaCategory("4", "Videos", "play_circle", itemCount = 19),
+        MediaCategory("5", "Articles", "article", itemCount = 24),
+        MediaCategory("6", "Recipes", "restaurant_menu", itemCount = 15)
     )
     
-    val categories: List<MediaCategory> = defaultCategories
-    val mediaItems: List<MediaItem> = makeDefaultMediaItems()
-    val playlists: MutableList<Playlist> = mutableListOf()
-    val episodes: List<Episode> = makeDefaultEpisodes()
+    private val _categories = mutableListOf<MediaCategory>()
+    override val categories: List<MediaCategory> get() = _categories
     
-    init {
-        playlists.addAll(makeDefaultPlaylists())
-    }
+    private val _mediaItems = mutableListOf<MediaItem>()
+    override val mediaItems: List<MediaItem> get() = _mediaItems
     
-    fun mediaItem(id: String): MediaItem? = mediaItems.firstOrNull { it.id == id }
+    private val _playlists = mutableListOf<Playlist>()
+    override val playlists: List<Playlist> get() = _playlists
     
-    fun mediaItems(category: MediaCategory): List<MediaItem> {
-        return mediaItems.filter { it.category.id == category.id }
-    }
+    private val _episodes = mutableListOf<Episode>()
+    override val episodes: List<Episode> get() = _episodes
     
-    fun searchMediaItems(query: String): List<MediaItem> {
-        if (query.isEmpty()) return mediaItems
-        val lowerQuery = query.lowercase()
-        return mediaItems.filter {
-            it.title.lowercase().contains(lowerQuery) ||
-            it.artist.lowercase().contains(lowerQuery) ||
-            it.description.lowercase().contains(lowerQuery)
-        }
-    }
+    private val _playbackHistory = mutableListOf<PlaybackHistoryItem>()
+    override val playbackHistory: List<PlaybackHistoryItem> get() = _playbackHistory
     
-    fun featuredItems(): List<MediaItem> {
-        return mediaItems.filter { (it.rating ?: 0.0) >= 4.5 }.take(10)
-    }
+    private val _favorites = mutableSetOf<String>()
+    override val favorites: Set<String> get() = _favorites
     
-    fun playlist(id: String): Playlist? = playlists.firstOrNull { it.id == id }
+    init {
+        loadData()
+    }
     
-    fun episode(id: String): Episode? = episodes.firstOrNull { it.id == id }
+    private fun loadData() {
+        _categories.clear()
+        _categories.addAll(defaultCategories)
+        
+        _mediaItems.clear()
+        _mediaItems.addAll(generateDefaultMediaItems())
+        
+        _playlists.clear()
+        _playlists.addAll(generateDefaultPlaylists())
+        
+        _episodes.clear()
+        _episodes.addAll(generateDefaultEpisodes())
+    }
     
-    private fun makeDefaultMediaItems(): List<MediaItem> {
-        val categories = defaultCategories
-        return listOf(
-            MediaItem(
-                id = "m1",
-                title = "Midnight Dreams",
-                artist = "Luna Echo",
-                description = "A soothing blend of ambient and electronic music.",
-                duration = 245,
-                artworkUrl = "https://picsum.photos/seed/music1/400/400",
-                mediaUrl = "https://example.com/media/m1.mp3",
-                type = MediaType.MUSIC,
-                category = categories[0],
-                rating = 4.8,
-                playCount = 1234
-            ),
-            MediaItem(
-                id = "m2",
-                title = "City Lights",
-                artist = "Urban Beats",
-                description = "Energetic electronic track.",
-                duration = 198,
-                artworkUrl = "https://picsum.photos/seed/music2/400/400",
-                mediaUrl = "https://example.com/media/m2.mp3",
-                type = MediaType.MUSIC,
-                category = categories[0],
-                rating = 4.6,
-                playCount = 856,
-                isFavorite = true
-            ),
-            MediaItem(
-                id = "p1",
-                title = "Tech Talk Weekly",
-                artist = "Tech Insights",
-                description = "Weekly discussions about technology.",
-                duration = 3600,
-                artworkUrl = "https://picsum.photos/seed/podcast1/400/400",
-                mediaUrl = "https://example.com/media/p1.mp3",
-                type = MediaType.PODCAST,
-                category = categories[1],
-                rating = 4.7,
-                playCount = 890
-            )
-        )
+    private fun generateDefaultMediaItems(): List<MediaItem> {
+        val items = mutableListOf<MediaItem>()
+        val now = System.currentTimeMillis()
+        
+        defaultCategories.forEachIndexed { index, category ->
+            repeat(5) { itemIndex ->
+                items.add(
+                    MediaItem(
+                        id = "${category.id}_item_$itemIndex",
+                        title = "Sample ${category.name} Item ${itemIndex + 1}",
+                        artist = "Artist ${itemIndex + 1}",
+                        description = "Description for ${category.name} item ${itemIndex + 1}",
+                        duration = (180 + itemIndex * 60).toLong(),
+                        mediaUrl = "https://example.com/media/${category.id}_$itemIndex.mp3",
+                        type = when (category.name) {
+                            "Music" -> MediaType.MUSIC
+                            "Podcasts" -> MediaType.PODCAST
+                            "Audiobooks" -> MediaType.AUDIO
+                            "Videos" -> MediaType.VIDEO
+                            "Articles" -> MediaType.ARTICLE
+                            "Recipes" -> MediaType.RECIPE
+                            else -> MediaType.AUDIO
+                        },
+                        category = category,
+                        releaseDate = now - (itemIndex * 86400000L),
+                        rating = 4.0 + (itemIndex * 0.2),
+                        playCount = itemIndex * 10,
+                        isFavorite = itemIndex == 0
+                    )
+                )
+            }
+        }
+        return items
     }
     
-    private fun makeDefaultPlaylists(): List<Playlist> {
+    private fun generateDefaultPlaylists(): List<Playlist> {
         val now = System.currentTimeMillis()
         return listOf(
             Playlist(
-                id = "pl1",
+                id = "playlist_1",
                 name = "My Favorites",
-                description = "A collection of my favorite tracks",
-                artworkUrl = mediaItems.firstOrNull()?.artworkUrl,
-                items = mediaItems.take(5),
+                description = "A collection of favorite tracks",
+                items = _mediaItems.take(10),
                 createdAt = now,
                 updatedAt = now,
-                isPublic = false,
-                playCount = 45
+                playCount = 42
             ),
             Playlist(
-                id = "pl2",
-                name = "Workout Mix",
-                description = "High-energy tracks for your workout",
-                artworkUrl = mediaItems.firstOrNull()?.artworkUrl,
-                items = mediaItems.filter { it.type == MediaType.MUSIC }.take(8),
-                createdAt = now - 86400000,
-                updatedAt = now - 3600000,
-                isPublic = true,
-                playCount = 123
+                id = "playlist_2",
+                name = "Recently Played",
+                description = "Recently played media",
+                items = _mediaItems.drop(5).take(8),
+                createdAt = now - 86400000L,
+                updatedAt = now - 3600000L,
+                playCount = 28
             )
         )
     }
     
-    private fun makeDefaultEpisodes(): List<Episode> {
+    private fun generateDefaultEpisodes(): List<Episode> {
         val now = System.currentTimeMillis()
         return listOf(
             Episode(
-                id = "e1",
-                title = "The Future of AI",
-                description = "Exploring how AI is shaping our world.",
-                duration = 3600,
-                artworkUrl = "https://picsum.photos/seed/episode1/400/400",
-                mediaUrl = "https://example.com/media/e1.mp3",
-                seriesId = "s1",
-                seriesName = "Tech Talk Weekly",
+                id = "episode_1",
+                title = "Episode 1: Introduction",
+                description = "First episode of the series",
+                duration = 3600L,
+                mediaUrl = "https://example.com/episodes/ep1.mp3",
+                seriesId = "series_1",
+                seriesName = "Sample Podcast Series",
                 episodeNumber = 1,
                 seasonNumber = 1,
-                releaseDate = now - 604800000,
-                chapters = listOf(
-                    Chapter(id = "c1", title = "Introduction", startTime = 0, endTime = 300),
-                    Chapter(id = "c2", title = "Current State", startTime = 300, endTime = 1800)
-                ),
-                playCount = 234
+                releaseDate = now - 86400000L,
+                playCount = 15
+            ),
+            Episode(
+                id = "episode_2",
+                title = "Episode 2: Deep Dive",
+                description = "Second episode exploring topics",
+                duration = 4200L,
+                mediaUrl = "https://example.com/episodes/ep2.mp3",
+                seriesId = "series_1",
+                seriesName = "Sample Podcast Series",
+                episodeNumber = 2,
+                seasonNumber = 1,
+                releaseDate = now - 172800000L,
+                playCount = 8
             )
         )
     }
+    
+    // MARK: - CRUD Operations - Playlists
+    
+    override fun addPlaylist(playlist: Playlist) {
+        _playlists.add(playlist)
+    }
+    
+    override fun updatePlaylist(playlist: Playlist) {
+        val index = _playlists.indexOfFirst { it.id == playlist.id }
+        if (index >= 0) {
+            _playlists[index] = playlist
+        }
+    }
+    
+    override fun deletePlaylist(id: String) {
+        _playlists.removeAll { it.id == id }
+    }
+    
+    override fun addToPlaylist(playlistId: String, item: MediaItem) {
+        val playlist = _playlists.find { it.id == playlistId } ?: return
+        val updatedItems = playlist.items + item
+        val updated = playlist.copy(
+            items = updatedItems,
+            updatedAt = System.currentTimeMillis()
+        )
+        updatePlaylist(updated)
+    }
+    
+    override fun removeFromPlaylist(playlistId: String, itemId: String) {
+        val playlist = _playlists.find { it.id == playlistId } ?: return
+        val updatedItems = playlist.items.filter { it.id != itemId }
+        val updated = playlist.copy(
+            items = updatedItems,
+            updatedAt = System.currentTimeMillis()
+        )
+        updatePlaylist(updated)
+    }
+    
+    override fun reorderPlaylist(playlistId: String, from: Int, to: Int) {
+        val playlist = _playlists.find { it.id == playlistId } ?: return
+        val items = playlist.items.toMutableList()
+        if (from < items.size && to < items.size) {
+            val item = items.removeAt(from)
+            items.add(to, item)
+            val updated = playlist.copy(
+                items = items,
+                updatedAt = System.currentTimeMillis()
+            )
+            updatePlaylist(updated)
+        }
+    }
+    
+    // MARK: - CRUD Operations - Favorites
+    
+    override fun toggleFavorite(itemId: String) {
+        if (_favorites.contains(itemId)) {
+            _favorites.remove(itemId)
+        } else {
+            _favorites.add(itemId)
+        }
+        // Update media item favorite status
+        val index = _mediaItems.indexOfFirst { it.id == itemId }
+        if (index >= 0) {
+            val item = _mediaItems[index]
+            _mediaItems[index] = item.copy(isFavorite = !item.isFavorite)
+        }
+    }
+    
+    override fun isFavorite(itemId: String): Boolean {
+        return _favorites.contains(itemId)
+    }
+    
+    // MARK: - CRUD Operations - History
+    
+    override fun addToHistory(item: MediaItem, progress: Long) {
+        val existingIndex = _playbackHistory.indexOfFirst { it.mediaItem.id == item.id }
+        val historyItem = PlaybackHistoryItem(
+            id = UUID.randomUUID().toString(),
+            mediaItem = item,
+            lastPlayedAt = System.currentTimeMillis(),
+            progress = progress,
+            completed = progress >= item.duration * 0.9
+        )
+        if (existingIndex >= 0) {
+            _playbackHistory[existingIndex] = historyItem
+        } else {
+            _playbackHistory.add(0, historyItem)
+        }
+        // Keep only last 50 items
+        if (_playbackHistory.size > 50) {
+            _playbackHistory.removeAt(_playbackHistory.size - 1)
+        }
+    }
+    
+    override fun updateHistoryProgress(itemId: String, progress: Long) {
+        val index = _playbackHistory.indexOfFirst { it.mediaItem.id == itemId }
+        if (index >= 0) {
+            val historyItem = _playbackHistory[index]
+            val item = historyItem.mediaItem
+            _playbackHistory[index] = historyItem.copy(
+                progress = progress,
+                lastPlayedAt = System.currentTimeMillis(),
+                completed = progress >= item.duration * 0.9
+            )
+        }
+    }
+    
+    // MARK: - Query Methods
+    
+    override fun mediaItem(id: String): MediaItem? {
+        return _mediaItems.find { it.id == id }
+    }
+    
+    override fun mediaItems(category: MediaCategory): List<MediaItem> {
+        return _mediaItems.filter { it.category.id == category.id }
+    }
+    
+    override fun searchMediaItems(query: String): List<MediaItem> {
+        if (query.isBlank()) return _mediaItems
+        val lowerQuery = query.lowercase()
+        return _mediaItems.filter {
+            it.title.lowercase().contains(lowerQuery) ||
+            it.artist.lowercase().contains(lowerQuery) ||
+            it.description.lowercase().contains(lowerQuery) ||
+            it.tags?.any { tag -> tag.lowercase().contains(lowerQuery) } == true
+        }
+    }
+    
+    override fun featuredItems(): List<MediaItem> {
+        return _mediaItems.filter { (it.rating ?: 0.0) >= 4.5 }.take(10)
+    }
+    
+    override fun recentlyPlayed(): List<MediaItem> {
+        return _playbackHistory.take(10).map { it.mediaItem }
+    }
+    
+    override fun popularPlaylists(): List<Playlist> {
+        return _playlists.sortedByDescending { it.playCount }.take(5)
+    }
+    
+    override fun playlist(id: String): Playlist? {
+        return _playlists.find { it.id == id }
+    }
+    
+    override fun episode(id: String): Episode? {
+        return _episodes.find { it.id == id }
+    }
+    
+    override fun episodes(seriesId: String): List<Episode> {
+        return _episodes.filter { it.seriesId == seriesId }
+            .sortedByDescending { it.releaseDate }
+    }
+    
+    // MARK: - Reset
+    
+    override fun reset() {
+        loadData()
+        _favorites.clear()
+        _playbackHistory.clear()
+    }
 }

package/templates/android/MediaTemplate/app/src/test/kotlin/com/appship/media/DataRepositoryTest.kt

@@ -0,0 +1,41 @@
+package com.appship.media
+
+import com.appship.media.data.DataRepository
+import com.appship.media.data.DataSourceResolver
+import com.appship.media.mock.MockDataProvider
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Tests that MockDataProvider implements DataRepository and that
+ * DataSourceResolver returns the correct implementation.
+ */
+class DataRepositoryTest {
+
+    private lateinit var repo: DataRepository
+
+    @Before
+    fun setUp() {
+        repo = MockDataProvider
+    }
+
+    // MARK: DataRepository Interface Conformance
+
+    @Test
+    fun testMockDataProviderImplementsDataRepository() {
+        assertTrue("MockDataProvider should implement DataRepository", MockDataProvider is DataRepository)
+    }
+
+    @Test
+    fun testRepositoryLoadData() {
+        assertTrue("mediaItems should not be empty", repo.mediaItems.isNotEmpty())
+        assertTrue("categories should not be empty", repo.categories.isNotEmpty())
+    }
+
+    @Test
+    fun testDataSourceResolverReturnsMock() {
+        val resolved = DataSourceResolver.repository
+        assertNotNull("DataSourceResolver should return a non-null repository", resolved)
+    }
+}

package/templates/android/MediaTemplate/gradle/libs.versions.toml

@@ -16,6 +16,7 @@ ksp = "1.9.22-1.0.17"
 coil = "2.5.0"
 gson = "2.10.1"
 coroutinesTest = "1.7.3"
+room = "2.6.1"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -42,6 +43,9 @@ hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.r
 coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }
 gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
 kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesTest" }
+room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
+room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
+room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }