@shaykec/app-agent 1.0.5 → 1.0.6

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

@@ -1,78 +1,307 @@
-package com.appship.game.mock
+package com.appship.media.mock
 
-import android.content.Context
-import com.appship.game.AppConfig
-import com.appship.game.data.*
+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 : DataRepository {
-    // Seed Data
-    val defaultLevels: List<Level> = listOf(
-        Level("l1", 1, "Getting Started", "Learn the basics", Level.Difficulty.EASY, 100, true, Date()),
-        Level("l2", 2, "First Challenge", "Test your skills", Level.Difficulty.EASY, 200, true, Date()),
-        Level("l3", 3, "Building Momentum", "Keep the streak going", Level.Difficulty.EASY, 300, true, Date()),
-        Level("l4", 4, "Rising Star", "You're getting better!", Level.Difficulty.MEDIUM, 500, true, Date()),
-        Level("l5", 5, "Halfway There", "You've reached the midpoint", Level.Difficulty.MEDIUM, 750, true, Date()),
-        Level("l6", 6, "Skill Mastery", "Show what you've learned", Level.Difficulty.MEDIUM, 1000, true, Date()),
-        Level("l7", 7, "The Challenge", "Things are getting serious", Level.Difficulty.HARD, 1500, true, Date()),
-        Level("l8", 8, "Elite Player", "Only the best reach here", Level.Difficulty.HARD, 2000, true, Date()),
-        Level("l9", 9, "Master Level", "Prove your mastery", Level.Difficulty.HARD, 2500, true, Date()),
-        Level("l10", 10, "Legendary", "The ultimate test", Level.Difficulty.EXPERT, 3000, true, Date()),
-        Level("l11", 11, "Beyond Limits", "Push beyond your limits", Level.Difficulty.EXPERT, 3500, false, Date()),
-        Level("l12", 12, "Champion's Path", "Walk the path of champions", Level.Difficulty.EXPERT, 4000, false, Date())
-    )
     
-    val defaultAchievements: List<Achievement> = listOf(
-        Achievement("a1", "First Steps", "Complete your first level", "star", false, null, Achievement.Rarity.COMMON),
-        Achievement("a2", "Score Master", "Reach a score of 1000 points", "emoji_events", false, null, Achievement.Rarity.COMMON),
-        Achievement("a3", "Level 5", "Complete level 5", "looks_5", false, null, Achievement.Rarity.RARE),
-        Achievement("a4", "Perfect Game", "Complete a level without losing a life", "check_circle", false, null, Achievement.Rarity.RARE),
-        Achievement("a5", "Speed Demon", "Complete a level in under 2 minutes", "bolt", false, null, Achievement.Rarity.EPIC),
-        Achievement("a6", "Collector", "Purchase 5 items from the shop", "shopping_bag", false, null, Achievement.Rarity.EPIC),
-        Achievement("a7", "Champion", "Reach the top 10 on the leaderboard", "workspace_premium", false, null, Achievement.Rarity.LEGENDARY),
-        Achievement("a8", "Unstoppable", "Complete 10 levels in a row", "local_fire_department", false, null, Achievement.Rarity.LEGENDARY),
-        Achievement("a9", "Daily Warrior", "Complete 7 daily challenges", "calendar_today", false, null, Achievement.Rarity.RARE),
-        Achievement("a10", "Millionaire", "Earn 1,000,000 coins", "attach_money", false, null, Achievement.Rarity.LEGENDARY)
+    // MARK: - Default Seed Data
+    private val defaultCategories = listOf(
+        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 defaultShopItems: List<ShopItem> = listOf(
-        ShopItem("s1", "Extra Life", "Get one additional life", 50, ShopItem.CurrencyType.COINS, "favorite", false),
-        ShopItem("s2", "Score Multiplier", "Double your score for one game", 100, ShopItem.CurrencyType.COINS, "multiply", false),
-        ShopItem("s3", "Time Freeze", "Freeze the timer for 30 seconds", 75, ShopItem.CurrencyType.COINS, "schedule", false),
-        ShopItem("s4", "Power Boost", "Start with 2x power for 3 levels", 5, ShopItem.CurrencyType.GEMS, "bolt", false),
-        ShopItem("s5", "Lucky Charm", "Increase coin rewards by 50%", 10, ShopItem.CurrencyType.GEMS, "stars", false),
-        ShopItem("s6", "Premium Pack", "Get 500 coins + 10 gems", 3, ShopItem.CurrencyType.GEMS, "card_giftcard", false),
-        ShopItem("s7", "Unlock All Levels", "Unlock all levels instantly", 20, ShopItem.CurrencyType.GEMS, "lock_open", false)
-    )
+    private val _categories = mutableListOf<MediaCategory>()
+    override val categories: List<MediaCategory> get() = _categories
     
-    fun makeDefaultLeaderboard(): List<LeaderboardEntry> {
-        val names = listOf("Champion", "ProGamer", "ElitePlayer", "MasterMind", "SpeedRunner", "TopScorer", "GameKing", "Victory", "Winner", "Hero")
-        return names.mapIndexed { index, name ->
-            val score = 10000 - (index * 500)
-            val level = maxOf(1, 10 - index)
-            LeaderboardEntry(
-                "lb${index + 1}",
-                index + 1,
-                Player("p${index + 1}", name, null, level, score.toLong(), com.appship.game.data.Currency(1000 - index * 50, 50 - index * 2), emptyList(), index + 1, level * 1000, 5, Date()),
-                score,
-                level
-            )
-        }
+    private val _mediaItems = mutableListOf<MediaItem>()
+    override val mediaItems: List<MediaItem> get() = _mediaItems
+    
+    private val _playlists = mutableListOf<Playlist>()
+    override val playlists: List<Playlist> get() = _playlists
+    
+    private val _episodes = mutableListOf<Episode>()
+    override val episodes: List<Episode> get() = _episodes
+    
+    private val _playbackHistory = mutableListOf<PlaybackHistoryItem>()
+    override val playbackHistory: List<PlaybackHistoryItem> get() = _playbackHistory
+    
+    private val _favorites = mutableSetOf<String>()
+    override val favorites: Set<String> get() = _favorites
+    
+    init {
+        loadData()
     }
     
-    fun makeDefaultDailyChallenges(): List<DailyChallenge> {
-        val tomorrow = Calendar.getInstance().apply {
-            add(Calendar.DAY_OF_YEAR, 1)
-            set(Calendar.HOUR_OF_DAY, 0)
-            set(Calendar.MINUTE, 0)
-            set(Calendar.SECOND, 0)
-        }.time
+    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 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 generateDefaultPlaylists(): List<Playlist> {
+        val now = System.currentTimeMillis()
         return listOf(
-            DailyChallenge("dc1", "Score 500 Points", "Score at least 500 points in a single game", ChallengeReward(50, 0, 100), false, tomorrow, 0, 500),
-            DailyChallenge("dc2", "Complete 3 Levels", "Complete 3 levels today", ChallengeReward(75, 2, 150), false, tomorrow, 0, 3),
-            DailyChallenge("dc3", "Reach Level 5", "Play and complete level 5", ChallengeReward(100, 5, 200), false, tomorrow, 0, 1)
+            Playlist(
+                id = "playlist_1",
+                name = "My Favorites",
+                description = "A collection of favorite tracks",
+                items = _mediaItems.take(10),
+                createdAt = now,
+                updatedAt = now,
+                playCount = 42
+            ),
+            Playlist(
+                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 generateDefaultEpisodes(): List<Episode> {
+        val now = System.currentTimeMillis()
+        return listOf(
+            Episode(
+                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 - 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" }

package/templates/android/MediaTemplate/tests/01_launch_home.yaml

@@ -1,19 +1,29 @@
 appId: ${APP_PACKAGE_NAME}
 ---
+- clearState
 - launchApp
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
 - tapOn:
-    text: "Skip"
+    id: "onboarding_skip_button"
     optional: true
 - tapOn:
-    text: "Get Started"
+    id: "onboarding_get_started_button"
     optional: true
 - assertVisible:
-    id: "tab_bar_home"
+    - "Home"
+    - id: "home_search_bar"
 - assertVisible:
-    id: "home_search_bar"
-- assertVisible:
-    text: "Featured"
+    id: "home_featured_0_card"
+    optional: true
 - assertVisible:
-    text: "Categories"
+    id: "home_category_0_card"
+    optional: true
 - assertVisible:
-    id: "home_featured_0_card"
+    id: "home_playlist_0_card"
+    optional: true
+- assertNotVisible:
+    id: "home_empty_state"

package/templates/android/MediaTemplate/tests/02_tab_navigation.yaml

@@ -1,17 +1,40 @@
 appId: ${APP_PACKAGE_NAME}
 ---
+- clearState
 - launchApp
-- assertVisible:
-    id: "tab_bar_home"
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
+- tapOn:
+    id: "onboarding_skip_button"
+    optional: true
 - tapOn:
-    id: "tab_bar_browse"
+    id: "onboarding_get_started_button"
+    optional: true
+- assertVisible:
+    - "Home"
+    - id: "home_featured_0_card"
+    optional: true
+- tapOn: "Browse"
 - assertVisible:
     id: "browse_category_0_card"
-- tapOn:
-    id: "tab_bar_library"
+    optional: true
 - assertVisible:
-    text: "Library"
-- tapOn:
-    id: "tab_bar_settings"
+    id: "browse_empty_state"
+    optional: true
+- tapOn: "Library"
+- assertVisible:
+    id: "library_playlist_0_card"
+    optional: true
+- assertVisible:
+    id: "library_empty_state"
+    optional: true
+- tapOn: "Settings"
+- assertVisible:
+    - "Settings"
+- tapOn: "Home"
 - assertVisible:
-    text: "Settings"
+    - "Home"
+    - id: "home_search_bar"

package/templates/android/MediaTemplate/tests/05_search.yaml

@@ -1,14 +1,41 @@
 appId: ${APP_PACKAGE_NAME}
 ---
+- clearState
 - launchApp
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
+- tapOn:
+    id: "onboarding_skip_button"
+    optional: true
+- tapOn:
+    id: "onboarding_get_started_button"
+    optional: true
 - tapOn:
     id: "home_search_bar"
 - assertVisible:
     id: "search_field"
-- inputText: "music"
+- inputText: "Music"
 - assertVisible:
     id: "search_result_0_card"
+    optional: true
+- assertVisible:
+    id: "search_empty_state"
+    optional: true
 - tapOn:
     id: "search_result_0_card"
+    optional: true
 - assertVisible:
     id: "detail_play_button"
+    optional: true
+- tapOn:
+    text: "Back"
+    optional: true
+- clearText:
+    id: "search_field"
+- inputText: "NonexistentMedia12345"
+- assertVisible:
+    id: "search_empty_state"
+    optional: true

package/templates/android/MediaTemplate/tests/06_playlist_management.yaml

@@ -0,0 +1,37 @@
+appId: ${APP_PACKAGE_NAME}
+---
+- clearState
+- launchApp
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
+- tapOn:
+    id: "onboarding_skip_button"
+    optional: true
+- tapOn:
+    id: "onboarding_get_started_button"
+    optional: true
+- tapOn: "Library"
+- assertVisible:
+    id: "library_playlist_0_card"
+    optional: true
+- assertVisible:
+    id: "library_empty_state"
+    optional: true
+- tapOn:
+    id: "library_playlist_0_card"
+    optional: true
+- assertVisible:
+    - "Playlist"
+- tapOn: "Home"
+- tapOn:
+    id: "home_featured_0_card"
+    optional: true
+- tapOn:
+    id: "detail_add_to_playlist_button"
+    optional: true
+- assertVisible:
+    id: "library_playlist_0_card"
+    optional: true

package/templates/android/MediaTemplate/tests/07_downloads_settings.yaml

@@ -0,0 +1,34 @@
+appId: ${APP_PACKAGE_NAME}
+---
+- clearState
+- launchApp
+- extendedWaitUntil:
+    visible:
+      - "Home"
+      - id: "home_search_bar"
+    timeout: 10000
+- tapOn:
+    id: "onboarding_skip_button"
+    optional: true
+- tapOn:
+    id: "onboarding_get_started_button"
+    optional: true
+- tapOn: "Settings"
+- assertVisible:
+    - "Settings"
+- swipe:
+    direction: DOWN
+- tapOn:
+    text: "Manage Downloads"
+    optional: true
+- assertVisible:
+    id: "downloads_item_0_card"
+    optional: true
+- assertVisible:
+    id: "downloads_empty_state"
+    optional: true
+- tapOn:
+    text: "Back"
+    optional: true
+- assertVisible:
+    - "Settings"