Connect with us

Code

RSS Parser – Android library to parse a RSS Feed

RSS Parser is an Android library to parse any RSS feed. With RSS Parser, you can fetch plenty of useful information from any RSS channel, be it a blog, magazine, or even a podcast feed.

As of April 2020, it’s been downloaded more than 30,000 times from 125 different countries (among them, North Korea, Madagascar and even Panama 🌴).

Available data

The RSS channel resulting object provides you with the following data:

  • Title
  • Description
  • Link
  • Articles
  • Image (Title, Url and Link)
  • Last build data
  • Update period
  • Itunes Data:
    • Author
    • Categories
    • Duration
    • Explicit
    • Image
    • Keywords
    • News Feed URL
    • Owner
    • Subtitle
    • Summary
    • Type

Articles, on the other hand, support the following attributes:

  • Title
  • Author
  • Description
  • Content
  • Image
  • Link
  • Publication Date
  • Categories
  • Audio
  • Source (name and URL)
  • GUID
  • Video
  • Itunes Data:
    • Author
    • Duration
    • Episode
    • Episode Type
    • Explicit
    • Image
    • Keywords
    • Subtitle
    • Summary

Features

Caching

The library provides a caching layer to avoid wasting data with very long feeds. All you need to do is provide an expiration date. For more details, give a look to the Usage section

⚠️ For the time being caching is only supported if you are using Kotlin.

RSS Parsing from string

The library provides a way of simply parsing raw data from a string.

Installation

The library is uploaded on MavenCentral, so you can easily add the dependency:

dependencies {
  implementation 'com.prof18.rssparser:rssparser:<latest-version>'
}

Usage

Kotlin

First of all, you have to create a Parser object with the Parser Builder. In the builder you can provided some custom and optional fields:

  • A custom OkHttpClient; if not provided, the library will create one for you.
  • A custom Charset; if not provided, it will automatically inferred from the XML.
  • The Android Context, mandatory to make the caching layer work.
  • The cache expiration date in milliseconds, mandatory to make the caching layer work.

If you don’t provide the Android Context and the cache expiration date, the library will continue working but without the caching feature.

val parser = Parser.Builder()
                .context(this)
                .charset(Charset.forName("ISO-8859-7"))
                .cacheExpirationMillis(24L * 60L * 60L * 1000L) // one day
                .build()

The library uses the Kotlin Coroutines to retrieve, parse and cache the feed. So to start the process, you need to launch the coroutine.

//url of RSS feed
private val url = "https://www.androidauthority.com/feed"

viewModelScope.launch {
    try {
        val channel = parser.getChannel(url)
        // Do something with your data
    } catch (e: Exception) {
        e.printStackTrace()
        // Handle the exception
    }
}

For flushing the cache:

parser.flushCache(url)

For simply parsing raw data:

  • suspend function Parser#parser(rawRssFeed) which returns the channel.
// parser without any network or caching configuration
val parser = Parser.Builder().build()

viewModelScope.launch {
    try {
        val channel = parser.parse(raw)
        // Do something with your data
    } catch (e: Exception) {
        e.printStackTrace()
        // Handle the exception
    }
}

You can give a look to the full Kotlin sample by clicking here

Java

Starting from the version 2.x, the library has been completely rewritten using Kotlin and the coroutines. However, the compatibility with Java has been preserved and the same code of the versions 1.x can still be used.

⚠️ For the time being, the caching is not supported if you are using Java.

If you are still using Java, this is the interface to use the library:

import com.prof.rssparser.Article;
import com.prof.rssparser.OnTaskCompleted;
import com.prof.rssparser.Parser;

Parser parser = new Parser.Builder()
        .charset(Charset.forName("ISO-8859-7"))
        // .cacheExpirationMillis() and .context() not called because on Java side, caching is NOT supported
        .build();
        
parser.onFinish(new OnTaskCompleted() {

    //what to do when the parsing is done
    @Override
    public void onTaskCompleted(Channel channel) {
        // Use the channel info
    }

    //what to do in case of error
    @Override
    public void onError(Exception e) {
        // Handle the exception
    }
});
parser.execute(urlString);

For parsing raw data there is a java compatible function which calls the listeners OnTaskCompleted and onError once done.

Parser.parser(rawRssFeed, OnTaskCompleted)

The full Java sample is available here

Version 1.4.4 and below

For older versions of the library, the interface is marginally different:

import com.prof.rssparser.Article;
import com.prof.rssparser.Parser;

//url of RSS feed
String urlString = "http://www.androidcentral.com/feed";
Parser parser = new Parser();
parser.onFinish(new Parser.OnTaskCompleted() {
    
    @Override
    public void onTaskCompleted(Channel channel) {
      //what to do when the parsing is done
    }

    @Override
    public void onError() {
      //what to do in case of error
    }
});
parser.execute(urlString);
RSS Parser on GitHub: https://github.com/prof18/RSS-Parser
Платформа: Android
⭐️: 344
Advertisement

Trending