You do not need to use Rome and other libraries to parse RSS with Kotlin: With Android's built-in XmlPullParser and coroutine, you can realize a lightweight and easy-to-maintain parser; 2. The steps include adding network permissions, using HttpURLConnection or Retrofit to obtain RSS streams, using XmlPullParser to parse into a data class list, and running in a background thread to avoid blocking the UI; 3. Pay attention to handling CDATA, network exceptions, cache results, and test real RSS sources. Consider introducing a dedicated library when the structure is complex.

If you're building an Android app that needs to fetch and display content from RSS feeds using Kotlin, here's a practical and lightweight approach — no need for heavy libraries unless you really want them.

? Why Not Use a Library Like Rome?

You can use libraries like Rome (Java), but for basic RSS parsing in Android, it often adds unnecessary complexity. With Kotlin's clean syntax and Android's built-in tools ( XmlPullParser ), you can write a parser that's easy to understand, debug, and maintain.

1. Add Internet Permission

First, make sure your AndroidManifest.xml includes:

 <uses-permission android:name="android.permission.INTERNET" />

2. Fetch RSS Feed with Retrofit or HTTPUrlConnection

You can use either:

Option A: Simple with HttpURLConnection (no extra dependency)

 private fun fetchRss(urlString: String): InputStream? {
    val url = URL(urlString)
    val connection = url.openConnection() as HttpURLConnection
    connection.requestMethod = "GET"
    connection.connectTimeout = 5000
    connection.readTimeout = 5000

    return if (connection.responseCode == 200) {
        connection.inputStream
    } else {
        null
    }
}

Option B: Use Retrofit (recommended for multiple feeds/APIs)

Add Retrofit to build.gradle :

 implementation "com.squareup.retrofit2:retrofit:2.9.0"

Then create a simple service:

 interface RssService {
    @GET
    suspend fun getFeed(@Url url: String): Response<ResponseBody>
}

3. Parse RSS XML with XmlPullParser

Create a data class:

 data class RssItem(
    val title: String = "",
    val link: String = "",
    val description: String = "",
    val pubDate: String = ""
)

Now parse:

 fun parseRss(inputStream: InputStream): List<RssItem> {
    val parser = Xml.newPullParser()
    parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false)
    parser.setInput(inputStream, null)
    parser.nextTag()

    val items = mutableListOf<RssItem>()
    var title = ""
    var link = ""
    var description = ""
    var pubDate = ""

    while (parser.next() != XmlPullParser.END_TAG) {
        if (parser.eventType != XmlPullParser.START_TAG) continue
        When (parser.name) {
            "item" -> {
                // Reset for each item
                title = ""
                link = ""
                description = ""
                pubDate = ""
            }
            "title" -> title = parser.nextText()
            "link" -> link = parser.nextText()
            "description" -> description = parser.nextText()
            "pubDate" -> pubDate = parser.nextText()
            "guid", "category", "author" -> parser.nextText() // ignore or store if needed
            else -> skip(parser)
        }

        if (parser.name == "item" && parser.eventType == XmlPullParser.END_TAG) {
            items.add(RssItem(title, link, description, pubDate))
        }
    }
    Return items
}

private fun skip(parser: XmlPullParser) {
    if (parser.eventType != XmlPullParser.START_TAG) {
        throw IllegalStateException()
    }
    var depth = 1
    while (depth != 0) {
        When (parser.next()) {
            XmlPullParser.END_TAG -> depth--
            XmlPullParser.START_TAG -> depth  
        }
    }
}

? This parser assumes basic RSS 2.0 structure ( <rss><channel><item>...</item></channel></rss> ). If your feed is nested differently, adjust the logic accordingly.

4. Run on Background Thread

Use CoroutineScope(Dispatchers.IO) :

 lifecycleScope.launch(Dispatchers.IO) {
    val inputStream = fetchRss("https://example.com/feed")
    if (inputStream != null) {
        val items = parseRss(inputStream)
        withContext(Dispatchers.Main) {
            // Update RecyclerView or UI
            adapter.submitList(items)
        }
    }
}

? Tips & Gotchas

• Some RSS feeds have CDATA in <description></description> — nextText() handles it fine.
• Always handle network errors ( IOException , timeouts).
• Cache parsed results (Room or simple file) to avoid refetching.
• Test with real-world feeds like BBC, NPR, or Medium — they vary in structure.
• If feeds use Atom or malformed XML, consider a library like Simple XML or kotlinx.serialization with custom adapters.

Bottom line:
You don't need a library to parse basic RSS in Kotlin. With XmlPullParser and coroutines, it's clean, fast, and works reasonably. Keep it simple until your needs grow — then consider Retrofit a dedicated parser.

The above is the detailed content of Fetching and parsing RSS feeds in an Android application using Kotlin. For more information, please follow other related articles on the PHP Chinese website!