Free PacktPub Ebook Notifier App In Android (Kotlin)

Introduction

PacktPub is one of the greatest ebook and videos sites for tech users and they offer one free ebook every day. Most of the time, I forget to visit the site so I miss a lot of free good ebooks and regret it later. So, I decided to create a weekend side project to explore the Kotlin language and also to refresh my Android skills by understanding the latest Andriod O background processing limitations.

It took some time to understand the basic Kotlin language concepts (like companion objects, null safety) but its a good opportunity for .Net developers to explore this language rather than coding in Java for Android apps. Kotlin also provides some real good extensions plugins to eliminate lots of boilerplate Android code like findviewbyid.

Application Overview

 

This app launches the main activity with asynctask in background to parse the content to get the free ebook title, image url and render it on the main activity. It also checks the site periodically (based on settings) and notifies the user.

class MainActivity : AppCompatActivity(),ToolbarManager {

    private val Tag: String = "MainActivity"
    private lateinit var parserHelper: ParserHelper
    private lateinit var alarmManagerHelper: AlarmManagerHelper
    var mImageURL: String? = null
    var mTitle: String? = null
    override val toolbar by lazy { find(R.id.toolbar) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initToolbar()
        toolbarTitle = getString(app_name)

        claimThisBook.setOnClickListener {
            val intent = Intent(Intent.ACTION_VIEW)
                    .setData(Uri.parse(getString(R.string.FREE_BOOK_URL)))
            startActivity(intent)
        }

        //Call the Async Task
        LoadContentTask().execute()

        //Setting the Broadcast Alert
        alarmManagerHelper = AlarmManagerHelper(this)
        alarmManagerHelper.setBroadCastAlert(false)

        //Enable the BootReceiver
        enableBootReceiver()
    }

    private fun enableBootReceiver() {
        val receiver = ComponentName(this, BootReceiver::class.java)
        val pm = this.packageManager
        pm.setComponentEnabledSetting(receiver,
                PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                PackageManager.DONT_KILL_APP)
    }

    inner class LoadContentTask : AsyncTask() {
        override fun doInBackground(vararg p0: Unit) {
            parserHelper = ParserHelper(this@MainActivity);
            val (title, imageURL) = parserHelper.parsePacktPubFreeBook()
            mTitle = title
            mImageURL = imageURL
        }

        override fun onPostExecute(result: Unit) {
            super.onPostExecute(result)
            Glide.with(this@MainActivity).load(mImageURL).into(imageView)
            titleView.text = mTitle
        }
    }
}

I have created AlarmManagerHelper class to set a repeating alarm based on the sync frequency settings. The Sync Frequency Settings are stored in SharedPreferences. 

internal class AlarmManagerHelper(ctx: Context) : ContextWrapper(ctx) {

    fun setBroadCastAlert(argRefreshAlarm: Boolean) {

        var refreshAlarm = argRefreshAlarm
        val alarmManager = this.getSystemService(Activity.ALARM_SERVICE) as AlarmManager

        val notificationIntent = Intent(Constants.ALARM_RECEIVER_INTENT_TRIGGER)
        notificationIntent.setClass(this, NotificationReceiver::class.java)

        var pendingIntent = PendingIntent.getBroadcast(this, 0, notificationIntent, PendingIntent.FLAG_NO_CREATE)
        if (pendingIntent == null) {
            pendingIntent = PendingIntent.getBroadcast(this, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT)
            refreshAlarm = true
        }
        if (refreshAlarm) {
            val syncFrequency: String by DelegatesExt.preference(this, Constants.SYNC_FREQUENCY_NAME, Constants.SYNC_FREQUENCY_DEFAULT_VALUE)
            val syncFrequencyLong = syncFrequency.toLong()
            var finalCalInMillis: Long = System.currentTimeMillis() + (syncFrequencyLong * AlarmManager.INTERVAL_HOUR)
            alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, finalCalInMillis, (syncFrequencyLong * AlarmManager.INTERVAL_HOUR) , pendingIntent)
        }
    }
}

From Android O, there are lots of limitations on background execution limits and you can read all those details in the Android Developer Guide. For this project, I need a background job that should run periodically based on frequency settings defined in the app and send the notification to user with the book title. I used JobIntentService to do the background work and send the notification to the user.

class NotificationService : JobIntentService() {

    private lateinit var notiHelper: NotificationHelper
    private lateinit var parserHelper: ParserHelper

    companion object {
        private const val JOB_ID = 1000
        private const val NOTI_PRIMARY = 1100

        fun enqueueWork(ctx: Context, intent: Intent) {
            enqueueWork(ctx, NotificationService::class.java, JOB_ID, intent)
        }
    }

    override fun onHandleWork(intent: Intent) {

        notiHelper = NotificationHelper(this)
        parserHelper = ParserHelper(this);

        val(title) = parserHelper.parsePacktPubFreeBook()

        val pendingIntent = PendingIntent.getActivity(this, 0, intent, 0)
        notiHelper.notify(NOTI_PRIMARY, notiHelper.getNotification(getString(R.string.noti_title), title,pendingIntent))
    }
}

I also created BootReceiver with BOOT_COMPLETED intent so that repeating alarm will get set even in the event of a phone restart.

class BootReceiver : BroadcastReceiver() {

    private lateinit var alarmManagerHelper: AlarmManagerHelper

    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == "android.intent.action.BOOT_COMPLETED") {
            alarmManagerHelper = AlarmManagerHelper(context)
            alarmManagerHelper.setBroadCastAlert(false)
        }
    }
}

I used Jsoup Library to parse the HTML content. Jsoup is a Java library for working with real-world HTML. It provides a very convenient API for extracting and manipulating data, using the best of DOM, CSS, and jquery-like methods.

internal class ParserHelper(ctx: Context) : ContextWrapper(ctx) {

    private val tag: String = "ParserHelper"

    data class ParserEntity(val title: String, val imageURL: String?)

    fun parsePacktPubFreeBook(): ParserEntity {
        var title = "Internet access not available"
        var imageURL: String? = null
        if (isInternetConnected()) {
            try {
                val htmlContent = Jsoup.connect(getString(R.string.FREE_BOOK_URL)).get()
                title = htmlContent.select("div[class=dotd-title]").text()
                imageURL = "http:" + htmlContent.select("img[class=bookimage imagecache imagecache-dotd_main_image]").attr("src")
            } catch (e: Exception) {
                Log.e(tag, "Error in fetching the content " + e.printStackTrace())
            }
        }

        return ParserEntity(title, imageURL)
    }

    private fun isInternetConnected(): Boolean {
        val cm = this.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val activeNetwork = cm.activeNetworkInfo
        return activeNetwork != null && activeNetwork.isConnectedOrConnecting
    }
}

So, overall this project will give you an idea of how to develop an Android app in Kotlin including running the background job and sending the notitfication to users. I have uploaded the entire source code in github.

You can also find my other articles in my blog.

Happy Coding!!