All Ruby on Rails Node JS Android iOS React Native Frontend

Things We've Learned During Coolcal Development – Android Kotlin App Example

Learning Kotlin is a pleasant process and only takes a few hours if you’re familiar with the Java programming language. :) The syntax is very intuitive, e.g. a when the block is more readable than an if block or switch. At Netguru, we had quite an adventure with Kotlin over the last few weeks while creating the Coolcal app. Here you can read about how we did it. In this article, I want to tell you more about what it’s like to learn Kotlin.

Our Kotlin Adventure

The development process is much faster and hassle-free with Kotlin. Look at the snippets below.

When matches the argument against all branches until some branch condition is satisfied. It can be an expression or a statement as the expression value of the satisfied branch becomes the value of the whole expression. The statement values of individual branches are ignored.

Declaring a singleton object is done by simply adding the object keyword before the name of our object.

object InstancesLoader { //Implementaion}

Objects inside a class can be marked with a companion object and can be called by using simply the class name as the qualifier.

In apps, we frequently need classes just to hold data; a lot of boilerplate code needs to be written. But in Kotlin, everything is achieved by using data classes. The compiler automatically derives the necessary code.

The code above implements members from the primary constructor and the necessary methods:

  • equals()/hashcode() pair,
  • toString(),
  • copy()

Small things like no new keyword also improve the development process.

var adapter = EventAdapter(context, null, 0, this)

The above snippet creates an instance of the EventAdapter class. These features, and many others make Kotlin a really enjoyable language.

Compared to Java, Kotlin is a really modern solution for implementation problems. Null object handling is a big issue in Java, but Kotlin is a null type safety language, so we don’t have to worry about this, e.g

subscription?.unsubscribe()

The syntax above means that the variable subscription will execute the method unsubscribe if the subscription isn’t null. This construction is very helpful and solves null handling problems.

What’s more - when we need to check if a variable is null to operate on it after a null check, we don’t need to cast it to non-null type; Kotlin supports smart cast operation.

In the example above dtStart and dtEnd were automatically cast to proper type.

According to Effective Java, Item 17 (“Design and document for inheritance or else prohibit it”) all classes should be final, and Kotlin classes correspond to this statement. This helps developers build a better code base.  

Awesome Libraries to Browse

Awesome libraries exist in the Android developer community and to give up on them would be painful. Fortunately, Kotlin is 100% interoperable with Java, so it’s possible to use popular Java libraries like Retrofit in Kotlin. :)

If you are planning to code in Kotlin, please take a look at these short tips. Using higher-order functions in Kotlin creates additional memory allocations and runtime overhead, but we can remedy this problem using an inline modifier. Remember, though, that inlining is not always possible or wanted - it causes generated code to grow. Listeners and callbacks are awful to write, but they can be clean and more readable thanks to lambda expressions.

eventIconClose.setOnClickListener { activity.finish() }

A nasty thing in Android is the findViewById function, but thanks to Kotlin Android Extensions, we can obtain the same functionality without this extra, awful code.

dayOfWeekTextView.text = timeFormatter.formatDayOfWeekShort(todayDt) 

Default values are very helpful - no more method overloading or creating several constructors to cut input parameters.

fun formatTimeOfDay(dt: Long?, isAllDay: Boolean = false)

We can use this method with only one parameter like formatTimeOfDay(dt)

Sometimes a method or constructor has many parameters of the same type, which can be very error-prone - it’s easy to put the wrong value in the wrong place. To help developers beat this problem, language creators added named parameters. It’s worth using :)   

formatTime(timeMillis = i)

I is value of timeMillis parameter.

During the development process, three Netguru Android team members made commits to the code base. As it was an internal project, we had very limited resources, commercial projects were always a priority. This didn’t matter in terms of the quality or continuity of the project as our process makes it easier for a team member to join or leave.

During development, we found places to make code easier and more readable. We achieved this thanks to powerful language features. Kotlin extension functions help us make our code easy to understand. A good example of using this feature is getting a cursor value for a specific column. Writing this in Java for a generic field wouldn’t be as simple as in Kotlin.

This method gets a value from cursor for a specific column name; usage of this method is even simpler.

fun Cursor.eventId() = from(_ID) { getLong(it) }
fun Cursor.eventDescription() = from(DESCRIPTION) { getString(it) }

Everything looks very intuitive and awesome. The next cool thing is using properties for handling shared preferences.

Using preferences implemented this way is very readable and clean.

appPreferences.lastForecast = response 

The above code saves the response into lastForecast.

Wrapping up

Kotlin is one of those languages whose processes are faster and less problematic than those of many other languages. I hope you will find my tips useful and that you will like our showcase app - Coolcal. Please let me know what you think in the comments below. All feedback will be greatly appreciated.

We're building our future. Let's do this right - join us
New Call-to-action
READ ALSO FROM Dev
Read also
Need a successful project?
Estimate project or contact us