RSS Reading In Kotlin: Easy Android Programming
Prologue
RSS reading is one of the most important and widely used features across software apps in web or mobile techs. To keep the things in control we would be concentrating our blog to kotlin.
To start with I would like to emphasize on a saying
You can’t build a great building on a weak foundation
Therefore, we will first be creating a very basic app for exploring RSS Reading functionality in Kotlin. In the later part of this blog, we would be using MVVM to improve our code structure.
During our journey, we will encounter a few helper libraries like CardView, RecyclerView, Glide, Jsoup in between.
So Let’s start the process, you may like to see what we are going to develop
Process
I assume that readers know how to checkout projects from a Github repository. Even if they don’t know, they may read more at this and this link. Once you git checkout public repository available at the link and open it in your Android Studio, you will see below code structure in the src folder.
Further, this blog is not about recycler view or any other UI component. If required I will write another blog for explaining them.
So we have
Activity called MainActivity
Fragment called RSSFragment (kind of list fragment)
Recyclerview Adapter called MyItemRecylcerviewAdapter
Model class RSSItem to hold particular RSS item data.
Parser class for parsing inputstream.
Then we have AppGlideModule class required by Glide.
Below is the code for different files , I will explain them one by one
MainActivity.kt
/*
* Copyright (c) 2020. Relsell Global
*/package com.relsellglobal.kotlinrssreadingimport android.os.Bundle
import androidx.appcompat.app.AppCompatActivityclass MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main) supportFragmentManager.beginTransaction().replace(R.id.fragment_root,RSSFragment()).commit(); }
}
we are mere invoking RSSFragment in onCreate method.
Distributing code among fragments
Fragments are Lightweight, reusable UI components that can be used for creating UI in Android. Invoking an activity is a heavy process for Android OS as compared to fragment. Android OS may choose to reject activity invoking requests by the application.
You must have encountered the above scenario in real life when your phone stops responding to touch events on screen. Moreover, only the activity is not the only culprit here.
As per android docs
You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running (sort of like a “sub-activity” that you can reuse in different activities).
Therefore we will be using fragment here to build our application.
/*
* Copyright (c) 2020. Relsell Global
*/package com.relsellglobal.kotlinrssreadingimport android.os.AsyncTask
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import java.io.IOException
import java.io.InputStream
import java.lang.ref.WeakReference
import java.net.HttpURLConnection
import java.net.URL
/**
* A fragment representing a list of Items.
* Activities containing this fragment MUST implement the
* [RSSFragment.OnListFragmentInteractionListener] interface.
*/
class RSSFragment : Fragment() { // TODO: Customize parameters
private var columnCount = 1 private var listener: OnListFragmentInteractionListener? = null val RSS_FEED_LINK = "http://www.relsellglobal.in/feed/"; var adapter: MyItemRecyclerViewAdapter? = null
var rssItems = ArrayList<RssItem>() var listV : RecyclerView ?= null override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
val view = inflater.inflate(R.layout.fragment_item_list, container, false) listV = view.findViewById(R.id.listV)
return view
} override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
adapter = MyItemRecyclerViewAdapter(rssItems, listener,activity)
listV?.layoutManager = LinearLayoutManager(activity,LinearLayoutManager.VERTICAL,false)
listV?.adapter = adapter val url = URL(RSS_FEED_LINK)
RssFeedFetcher(this).execute(url) } fun updateRV(rssItemsL: List<RssItem>) {
if (rssItemsL != null && !rssItemsL.isEmpty()) {
rssItems.addAll(rssItemsL)
adapter?.notifyDataSetChanged()
}
}
class RssFeedFetcher(val context: RSSFragment) : AsyncTask<URL, Void, List<RssItem>>() {
val reference = WeakReference(context)
private var stream: InputStream? = null;
override fun doInBackground(vararg params: URL?): List<RssItem>? {
val connect = params[0]?.openConnection() as HttpURLConnection
connect.readTimeout = 8000
connect.connectTimeout = 8000
connect.requestMethod = "GET"
connect.connect(); val responseCode: Int = connect.responseCode;
var rssItems: List<RssItem>? = null
if (responseCode == 200) {
stream = connect.inputStream;
try {
val parser = RssParser()
rssItems = parser.parse(stream!!) } catch (e: IOException) {
e.printStackTrace()
}
} return rssItems } override fun onPostExecute(result: List<RssItem>?) {
super.onPostExecute(result)
if (result != null && !result.isEmpty()) {
reference.get()?.updateRV(result)
} } } interface OnListFragmentInteractionListener {
// TODO: Update argument type and name
fun onListFragmentInteraction(item: RssItem?)
}}
Once you scan the above code, you will find it’s very simple. No complex task is going on, but yet few lines may increase your thrust to know more. 🙂
In our onActivityCreated method, we are calling an AsyncTask to bring the RSS feed data from the network so that UI Thread remains free for doing some cool things like showing animations. More specifically, below is the asynctask class.
Nothing complex here, we are just making a network request for getting input stream from the given URL. Please ensure you have given proper permissions in Android Manifest.xml to access the internet.
class RssFeedFetcher(val context: RSSFragment) : AsyncTask<URL, Void, List<RssItem>>() {
val reference = WeakReference(context)
private var stream: InputStream? = null;
override fun doInBackground(vararg params: URL?): List<RssItem>? {
val connect = params[0]?.openConnection() as HttpURLConnection
connect.readTimeout = 8000
connect.connectTimeout = 8000
connect.requestMethod = "GET"
connect.connect(); val responseCode: Int = connect.responseCode;
var rssItems: List<RssItem>? = null
if (responseCode == 200) {
stream = connect.inputStream;
try {
val parser = RssParser()
rssItems = parser.parse(stream!!) } catch (e: IOException) {
e.printStackTrace()
}
} return rssItems } override fun onPostExecute(result: List<RssItem>?) {
super.onPostExecute(result)
if (result != null && !result.isEmpty()) {
reference.get()?.updateRV(result)
} } }
In the above code, we get an inputstream from a server on hitting the given RSS link. To make the code easy to understand we are not ignoring network error conditions here.
Once we get inputstream we pass it to our parser class
/*
* Copyright (c) 2020. Relsell Global
*/package com.relsellglobal.kotlinrssreadingimport org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserException
import org.xmlpull.v1.XmlPullParserFactory
import java.io.IOException
import java.io.InputStream
class RssParser {
private val rssItems = ArrayList<RssItem>()
private var rssItem : RssItem ?= null
private var text: String? = null fun parse(inputStream: InputStream):List<RssItem> {
try {
val factory = XmlPullParserFactory.newInstance()
factory.isNamespaceAware = true
val parser = factory.newPullParser()
parser.setInput(inputStream, null)
var eventType = parser.eventType
var foundItem = false
while (eventType != XmlPullParser.END_DOCUMENT) {
val tagname = parser.name
when (eventType) {
XmlPullParser.START_TAG -> if (tagname.equals("item", ignoreCase = true)) {
// create a new instance of employee
foundItem = true
rssItem = RssItem()
}
XmlPullParser.TEXT -> text = parser.text
XmlPullParser.END_TAG -> if (tagname.equals("item", ignoreCase = true)) {
// add employee object to list
rssItem?.let { rssItems.add(it) }
foundItem = false
} else if ( foundItem && tagname.equals("title", ignoreCase = true)) {
rssItem!!.title = text.toString()
} else if (foundItem && tagname.equals("link", ignoreCase = true)) {
rssItem!!.link = text.toString()
} else if (foundItem && tagname.equals("pubDate", ignoreCase = true)) {
rssItem!!.pubDate = text.toString()
} else if (foundItem && tagname.equals("category", ignoreCase = true)) {
rssItem!!.category = text.toString()
} else if (foundItem && tagname.equals("description", ignoreCase = true)) {
rssItem!!.description = text.toString()
}
}
eventType = parser.next()
} } catch (e: XmlPullParserException) {
e.printStackTrace()
} catch (e: IOException) {
e.printStackTrace()
}
return rssItems
}
}
Our RSS Parser is based on XMLPullparser in android. To know more about XMLPullparser
So now RSSParser call will parse inputstream and stuff all the items in an ArrayList. If we put focus on the parse method we will see, XMLPullparser raised events for the start and end XML tags present in RSS feed.
while (eventType != XmlPullParser.END_DOCUMENT) {
val tagname = parser.name
when (eventType) {
XmlPullParser.START_TAG -> if (tagname.equals("item", ignoreCase = true)) {
// create a new instance of employee
foundItem = true
rssItem = RssItem()
}
XmlPullParser.TEXT -> text = parser.text
XmlPullParser.END_TAG -> if (tagname.equals("item", ignoreCase = true)) {
// add employee object to list
rssItem?.let { rssItems.add(it) }
foundItem = false
} else if ( foundItem && tagname.equals("title", ignoreCase = true)) {
rssItem!!.title = text.toString()
} else if (foundItem && tagname.equals("link", ignoreCase = true)) {
rssItem!!.link = text.toString()
} else if (foundItem && tagname.equals("pubDate", ignoreCase = true)) {
rssItem!!.pubDate = text.toString()
} else if (foundItem && tagname.equals("category", ignoreCase = true)) {
rssItem!!.category = text.toString()
} else if (foundItem && tagname.equals("description", ignoreCase = true)) {
rssItem!!.description = text.toString()
}
}
eventType = parser.next()
}At last here are the Gradle files that show different dependencies used in our application. below is root level Gradle file
// Top-level build file where you can add configuration options common to all sub-projects/modules.buildscript {
ext.kotlin_version = '1.3.61'
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.5.3'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}allprojects {
repositories {
google()
jcenter()
}
}task clean(type: Delete) {
delete rootProject.buildDir
}
app-level Gradle file
apply plugin: 'com.android.application'apply plugin: 'kotlin-android'apply plugin: 'kotlin-android-extensions'apply plugin: 'kotlin-kapt'android {
compileSdkVersion 29
buildToolsVersion "29.0.2"
defaultConfig {
applicationId "com.relsellglobal.kotlinrssreading"
minSdkVersion 22
targetSdkVersion 29
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
implementation 'androidx.appcompat:appcompat:1.1.0'
implementation 'androidx.core:core-ktx:1.0.2'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
implementation 'androidx.legacy:legacy-support-v4:1.0.0'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test.ext:junit:1.1.0'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0' // gson
implementation 'com.google.code.gson:gson:2.8.6' //cardview
implementation 'androidx.cardview:cardview:1.0.0' // recyclerview
implementation "androidx.recyclerview:recyclerview:1.1.0" // glide
implementation 'com.github.bumptech.glide:glide:4.9.0'
kapt 'com.github.bumptech.glide:compiler:4.9.0' // parsing html
implementation 'org.jsoup:jsoup:1.11.2'
}
Code improvement using MVVM would be explained in another blog. Soon I will update the link here.
Thanks for reading RSS Reading in Kotlin blog.
The post originally published at Link.
Happy Coding.
