Timeline Generation & Caching

User A tweets → write to A's 10,000 followers' timeline caches → tweet immediately readable

User opens app → fetch latest tweets from 500 followed accounts → merge and sort → display

Copy code@Entity(tableName = "timeline")
data class TimelineEntry(
    @PrimaryKey val tweetId: String,
    val authorId: String,
    val authorName: String,
    val authorHandle: String,
    val authorAvatarUrl: String,
    val text: String,
    val mediaUrls: List<String>,
    val likeCount: Int,
    val retweetCount: Int,
    val replyCount: Int,
    val createdAt: Long,
    val fetchedAt: Long = System.currentTimeMillis(),
    // Denormalized for display; accept eventual consistency
    val isLikedByMe: Boolean = false,
    val isRetweetedByMe: Boolean = false
)

@Dao
interface TimelineDao {
    @Query("SELECT * FROM timeline ORDER BY created_at DESC LIMIT 200")
    fun observeTimeline(): Flow<List<TimelineEntry>>

    @Query("DELETE FROM timeline WHERE fetched_at < :cutoff")
    suspend fun evictOlderThan(cutoff: Long)

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(entries: List<TimelineEntry>)
}

Copy codeclass TimelineCacheManager(private val dao: TimelineDao) {

    // Keep only 200 tweets in cache; evict anything older than 1 week
    suspend fun trimCache() {
        val oneWeekAgo = System.currentTimeMillis() - 7 * 24 * 60 * 60 * 1000L
        dao.evictOlderThan(oneWeekAgo)
        // Room Query to keep only top 200 by createdAt
    }

    // Invalidate and refresh on pull-to-refresh
    suspend fun refresh(api: TimelineApi) {
        val fresh = api.getTimeline(cursor = null, count = 50)
        dao.insertAll(fresh.map { it.toEntity() })
        trimCache()
    }
}

Copy code@HiltViewModel
class TimelineViewModel @Inject constructor(
    private val dao: TimelineDao,
    private val api: TimelineApi
) : ViewModel() {

    val timeline: StateFlow<List<TimelineEntry>> = dao.observeTimeline()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    private val _newTweetCount = MutableStateFlow(0)
    val newTweetCount: StateFlow<Int> = _newTweetCount

    private var newestTweetId: String? = null

    init {
        pollForNewTweets()
    }

    private fun pollForNewTweets() = viewModelScope.launch {
        while (isActive) {
            delay(60_000)  // check every minute
            newestTweetId?.let { sinceId ->
                try {
                    val newTweets = api.getTimeline(sinceId = sinceId, count = 10)
                    if (newTweets.isNotEmpty()) {
                        _newTweetCount.value = newTweets.size
                    }
                } catch (e: IOException) {
                    // Ignore; try again next poll
                }
            }
        }
    }

    fun onScrolledToTop(newestId: String) {
        newestTweetId = newestId
        _newTweetCount.value = 0
    }

    fun onRefreshRequested() = viewModelScope.launch {
        _newTweetCount.value = 0
        // Invalidate pager or refresh Room cache
    }
}

Copy codesealed class TimelineItem {
    data class OriginalTweet(val entry: TimelineEntry) : TimelineItem()
    data class Retweet(val retweeter: UserSummary, val original: TimelineEntry) : TimelineItem()
    data class QuoteTweet(val entry: TimelineEntry, val quoted: TimelineEntry) : TimelineItem()
    data class Thread(val tweets: List<TimelineEntry>) : TimelineItem()
}

fun List<TimelineEntry>.toTimelineItems(): List<TimelineItem> {
    return mapNotNull { entry ->
        when {
            entry.retweetedFrom != null -> TimelineItem.Retweet(
                retweeter = entry.author,
                original = findOriginal(entry.retweetedFrom) ?: return@mapNotNull null
            )
            entry.quotedTweetId != null -> TimelineItem.QuoteTweet(
                entry = entry,
                quoted = findOriginal(entry.quotedTweetId) ?: return@mapNotNull null
            )
            else -> TimelineItem.OriginalTweet(entry)
        }
    }
}