@shaykec/app-agent 1.0.5 → 1.0.6

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

@@ -0,0 +1,76 @@
+package com.appship.media.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.media.data.models.Chapter
+import com.appship.media.data.models.Episode
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.util.Date
+
+/**
+ * Room entity for Episode persistence.
+ */
+@Entity(tableName = "episodes")
+data class EpisodeEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String = "",
+    val duration: Long = 0L,
+    val artworkUrl: String? = null,
+    val mediaUrl: String = "",
+    val seriesId: String = "",
+    val seriesName: String = "",
+    val episodeNumber: Int? = null,
+    val seasonNumber: Int? = null,
+    val releaseDate: Long = System.currentTimeMillis(),
+    val chaptersJson: String? = null,
+    val playCount: Int = 0,
+    val isDownloaded: Boolean = false
+) {
+    fun toEpisode(): Episode = Episode(
+        id = id,
+        title = title,
+        description = description,
+        duration = duration,
+        artworkUrl = artworkUrl,
+        mediaUrl = mediaUrl,
+        seriesId = seriesId,
+        seriesName = seriesName,
+        episodeNumber = episodeNumber,
+        seasonNumber = seasonNumber,
+        releaseDate = releaseDate,
+        chapters = parseChapters(),
+        playCount = playCount,
+        isDownloaded = isDownloaded
+    )
+
+    private fun parseChapters(): List<Chapter>? {
+        return try {
+            chaptersJson?.let {
+                Gson().fromJson(it, object : TypeToken<List<Chapter>>() {}.type)
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    companion object {
+        fun fromEpisode(episode: Episode): EpisodeEntity = EpisodeEntity(
+            id = episode.id,
+            title = episode.title,
+            description = episode.description,
+            duration = episode.duration,
+            artworkUrl = episode.artworkUrl,
+            mediaUrl = episode.mediaUrl,
+            seriesId = episode.seriesId,
+            seriesName = episode.seriesName,
+            episodeNumber = episode.episodeNumber,
+            seasonNumber = episode.seasonNumber,
+            releaseDate = episode.releaseDate,
+            chaptersJson = episode.chapters?.let { Gson().toJson(it) },
+            playCount = episode.playCount,
+            isDownloaded = episode.isDownloaded
+        )
+    }
+}

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

@@ -0,0 +1,335 @@
+package com.appship.media.data.local
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.appship.media.AppConfig
+import com.appship.media.data.DataRepository
+import com.appship.media.data.models.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores media items, categories, playlists, episodes, and playback history in a local SQLite database.
+ * Pre-seeds default categories from AppConfig on first launch.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val prefs: SharedPreferences,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _categories = MutableStateFlow<List<MediaCategory>>(emptyList())
+    override val categories: List<MediaCategory> get() = _categories.value
+
+    private val _mediaItems = MutableStateFlow<List<MediaItem>>(emptyList())
+    override val mediaItems: List<MediaItem> get() = _mediaItems.value
+
+    private val _playlists = MutableStateFlow<List<Playlist>>(emptyList())
+    override val playlists: List<Playlist> get() = _playlists.value
+
+    private val _episodes = MutableStateFlow<List<Episode>>(emptyList())
+    override val episodes: List<Episode> get() = _episodes.value
+
+    private val _playbackHistory = MutableStateFlow<List<PlaybackHistoryItem>>(emptyList())
+    override val playbackHistory: List<PlaybackHistoryItem> get() = _playbackHistory.value
+
+    private val _favorites = MutableStateFlow<Set<String>>(emptySet())
+    override val favorites: Set<String> get() = _favorites.value
+
+    fun loadData() {
+        scope.launch {
+            // Seed categories on first launch
+            if (dao.categoryCount() == 0) {
+                seedDefaultCategories()
+            }
+            refreshCategories()
+            refreshMediaItems()
+            refreshPlaylists()
+            refreshEpisodes()
+            refreshPlaybackHistory()
+            loadFavorites()
+        }
+    }
+
+    override fun addPlaylist(playlist: Playlist) {
+        scope.launch {
+            dao.insertPlaylist(PlaylistEntity.fromPlaylist(playlist))
+            refreshPlaylists()
+        }
+    }
+
+    override fun updatePlaylist(playlist: Playlist) {
+        scope.launch {
+            dao.updatePlaylist(PlaylistEntity.fromPlaylist(playlist))
+            refreshPlaylists()
+        }
+    }
+
+    override fun deletePlaylist(id: String) {
+        scope.launch {
+            dao.getPlaylistById(id)?.let { dao.deletePlaylist(it) }
+            refreshPlaylists()
+        }
+    }
+
+    override fun addToPlaylist(playlistId: String, item: MediaItem) {
+        scope.launch {
+            val playlistEntity = dao.getPlaylistById(playlistId) ?: return@launch
+            val playlist = playlistEntity.toPlaylist(_mediaItems.value)
+            val updatedItems = playlist.items + item
+            val updated = playlist.copy(items = updatedItems, updatedAt = System.currentTimeMillis())
+            dao.updatePlaylist(PlaylistEntity.fromPlaylist(updated))
+            refreshPlaylists()
+        }
+    }
+
+    override fun removeFromPlaylist(playlistId: String, itemId: String) {
+        scope.launch {
+            val playlistEntity = dao.getPlaylistById(playlistId) ?: return@launch
+            val playlist = playlistEntity.toPlaylist(_mediaItems.value)
+            val updatedItems = playlist.items.filter { it.id != itemId }
+            val updated = playlist.copy(items = updatedItems, updatedAt = System.currentTimeMillis())
+            dao.updatePlaylist(PlaylistEntity.fromPlaylist(updated))
+            refreshPlaylists()
+        }
+    }
+
+    override fun reorderPlaylist(playlistId: String, from: Int, to: Int) {
+        scope.launch {
+            val playlistEntity = dao.getPlaylistById(playlistId) ?: return@launch
+            val playlist = playlistEntity.toPlaylist(_mediaItems.value)
+            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())
+                dao.updatePlaylist(PlaylistEntity.fromPlaylist(updated))
+                refreshPlaylists()
+            }
+        }
+    }
+
+    override fun toggleFavorite(itemId: String) {
+        scope.launch {
+            val currentFavorites = _favorites.value.toMutableSet()
+            if (currentFavorites.contains(itemId)) {
+                currentFavorites.remove(itemId)
+            } else {
+                currentFavorites.add(itemId)
+            }
+            _favorites.value = currentFavorites
+            saveFavorites()
+
+            dao.getMediaItemById(itemId)?.let { entity ->
+                val item = entity.toMediaItem(
+                    _categories.value.firstOrNull { it.id == entity.categoryId }
+                        ?: return@launch
+                )
+                val updated = item.copy(isFavorite = !item.isFavorite)
+                dao.updateMediaItem(MediaItemEntity.fromMediaItem(updated))
+                refreshMediaItems()
+            }
+        }
+    }
+
+    override fun isFavorite(itemId: String): Boolean {
+        return _favorites.value.contains(itemId)
+    }
+
+    override fun addToHistory(item: MediaItem, progress: Long) {
+        scope.launch {
+            // Remove existing history for this item
+            val existing = dao.getAllPlaybackHistory().firstOrNull {
+                it.toPlaybackHistoryItem()?.mediaItem?.id == item.id
+            }
+            existing?.let { dao.deletePlaybackHistory(it) }
+
+            val historyItem = PlaybackHistoryItem(
+                id = java.util.UUID.randomUUID().toString(),
+                mediaItem = item,
+                lastPlayedAt = System.currentTimeMillis(),
+                progress = progress,
+                completed = progress >= item.duration * 0.9
+            )
+            dao.insertPlaybackHistory(PlaybackHistoryEntity.fromPlaybackHistoryItem(historyItem))
+            refreshPlaybackHistory()
+        }
+    }
+
+    override fun updateHistoryProgress(itemId: String, progress: Long) {
+        scope.launch {
+            val existing = dao.getAllPlaybackHistory().firstOrNull {
+                it.toPlaybackHistoryItem()?.mediaItem?.id == itemId
+            } ?: return@launch
+
+            val historyItem = existing.toPlaybackHistoryItem() ?: return@launch
+            val updated = historyItem.copy(
+                lastPlayedAt = System.currentTimeMillis(),
+                progress = progress,
+                completed = progress >= historyItem.mediaItem.duration * 0.9
+            )
+            dao.updatePlaybackHistory(PlaybackHistoryEntity.fromPlaybackHistoryItem(updated))
+            refreshPlaybackHistory()
+        }
+    }
+
+    override fun mediaItem(id: String): MediaItem? {
+        return _mediaItems.value.firstOrNull { it.id == id }
+    }
+
+    override fun mediaItems(category: MediaCategory): List<MediaItem> {
+        return _mediaItems.value.filter { it.category.id == category.id }
+    }
+
+    override fun searchMediaItems(query: String): List<MediaItem> {
+        if (query.isBlank()) return _mediaItems.value
+        return _mediaItems.value.filter {
+            it.title.contains(query, ignoreCase = true) ||
+            it.artist.contains(query, ignoreCase = true) ||
+            it.description.contains(query, ignoreCase = true) ||
+            (it.tags?.any { tag -> tag.contains(query, ignoreCase = true) } == true)
+        }
+    }
+
+    override fun featuredItems(): List<MediaItem> {
+        return _mediaItems.value.filter { (it.rating ?: 0.0) >= 4.5 }.take(10)
+    }
+
+    override fun recentlyPlayed(): List<MediaItem> {
+        return _playbackHistory.value.take(10).map { it.mediaItem }
+    }
+
+    override fun popularPlaylists(): List<Playlist> {
+        return _playlists.value.sortedByDescending { it.playCount }.take(5)
+    }
+
+    override fun playlist(id: String): Playlist? {
+        return _playlists.value.firstOrNull { it.id == id }
+    }
+
+    override fun episode(id: String): Episode? {
+        return _episodes.value.firstOrNull { it.id == id }
+    }
+
+    override fun episodes(seriesId: String): List<Episode> {
+        return _episodes.value.filter { it.seriesId == seriesId }
+            .sortedByDescending { it.releaseDate }
+    }
+
+    override fun reset() {
+        scope.launch {
+            // Delete all entities
+            dao.getAllCategories().forEach { dao.deleteCategory(it) }
+            dao.getAllMediaItems().forEach { dao.deleteMediaItem(it) }
+            dao.getAllPlaylists().forEach { dao.deletePlaylist(it) }
+            dao.getAllEpisodes().forEach { dao.deleteEpisode(it) }
+            dao.getAllPlaybackHistory().forEach { dao.deletePlaybackHistory(it) }
+
+            seedDefaultCategories()
+            _favorites.value = emptySet()
+            saveFavorites()
+
+            refreshCategories()
+            refreshMediaItems()
+            refreshPlaylists()
+            refreshEpisodes()
+            refreshPlaybackHistory()
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private suspend fun refreshCategories() {
+        _categories.value = dao.getAllCategories().map { it.toMediaCategory() }
+    }
+
+    private suspend fun refreshMediaItems() {
+        val categoriesMap = _categories.value.associateBy { it.id }
+        _mediaItems.value = dao.getAllMediaItems().mapNotNull { entity ->
+            categoriesMap[entity.categoryId]?.let { entity.toMediaItem(it) }
+        }
+    }
+
+    private suspend fun refreshPlaylists() {
+        _playlists.value = dao.getAllPlaylists().map { it.toPlaylist(_mediaItems.value) }
+    }
+
+    private suspend fun refreshEpisodes() {
+        _episodes.value = dao.getAllEpisodes().map { it.toEpisode() }
+    }
+
+    private suspend fun refreshPlaybackHistory() {
+        _playbackHistory.value = dao.getAllPlaybackHistory()
+            .mapNotNull { it.toPlaybackHistoryItem() }
+            .take(50)
+    }
+
+    private suspend fun seedDefaultCategories() {
+        // Seed from AppConfig categories if available, otherwise use defaults
+        val defaultCategories = listOf(
+            MediaCategory(id = "1", name = "Music", icon = "music_note", itemCount = 0),
+            MediaCategory(id = "2", name = "Podcasts", icon = "mic", itemCount = 0),
+            MediaCategory(id = "3", name = "Audiobooks", icon = "book", itemCount = 0),
+            MediaCategory(id = "4", name = "Videos", icon = "play_circle", itemCount = 0),
+            MediaCategory(id = "5", name = "Articles", icon = "article", itemCount = 0),
+            MediaCategory(id = "6", name = "Recipes", icon = "restaurant_menu", itemCount = 0)
+        )
+        val entities = defaultCategories.map { MediaCategoryEntity.fromMediaCategory(it) }
+        dao.insertCategories(entities)
+    }
+
+    private fun loadFavorites() {
+        val favoritesJson = prefs.getString("favorites", null)
+        if (favoritesJson != null) {
+            try {
+                val gson = com.google.gson.Gson()
+                val type = object : com.google.gson.reflect.TypeToken<Set<String>>() {}.type
+                _favorites.value = gson.fromJson(favoritesJson, type) ?: emptySet()
+            } catch (_: Exception) {
+                _favorites.value = emptySet()
+            }
+        }
+    }
+
+    private fun saveFavorites() {
+        val gson = com.google.gson.Gson()
+        val json = gson.toJson(_favorites.value)
+        prefs.edit().putString("favorites", json).apply()
+    }
+
+    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)
+                        val prefs = context.getSharedPreferences("media_prefs", Context.MODE_PRIVATE)
+                        INSTANCE = LocalStorageProvider(db.appDao(), prefs).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/MediaTemplate/app/src/main/kotlin/com/appship/media/data/local/MediaCategoryEntity.kt

@@ -0,0 +1,39 @@
+package com.appship.media.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.media.data.models.MediaCategory
+
+/**
+ * Room entity for MediaCategory persistence.
+ */
+@Entity(tableName = "media_categories")
+data class MediaCategoryEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val icon: String = "",
+    val image: String? = null,
+    val parentId: String? = null,
+    val itemCount: Int? = null
+) {
+    fun toMediaCategory(): MediaCategory = MediaCategory(
+        id = id,
+        name = name,
+        icon = icon,
+        image = image,
+        parentId = parentId,
+        subcategories = null,
+        itemCount = itemCount
+    )
+
+    companion object {
+        fun fromMediaCategory(category: MediaCategory): MediaCategoryEntity = MediaCategoryEntity(
+            id = category.id,
+            name = category.name,
+            icon = category.icon,
+            image = category.image,
+            parentId = category.parentId,
+            itemCount = category.itemCount
+        )
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.appship.media.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.media.data.models.*
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for MediaItem persistence.
+ */
+@Entity(tableName = "media_items")
+data class MediaItemEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val artist: String = "",
+    val description: String = "",
+    val duration: Long = 0L,
+    val artworkUrl: String? = null,
+    val mediaUrl: String = "",
+    val type: String = "",
+    val categoryId: String = "",
+    val releaseDate: Long? = null,
+    val tagsJson: String? = null,
+    val rating: Double? = null,
+    val playCount: Int = 0,
+    val isFavorite: Boolean = false
+) {
+    fun toMediaItem(category: MediaCategory): MediaItem = MediaItem(
+        id = id,
+        title = title,
+        artist = artist,
+        description = description,
+        duration = duration,
+        artworkUrl = artworkUrl,
+        mediaUrl = mediaUrl,
+        type = MediaType.values().firstOrNull { it.name.equals(type, ignoreCase = true) } ?: MediaType.AUDIO,
+        category = category,
+        releaseDate = releaseDate,
+        tags = parseTags(),
+        rating = rating,
+        playCount = playCount,
+        isFavorite = isFavorite
+    )
+
+    private fun parseTags(): List<String>? {
+        return try {
+            tagsJson?.let {
+                Gson().fromJson(it, object : TypeToken<List<String>>() {}.type)
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    companion object {
+        fun fromMediaItem(item: MediaItem): MediaItemEntity = MediaItemEntity(
+            id = item.id,
+            title = item.title,
+            artist = item.artist,
+            description = item.description,
+            duration = item.duration,
+            artworkUrl = item.artworkUrl,
+            mediaUrl = item.mediaUrl,
+            type = item.type.name,
+            categoryId = item.category.id,
+            releaseDate = item.releaseDate,
+            tagsJson = item.tags?.let { Gson().toJson(it) },
+            rating = item.rating,
+            playCount = item.playCount,
+            isFavorite = item.isFavorite
+        )
+    }
+}

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

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(