16 development tips for Android in the Kotlin language. Part 1

Before reading these tips, you should read the Kotlin documentation and learn the language yourself on the site. try.kotlinlang.org. Since these tips are aimed specifically at using Kotlin in the context of Android development, you should also have experience with the Android SDK. It is also advisable to familiarize yourself with the Kotlin plugin and the use of Kotlin with Android Studio from JetBrains (creators of Kotlin)

Kotlin Basic Android Tips

Lazy Loading

Lazy loading has several advantages. For example, such:

  • You save startup time since loading some data is delayed until it is needed. This is especially true for Android, because the user will see the contents of the application faster instead of a long wait time for launching and watching the download tap.
  • You save memory, because the resource is loaded into the device’s memory only upon request. This is especially important for mobile platforms, because the resources of mobile phones are quite limited.

For example, if you are creating a shopping application in which users will mainly be guided by your choice, then lazy loading can be configured on the actual shopping API, for example, something like this:

val purchasingApi: PurchasingApi by lazy {
    val retrofit: Retrofit = Retrofit.Builder ()
            .baseUrl (API_URL)
            .addConverterFactory (MoshiConverterFactory.create ())
            .build ()
    retrofit.create (PurchasingApi :: class.java)
}

The result of using such a lazy download is that if the user does not try to make a purchase in the application, you will not download it and use unclaimed resources.

Also lazy loading is a good way to encapsulate initialization logic, for example:

val bounds: RectF by lazy {
    RectF (0f, 0f, width.toFloat (), height.toFloat ())
}

As soon as the first call is made, an instance of RectF is created based on the current width and height of the view, which saves us from having to create it separately and set this object.

Custom getters and setters

To read custom settings, the Kotlin language uses a structural model with defined user behavior to retrieve and set fields. When using models for specific frameworks, such as the Parse SDK, you select values ​​that are not local class variables, but that are retrieved and stored using a custom method, for example, from JSON.

Using user-defined acquisition and installation methods, we can simplify access, for example:

@ParseClassName ("Book")
class Book: ParseObject () {

    // getString () and put () - ParseObject methods
    var name: String
        get () = getString ("name")
        set (value) = put ("name", value)
    var author: String
        get () = getString ("author")
        set (value) = put ("author", value)
}

Retrieving these values ​​will be similar to using property access syntax in other models, such as:

val book = api.getBook ()
textAuthor.text = book.author

Now, if you need to transfer your model from Parse to some other data source, the code practically does not need to be changed.

Lambda

Lambdas reduce duplication of lines of code in the source file and allow the use of functional programming. Although lambdas are currently used by Android, Kotlin takes them to the next level, ensuring that you don’t have to deal with Retrolambda or change the way you build.

For example, listening to a file would look something like this:

button.setOnClickListener {view ->
    startDetailActivity ()
}

And this is how it works with return values:

toolbar.setOnLongClickListener {
    showContextMenu ()
    true
}

In the Android SDK, quite often there is a need to implement one of these methods. The lambda copes with this with a bang.

Data classes

Data classes simplify classes by automatically adding methods equals (), hashCode (), copy () and toString (). They clarify what data should be used in the model, separating data from logic.

For example, here is such a data class:

data class User (val name: String, val age: Int)

That's all. Nothing more is needed for his work. If you use data classes with something similar to Gson or another JSON type library, you can create a default constructor with default values, for example:

data class User (
    @SerializedName ("name") val name: String = "",
    @SerializedName ("age") val age: Int = 0
)

Dataset Filtering

In working with the API, the need to process collections constantly arises. Most often, you need to filter or change the contents of.

Using filtering collections Kotlin, you can make the code simpler and more understandable. You can specify the contents of a list of results by filtering collections, for example, like this:

val users = api.getUsers ()
val activeUsersNames = items.filter {
    it.active
}
adapter.setUsers (activeUsers)

Kotlin's built-in collection filtering methods are very similar to methods used in other programming languages ​​like Java 8 or when working with Swift collection types. Unified methods of filtering collections simplify mutual understanding when communicating with employees about the need to perform specific operations to obtain and display the necessary lists of elements.

This concludes the first part of the article and invites you to attend a free webinar on the topic: “Unit testing in Android”.

Similar Posts

Leave a Reply