Network calls might time out, APIs might be temporarily unavailable, or databases might become unreachable. To handle such transient errors gracefully, implementing a retry mechanism is crucial. This article will guide you through the basics of why you need a retry mechanism, starting with simple retries and gradually introducing backoff strategies using a Go example.

Simple Retries

A basic retry mechanism involves reattempting an operation a fixed number of times immediately after a failure. Here's how you can implement this in Go:

func immediatelyRetry(f func() error, retriesLeft int) error {
    err := f()
    if err == nil {
        return nil
    }

    if retriesLeft == 0 {
        return err
    }

    return immediatelyRetry(f, retriesLeft-1)
}

In this function, f is the operation that might fail. It is retried immediately until it either succeeds or the retry limit is reached.

Adding Backoff Strategies

While immediate retries can be effective, they might overwhelm the system or the external service you're interacting with. To address this, backoff strategies introduce delays between retries, with the delay increasing over time.

Exponential Backoff

Exponential backoff is a popular strategy where the delay between retries grows exponentially. This reduces the load on the system and gives it more time to recover. Here's an example implementation:

func retryWithBackoff(f func() error, retriesLeft int, delay time.Duration, backoff float64) error {
    err := f()
    if err == nil {
        return nil
    }

    if retriesLeft == 0 {
        return err
    }

    time.Sleep(delay)
    return retryWithBackoff(f, retriesLeft-1, time.Duration(float64(delay)*backoff), backoff)
}

In this function, the delay is multiplied by the backoff factor after each retry, resulting in exponentially increasing delays.

Defining a Custom Retry Policy

To provide flexibility, you can define a custom retry policy that combines immediate retries and retries with backoff. Here’s how you can achieve this in Go:

package xretry

import (
    "time"
)

// RetryPolicy is the retry policy
type RetryPolicy struct {
    immediateRetries   int
    retriesWithBackoff int
    delay              time.Duration
    backoffFactor      float64
}

// RetryPolicyOption is the option for the retry policy
type RetryPolicyOption func(*RetryPolicy)

// WithImmediateRetries sets the immediate retries
func WithImmediateRetries(retries int) RetryPolicyOption {
    return func(p *RetryPolicy) {
        p.immediateRetries = retries
    }
}

// WithRetriesWithBackoff sets the retries with backoff
func WithRetriesWithBackoff(retries int, delay time.Duration, backoffFactor float64) RetryPolicyOption {
    return func(p *RetryPolicy) {
        p.retriesWithBackoff = retries
        p.delay = delay
        p.backoffFactor = backoffFactor
    }
}

// NewRetryPolicy creates a new RetryPolicy
func NewRetryPolicy(opts ...RetryPolicyOption) RetryPolicy {
    p := RetryPolicy{
        immediateRetries:   0,
        retriesWithBackoff: 0,
        delay:              0,
        backoffFactor:      0,
    }

    for _, opt := range opts {
        opt(&p)
    }

    return p
}

// Retrier is the interface that wraps the Retry method
type Retrier struct {
    p RetryPolicy
}

// NewRetrier creates a new Retrier
func NewRetrier(p RetryPolicy) *Retrier {
    return &Retrier{
        p: p,
    }
}

// Retry will retry the given function
func (r *Retrier) Retry(f func() error) error {
    err := immediatelyRetry(f, r.p.immediateRetries)
    if err != nil {
        err = retryWithBackoff(f, r.p.retriesWithBackoff, r.p.delay, r.p.backoffFactor)
        if err != nil {
            return err
        }
    }

    return nil
}

Usage Example

Here's an example of how to use the custom retry policy and retrier in your application:

func main() {
    // Define a retry policy
    policy := xretry.NewRetryPolicy(
        xretry.WithImmediateRetries(3),
        xretry.WithRetriesWithBackoff(3, 1*time.Second, 2.0),
    )

    // Create a new retrier with the policy
    retrier := xretry.NewRetrier(policy)

    // Define a function that may fail
    f := func() error {
        // Your code here
    }

    // Use the retrier to retry the function if it fails
    err := retrier.Retry(f)
    if err != nil {
        fmt.Println("Operation failed after retries:", err)
    }
}

In this example, the function f will be retried immediately 3 times if it fails. If it still fails after these retries, it will be retried 3 more times with a delay that doubles after each retry, starting from 1 second.

Conclusion

Implementing a retry mechanism with customizable policies and backoff strategies can significantly enhance the resilience of your Go applications. By defining flexible retry policies, you can handle transient errors more gracefully, providing a better experience for your users and reducing the need for manual intervention.

Sealed Classes in Kotlin are a specialized form of abstract classes. They limit subclassing, giving you more control. This article will explain what sealed classes are, how they benefit you in Kotlin, and the best ways to use them.

Sealed Classes in Kotlin are a type of abstract class that can't be initiated directly, with abstract members. They limit subclassing, ensuring a class only has a limited, well-defined set of subclasses. This improves type-safety and helps write error-free code.

In this article, we'll cover the basics of Sealed Classes: syntax, constructors, and subclass restrictions. We'll also see how Sealed Classes can be used in when expressions for a more controlled, type-safe handling of cases. Whether you're new to Kotlin or a seasoned developer, you'll gain valuable insights on using Sealed Classes effectively.

Poperties and Overview

Sealed Classes in Kotlin limit the type hierarchy. They're like restricted abstract classes, having constructors and the ability to extend classes. But, unlike open or abstract classes, they cannot be inherited outside their file or package.

An example of a Sealed Class in Kotlin:

sealed class Error {
    abstract val message: String
}

The visibility of Sealed Class constructors is based on the visibility of the class. If the Sealed Class is private, its constructors will also be private. If it's internal, the constructors will be internal and so on.

Sealed classes in Kotlin have a limitation on inheritance. The direct descendants of a sealed class must be located in the same file or package as the sealed class itself. It's not possible to create a subclass of a sealed class in a different file or package.

Here's an illustration of two subclasses of the Error sealed class in the same file:

data class FileReadError(override val message: String, val file: String) : Error()

data class DatabaseError(override val message: String, val source: String) : Error()

Additionally, the subclasses of a sealed class must have a fully qualified name and cannot be defined as local or anonymous objects.

Control Flow

The usage of sealed classes in Kotlin offers improved control over control flow statements. One of the key advantages of sealed classes is demonstrated through their utilization in when expressions.

when expressions in Kotlin are comparable to switch statements in other programming languages. They let you inspect the class type of an object and perform different operations based on its type. Unlike switch statements, it is mandatory to include an else clause to cater to cases not covered in traditional switch statements.

With sealed classes, it is possible to verify that the when statement covers all cases, eliminating the need for an else clause. Consider the following example:

sealed class Error
class FileReadError : Error()
class DatabaseError : Error()
class RuntimeError : Error()

fun log(e: Error) = when(e) {
    is FileReadError -> { println("Error while reading file") }
    is DatabaseError -> { println("Error reading from database") }
    is RuntimeError ->  { println("Runtime error") }
    // the `else` clause is not required because all the cases are covered
}

In the example, Error is defined as a sealed class, with subclasses FileReadError, DatabaseError, and RuntimeError. The when expression within the log function checks the type of error and prints a corresponding message for each case.

Sealed classes in a when expression offer clear and reliable code, as all cases are accounted for, and there's no need for an else clause.

Conclusion

Sealed classes in Kotlin are a valuable tool for better type safety and control flow in your code. When used with when expressions, they restrict the objects that can be passed and make it simpler to guarantee all cases are handled. Additionally, sealed classes enforce proper naming conventions and keep subclasses in the same package, helping maintain code integrity and readability. Whether you are a beginner or an experienced developer, sealed classes are a must-have for writing superior code in Kotlin.

Happy Coding.

Kotlin provides us with a special modifier for classes - data. Such classes are known as data classes. They are typically used to represent a data model in an application, such as a user or a product. These data classes provide useful functionalities out f the box, such as equals(), hashCode(), and toString() methods, which are automatically generated for us by the compiler. This can save us a lot of time and make our code more readable and maintainable.

Let's get started!

Syntax And Usage

Let's see how can we model a User class using data classes. We'll store two properties name and age.

To declare a data class use the data keyword, followed by the class declaration. Make sure that there is at least one property in the primary constructor.

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

The val keyword in front of the properties indicates that they are read-only, and can only be initialized in the primary constructor. We can also use var to make the properties mutable.

We can create an instance of a data class similar to that of regular classes. For example:

val user = User("John", 30)

We can then access the properties of the User class using the dot notation:

println(user.name) // prints "John"
println(user.age) // prints 30

One of the main benefits of data classes is that they come with several automatically generated functions that make it easy to work with instances of the class. These functions include:

• equals(): This function compares two instances of the data class for equality. It is generated based on the properties defined in the primary constructor.

• hashCode(): This function generates a unique hash code for an instance of the data class. It is also generated based on the properties defined in the primary constructor.

• toString(): This function generates a string representation of an instance of the data class. The default implementation includes the class name and the values of the properties.

Let's see how we can use the equals() function to compare two instances of the User class:

val user1 = User("John", 30)
val user2 = User("John", 30)
val user3 = User("Jane", 25)

println(user1 == user2) // prints true
println(user1 == user3) // prints false

We can also use the toString() function to get a string representation of an instance of the data class:

val user = User("John", 30)
println(user) // prints "User(name=John, age=30)"

In this section, we covered the syntax and usage of data classes in Kotlin, including how to define a data class, create an instance of a data class, access its properties, and use the automatically generated functions such as equals(), hashCode(), and toString().

Properties Declared in the class body

In the previous section, we took a look at how to create a data class. We declared the properties in the primary constructor but we can also declare some properties in the class body. These properties are not considered part of the primary constructor and are not included in the automatically generated functions such as equals(), hashCode(), and toString(). However, they can still be accessed and used like any other property.

For example, consider the following data class:

data class Person(val name: String) {
    var age: Int = 0
}

In this example, name is a property of the primary constructor and age is a property declared in the class body. When comparing two Person objects using the == operator, only the name property will be considered.

val person1 = Person("John")
val person2 = Person("John")
person1.age = 10
person2.age = 20

println("person1 == person2: ${person1 == person2}")

This will result in person1 == person2: true, even though the age property is different between the two objects.

In addition, the toString(), hashCode(), and copy() functions will also only include the name property. If we wish to include additional properties in these functions, we can override them in the class body.

It's important to keep in mind that properties declared in the class body are not considered part of the data class' signature, and thus will not affect the automatically generated functions. They can be used for additional functionality and can be used to store additional data, but it's important to consider the trade-offs.

Copy()

In Kotlin, the copy() function is a convenient way to create a new instance of a data class while altering some or all of its properties. The copy() function is generated automatically by the compiler for data classes and takes all properties of the class as its parameters. The values passed to the copy() function will be used to create a new instance of the class, while the values that are not passed will be taken from the original instance.

Here is an example of using the copy() function in a data class:

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

fun main() {
    val person1 = Person("John", 25)
    val person2 = person1.copy(age = 30)
    println(person1) // Person(name=John, age=25)
    println(person2) // Person(name=John, age=30)
}

In this instance, person1 is an instance of the Person data class, with the name "John" and age 25. Using the copy() function, we modify the age to 30 and create a new instance of the class, person2. As we can see, two unique instances with different age values arise from copying the name property from the original instance and setting the age property to the new value.

It's important to keep in mind that the copy() function creates a new object with the provided properties rather than altering the original object. This makes it a helpful tool for making minor changes to existing instances before creating new ones.

In conclusion, the copy() function in Kotlin is a simple yet powerful tool for creating new instances of data classes with modified properties. It's easy to use, and it helps to keep your code clean and readable.

Desctructuting decarations with data classes

Data classes in Kotlin come with a set of automatically generated functions, including component functions. These component functions make it possible to use data classes in destructuring declarations.

A destructuring declaration is a way to decompose an object into its individual properties. It allows you to assign the properties of an object to separate variables in a single line. For example, consider the following data class:

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

We can create an instance of this class and use it in a destructuring declaration as follows:

val jane = Person("Jane", 35)
val (name, age) = jane
println("$name, $age years of age") // prints "Jane, 35 years of age"

In this example, the variables name and age are assigned the values of the name and age properties of the jane object, respectively. The variables are created and initialized in a single line, making the code more concise and readable.

It is also possible to use destructuring declarations with a specific component function. For example, if we only need the name property of the object, we can use the component1() function which is generated for the first property of the data class.

val (name) = jane
println("Name: $name") // prints "Name: Jane"

In summary, destructuring declarations provides a convenient and readable way to work with the properties of data classes. They allow us to easily access and assign the properties of an object without having to reference the object itself. This can make our code more readable and maintainable.

Conclusion

In conclusion, data classes in Kotlin provide a simple and efficient way to define classes that hold data. They allow developers to quickly create classes with minimal boilerplate code and automatically generated functions such as equals(), hashCode(), and toString(). They also provide a convenient way to copy objects and use them in destructuring declarations.

In the coming article, we'll discuss sealed classes. See you then.

Happy Hacking!

First, let's define what a type system is. In programming, a type system is a set of rules that determine how data is stored, modified, and used. Coming to the second part of our article, we'll discuss why we need to be concerned with null safety. Accessing a type that can be null can result in a null reference exception, commonly known as a NullPointerException. According to a survey, NullPointerException is the most common exception in java applications. But don't worry, Kotlin offers a solution for this.

The type system of Kotlin is designed to provide an effective way to manage null references. It makes a clear distinction between references that can hold null values (nullable references) and those that cannot (non-null references). Hence, the compiler can track values which can be null and warn you if you're trying to access nullable value, preventing an NullPointerException from happening.

With the introduction out of the way, let's get started!

Basic Types

The data type is one of the most fundamental concepts in any programming language. Simply put, a type is a category of data that a variable or expression can hold. In Kotlin, several basic types are available to use when declaring variables and constants. These basic types include numbers, characters, and booleans. These different types are very neatly organized in a hierarchy that we'll take a look at after we understand nullable types.

Numbers

Numbers in Kotlin come in two forms: Integers and Floating-point numbers. Integers are represented by types such as Byte, Short, Int, and Long. For example,

val age: Int = 25
val weight: Long = 150

Floating-point numbers include types such as Float and Double. For example,

val price: Double = 12.99
val temperature: Float = 32.5f

Also, you can use _ to make increase the readability of code.

val largeNum: Long = 1_000_000_000

Characters

Characters in Kotlin are represented by the Char type. They are enclosed in single quotes, for example:

val letter: Char = 'A'

Booleans

Booleans in Kotlin is represented by the Boolean type. They can be either true or false. For example,

val isStudent: Boolean = true
val isTired: Boolean = false

In addition to these basic types, Kotlin also supports strings, arrays and enum types.

Strings

Kotlin's string type is similar to the string type in most programming languages. It is used to represent a sequence of characters. For example,

val name: String = "John Doe"

Arrays

Arrays in Kotlin are similar to arrays in most programming languages. They are used to store a fixed-size sequential collection of elements of the same type. For example,

val numbers: IntArray = intArrayOf(1,2,3,4,5)
val names: Array<String> = arrayOf("John", "Doe", "Jane", "Smith")

Let's also discuss three special types in Kotlin, Any, Unit and Nothing.

Any

As I mentioned above, all types in Kotlin are organized into a hierarchy, Any is at the root of that hierarchy. For instance, Int and Boolean are subtype of Any. Also, all the classes that you create are subtypes of Any

Unit

Unit is a pre-defined type in Kotlin. It is a singleton, meaning there is only one instance of it. The unit type is used to represent the absence of a value. For example, if you have a function that does not need to return a value, you'd use Unit as its return type.

fun greet(): Unit {
    println("Hello, World!")
}

Also, if you don't specifically mention a return type for the function, it's assumed to return Unit. Hence, the above code can be rewritten as:

fun greet() {
   println("Hello, World!")
}

Nothing

Nothing is a special type in Kotlin. It is at the very bottom of the type hierarchy. This means that Nothing is a subtype of every type. Also, the type Nothing can not be initialized and hence, can not have any instance. Please note the difference between Unit and Nothing. Evaluation of an expression type Unit results in the singleton value Unit. Evaluation of an expression of type Nothing never returns at all.

fun throwsException(): Nothing {
    throw Exception()
}

Please note that Kotlin is a type-safe language, which means that the compiler checks the types of variables and constants at compile time to ensure that they match the expected types.

Null Safety

As we previously discussed, accessing a type that can be null can result in a null reference exception, commonly known as a NullPointerException. Let's see how we can deal with null references in Kotlin.

Kotlin's type system is designed in such a way that it distinguishes between variables that can hold a null value(nullable references) and those that cannot(non-nullable references).

For example, a regular variable of type String cannot hold null:

// Regular initialization means non-null by default
var a: String = "abc" 

a = null // compilation error

To declare a variable that can be set to null, append ? at the end of the type. For example, a nullable String should be declared as String?

var b: String? = "abc" // can be set to null
b = null               // ok

In this way, if you call a method or access a property on a, it's guaranteed not to cause throw a NullPointerException, so it is safe to say:

val l = a.length

However, if you want to access the same property on b, that would not be safe and the compiler will report an error:

val l = b.length // error: variable 'b' can be null

But don't worry, there are ways to safely access properties on nullable variables, which we will discuss later in the article. But first, let's take a look at the type hierarchy in Kotlin.

Type Hierarchy in Kotlin

As we discussed above, Any type is the supertype for all the types, hence it is placed at the "top" of the hierarchy

All the custom types (classes, interfaces, etc) that don't have an explicit type are also a sub-type of Any type. For instance,

class Box {
    fun render() {
        // function body
    }
}

The type Box is a subtype of Any.

Now, the types that inherit other types form a tree structure in the hierarchy. A type can have multiple parent types. For instance,

interface IClickable
interface IDragable

class Card: Box, IClickable, IDragable {
    // ...
}

Coming to the nullable references, each type has its nullable counterpart which is a supertype for the type. For example, Unit is a subtype of Unit? .

Expanding the complete graph to include nullable types results in the following

Now, at the "bottom" of the type hierarchy is the Nothing type. So here's the complete type hierarchy in Kotlin.

Working with Nullable Types

As we saw that we cannot directly access the properties and methods of nullable types, hence it's a bit tricky to work with them. There are two very useful operators to work with nullable types - safe call operator ? and Elvis operator ?:.

Let's first see how the safe-call operator works. This operator returns null if the operand is null. Hence, it allows you to access properties and methods of nullable variables without the risk of Null Pointer Exception.

var name: String? = "John"
var firstChar = name?.get(0) // Evaluates to J

name = null
firstChar = name?.get(0) // Evaluates to null

In this example, if the name variable is null, null will be assigned to the firstChar variable.

Now, let's take a look at the Elvis operator (?:). It is similar to an if-else statement, like so:

val name: String? = "John"
val firstChar = name?.get(0) ?: '?'

This is the same as writing:

val name: String? = "John"
val firstChar = if(name != null) name.get(0) else '?'

One more way to handle nullable variables is the not-null assertion operator (!!). It is used to explicitly assert that a nullable type is not null, and this will throw a null pointer exception if it is. We can use this operator when we are sure that a nullable variable holds a non-null value. For example:

val name: String? = "John"
val upperCaseName = name!!.toUpperCase()

Type checks and casts

is operator

In Kotlin, we can check the type of an object using the is operator and its negated form !is. These operators perform a runtime check that identifies whether an object conforms to a given type.

For example, if we have an object obj and want to check if it's of type String, we can do the following:

if (obj is String) {
    print(obj.length)
}

// OR

if (obj !is String) { // same as !(obj is String)
    print("Not a String")
} else {
    print(obj.length)
}

as and as?operator

Kotlin offers two types of cast operators that can be used to change the type of the object. The first is the unsafe cast operator, denoted by the keyword "as". This operator will throw an exception if the cast is not possible. For example, if we try to cast a variable of type Any to a String using the unsafe cast operator, the code will throw a ClassCastException if the variable is not a String.

val x: Any = "hello"
val y: String = x as String // This will work
val z: Any = 123
val a: String = z as String // This will throw a ClassCastException

The second type of cast operator is the safe cast operator, denoted by the keyword "as?". This operator will return null if the cast is not possible, instead of throwing an exception. This can be useful in situations where we are not sure if the variable is of the type we expect it to be.

val x: Any = "hello"
val y: String? = x as? String // This will return "hello"
val z: Any = 123
val a: String? = z as? String // This will return null

Smart Cast in Kotlin

In addition to these explicit cast operators, Kotlin also has a feature called smart casts. Smart casts allow the compiler to automatically insert safe casts when necessary, without the need for explicit cast operators. The compiler can track the type of a variable and insert a cast when it is used in a context where a different type is expected.

For example, consider the following code:

if (x is String) {
    print(x.length) // x is automatically cast to String
}

Here, the compiler is smart enough to know that x will be a String in the body of if block, hence, it automatically casts the variable x to String.

However, it's important to note that smart casts work only when the compiler can guarantee that the variable won't change between the check and the usage. More specifically, smart casts can be used under the following conditions:

• val local variables - always, except local delegated properties

• val properties - if the property is private or internal or if the check is performed in the same module where the property is declared. Smart casts cannot be used on open properties or properties that have custom getters.

• var local variables - if the variable is not modified between the check and the usage, is not captured in a lambda that modifies it, and is not a local delegated property.

• var properties - never, because the variable can be modified at any time by other code.

Conclusion

In conclusion, the Kotlin-type system is an important aspect of the language that provides many features to ensure safety and reliability in your code. We have discussed the basic types available in Kotlin, the concept of null safety, and the various type casts and checks that can be used to ensure that your code is working as expected.

It is important to understand how to use these features to prevent common errors such as null pointer exceptions and type mismatches. By making use of nullable types, the safe call operator, and the Elvis operator, you can write code that is safe from null references and is more readable.

We have also discussed how to use the is and !is operators and the safe and unsafe cast operators to perform runtime type checks and casts. Smart casts, which are automatically inserted by the compiler when necessary, provide an even more convenient way to handle types.

In the next article in this series, we will delve into data classes. Data classes are a special type of class in Kotlin that are designed to hold data. They are typically used to represent the data model in an app, such as a user or a product.

Keep Coding!

In this article, we will learn about inheritance and polymorphism, and how are these concepts useful in Android development. By the means of this article, we will also discuss interfaces and abstract classes. Let's get started!

Introduction to Inheritance and polymorphism

Inheritance and Polymorphism are important concepts in the object-oriented programming paradigm. Let's look at how each one is important.

Inheritance

Inheritance is a way to create new classes that are derived from existing classes. This is particularly useful because these derived classes have access to the properties and methods of the base class.

For instance, imagine that you are building an app for a school. You might have a class called Person that has information about a person, like their name and age.

Then, you can create new classes for specific types of people, like students and teachers. These new classes will inherit all the information from the Person class and you can add more specific information to them as well.

For example, the Student class might have information about what grade the student is in, and the Teacher class might have information about what subject the teacher teaches.

Inheritance is a useful tool in programming because it allows us to reuse code and create more specialized classes without having to write all the code from scratch. This can save us a lot of time and make our app more efficient.

Polymorphism

Polymorphism is a way of creating objects that can take on different forms. It gives us the ability to make sure that the classes of same category conform to a similar structure.

Imagine that you are building an app that has different types of animals, like dogs, cats, and birds. Each type of animal has its own unique characteristics, like the way they move, the sounds they make, and the things they like to do.

But they also have some things in common, like the fact that they are all animals and they can make sounds - although these sounds will depend on the type of animal all animals can make sounds.

Polymorphism allows us to create a template or plan for an animal that includes all the things that all animals can do. Then, we can create specific implementations for each type of animal, and give them the unique characteristics that are specific to that type of animal.

This is useful in programming because it allows us to create code that can be used in different situations and can adapt to different types of objects. It helps us to write more efficient and flexible code.

So with this understanding of inheritance and polymorphism, Let's look at how we can implement them in Kotlin.

Inheritance in Kotlin

As we saw earlier, inheritance is the practice of creating new classes by deriving them from existing classes. In Kotlin, we need to tell the compiler that we will be using a certain class to create a new class derived from it; to do this, we use the open keyword.

Imagine we are developing an application for a library. We would need a Book class that with properties such as title, author, and isbn. And we would also need a Movie class with properties such as title, director, and releaseYear.

Instead of having two separate classes with similar properties, we can create a parent Media class with the shared properties and have the Book and Movie classes inherit from it. This would allow you to reuse the shared code and keep your code organized.

open class Media {
    var title: String = ""
    var releaseYear: Int = 0

    fun getDescription(): String {
        return "$title ($releaseYear)"
    }
}

Now, to create a class that inherits from Media class, place the name superclass (Media in this case) after : in the declaration of the derived class

class Book: Media() {
    var author: String = ""
    var isbn: String = ""
}

Similarly, here's how you can create the Movie class we discussed above

class Movie: Media() {
    var director: String = ""
    var runtime: Int = 0
}

Overriding methods

Now that we have specialized classes for Books and Movies, we will need to make their descriptions a little more specific. For that, we will override the getDescription method.

To make a method overridable, we need to mark it with open keyword as we did with classes

open class Media {
    var title: String = ""
    var releaseYear: Int = 0

    open fun getDescription(): String {
        return "$title ($releaseYear)"
    }
}

Now, we will add the specialized method in the child classes.

class Book: Media() {
    var author: String = ""
    var isbn: String = ""

    override fun getDescription(): String {
        return "$title by $author ($releaseYear) [ISBN: $isbn]"
    }
}

class Movie: Media() {
    var director: String = ""
    var runtime: Int = 0

    override fun getDescription(): String {
        return "$title directed by $director ($releaseYear, $runtime minutes)"
    }
}

Polymorphism in Kotlin

As we saw earlier, polymorphism is the practice of creating objects that can take on different forms. To do this, we can use a normal class, an abstract class, or an interface as the base and build specific implementations by deriving from them.

Let's go with the example of different animals from above. Imagine that you are building an app that has different types of animals, like dogs, cats, and birds. Each type of animal has its unique characteristics, like the way they move, the sounds they make, and the things they like to do.

In this situation, we could use polymorphism to create a base Animal class with shared properties and behaviors, and then create subclasses for each specific type of animal. This would allow us to define the unique characteristics of each animal in the subclass, while still being able to treat them all as Animal objects.

Let's see how we can implement this code by first using abstract classes and then by using interfaces.

Using Abstract Classes for Polymorphisms

As per Kotlin docs,

A class may be declared abstract, along with some or all of its members. An abstract member does not have an implementation in its class. You don't need to annotate abstract classes or functions with open.

Here's how we would implement the base Animal class as an abstract class

abstract class Animal {
    var name: String = ""

    abstract fun move(): String
    abstract fun speak(): String
}

Since the class is abstract, we don't need to implement the methods move and speak. Now, let's create our specialized animal classes from this.

class Dog: Animal() {
    override fun move(): String {
        return "$name the dog is running and playing."
    }

    override fun speak(): String {
        return "$name the dog is barking."
    }
}

class Cat: Animal() {
    override fun move(): String {
        return "$name the cat is stalking its prey."
    }

    override fun speak(): String {
        return "$name the cat is meowing."
    }
}

class Bird: Animal() {
    override fun move(): String {
        return "$name the bird is flying."
    }

    override fun speak(): String {
        return "$name the bird is chirping."
    }
}

Using Interfaces for Polymorphism

Interfaces in Kotlin are used to define a set of abstract methods that must be implemented by a class that wants to implement the interface. Interfaces are similar to abstract classes, but they can only contain abstract methods and cannot contain any concrete methods with an implementation. We can also have properties in interfaces but they will only have the getter when accessed as an interface

Here is how we can define an Animal as an interface instead of an abstract class.

interface IAnimal {
    val name: String

    fun move(): String
    fun speak(): String
}

Now to create a concrete implementation of the above interface we will need to override move, speak and name. Here's how we can implement the above animals using interfaces:

class Dog (
    override val name: String
): IAnimal {
    override fun move(): String {
        return "$name the dog is running and playing."
    }

    override fun speak(): String {
        return "$name the dog is barking."
    }
}

class Cat(
    override val name: String
): IAnimal {
    override fun move(): String {
        return "$name the cat is stalking its prey."
    }

    override fun speak(): String {
        return "$name the cat is meowing."
    }
}

class Bird(
    override val name: String
): IAnimal {
    override fun move(): String {
        return "$name the bird is flying."
    }

    override fun speak(): String {
        return "$name the bird is chirping."
    }
}

Benefit of polymorphism

Now, the main benefit of polymorphism is ability to change form in runtime. Here's a sample of polymorphism in action

fun main() {    
    val animals: List<IAnimal> = listOf(
        Dog("Henry"),
        Cat("Tom"),
        Bird("Bubbles")
    )

    for (animal in animals) {
        println(animal.speak())
    }
}

The above code outputs:

As you can see we declared all the creatures with the type IAnimal but during runtime, they conform to their specific types i.e Dog, Cat and Bird

Conclusion

In conclusion, polymorphism and inheritance are important concepts in object-oriented programming languages like Kotlin. Polymorphism allows for flexibility and code reuse, as a single class can take on multiple forms and behave differently in different situations. Inheritance allows for the creation of new classes that are derived from existing ones, allowing for code reuse and organization.

Together, polymorphism and inheritance can be used to create complex and flexible object-oriented systems, making it easier to manage and maintain code. Developers need to understand these concepts and know how to use them effectively when designing and building applications.

Keep Coding!

In the previous article, we learned the foundations of object-oriented programming with Kotlin. We set up our development environment, installed Android Studio and the Android SDK, and explored the basic syntax of Kotlin, including variable declarations, data types, control flow, and defining and calling functions.

Now, we're ready to take our understanding of Kotlin a step further by exploring the basics of object-oriented programming in Kotlin. This article will go over how to define and use classes and objects in Kotlin, including constructors, properties, and methods.

But, before we get into the specifics, let's define exactly what we mean by "classes" and "objects."

What are classes and objects?

A class is a template that specifies the properties and behavior of a specific type of object. A class can have both properties (variables that store data) and methods (functions that perform actions).

An object is a class instance. When you create an object, you are essentially creating a specific instance of a class, complete with its own set of properties and methods. You can make multiple objects from the same class, each with its own set of properties and behaviors.

Classes and objects are useful for organizing and encapsulating code, as well as creating reusable components that can be reused throughout a program. They are a necessary tool for developing complex software applications.

Now that we've covered the fundamentals of classes and objects, let's look at why they are important for you as an android developer.

Why are classes and objects important for Android development?

As an Android developer, learning how to define and use classes and objects is essential for building efficient, maintainable, and scalable Android apps. Here are a few reasons why:

• Organization and structure: Classes and objects enable you to break down your code into logical units that are easier to understand and work with. This can assist you in writing more organized and maintainable code, particularly as your projects grow larger and more complex.

• Reusability: You can create reusable components that can be used in different parts of your app by defining classes and objects. You will save time and effort because you will not have to rewrite the same code over and over.

• Modularity: Classes and objects allow you to divide your code into self-contained units that can be tested and debugged independently. This can help you identify and fix bugs in your code, as well as add new features and functionality.

Overall, understanding classes and objects is an important step toward becoming a skilled Android developer. In the sections that follow, we'll look at how to define and use classes and objects in Kotlin so that you can use them in your Android projects.

Defining a class in Kotlin

In Kotlin, you can define a class by using the class keyword followed by the class name. For example, you could define a class called Person like this:

class Person {
    // class body
}

In the following sections, we'll look at how you can define the properties and methods of the class inside the class body.

You can also define a class with a primary constructor, which allows you to initialize the class with specific values when creating an object from it. We'll go over primary constructors in greater depth later in the article.

Defining class properties

You can define the class's properties within the class body by using the val or var keyword, followed by the property name and type. For example, you could define a String property called name as follows:

class Person {
    val name: String
}

You can also provide an initial value for the property by assigning it to a default value in the constructor. For example:

class Person(val name: String = "") {
    // class body
}

The name property is declared as a val in this instance, making it a read-only property that cannot be modified after initialization. Use the var keyword in its place to define a property that can be modified:

class Person {
    var age: Int
}

Properties in Kotlin are public by default, which means they can be accessed and modified from anywhere within the class and from outside the class. You can, however, use visibility modifiers to control the visibility and accessibility of your properties.

Here are the four visibility modifiers in Kotlin:

• private: A private property can only be accessed and modified within the class in which it's defined.

class Person {
    private val name: String
}

• protected: A protected property can only be accessed and modified within the class in which it is defined and any subclasses of that class.

class Person {
    protected val name: String
}

• internal: An internal property can be accessed and modified from anywhere within the same module (i.e. a set of compiled Kotlin files).

class Person {
    internal val name: String
}

• public: A public property can be accessed and modified from anywhere within the class as well as from outside the class. This is the default visibility in Kotlin.

class Person {
    public val name: String
}

You can control who can access and modify your properties by using visibility modifiers, which can help you write more secure and maintainable code.

Defining class methods

In addition to properties, methods can also be defined in a Kotlin class. A method is a function that executes a specific action and may or may not return a value.

In Kotlin, you define a method by using the fun keyword, followed by the method name, any arguments, and the return type (if applicable). For example, in the Person class, you could define a greet method that takes a name argument of type String and returns a String:

class Person {
    fun greet(name: String): String {
        return "Hello, $name!"
    }
}

You can also define methods that don't have any arguments or return values:

class Person {
    fun sayHello() {
        println("Hello!")
    }
}

Or you can define methods with default values for their arguments, which allows you to call the method with fewer arguments:

class Person {
    fun greet(name: String = "stranger"): String {
        return "Hello, $name!"
    }
}

Methods in Kotlin, like properties, are public by default, which means they can be called from anywhere within and outside the class. However, just like with properties, you can use visibility modifiers to control the visibility and accessibility of your methods.

We'll look at how to create objects from classes and use their properties and methods in the following section.

Creating objects

Now that we've gone over how to define classes, as well as their properties and methods, let's look at how to create objects from those classes.

You can create an object from a class in Kotlin by simply calling the class name with any necessary arguments. The basic syntax is as follows:

val obj = Person()

This will create a new object from the Person class and assign it to the obj variable. You can then access the object's properties and methods using the . operator:

val obj = Person()
val name = obj.name  // access the 'name' property
obj.sayHello()       // call the 'sayHello' method

If the class has a primary constructor, you can pass in arguments when you create the object to initialize its properties. For example:

class Person(val name: String, var age: Int) {
    // class body
}

val obj = Person("Alice", 25)

This creates a new Person object with the name "Alice" and age 25.

In the next section, we'll take a closer look at primary constructors and how to define them in Kotlin.

Constructors

Defining a primary constructor

To define a primary constructor for a class in Kotlin, use the constructor keyword. A primary constructor is a type of constructor that allows you to initialize a class with specific values when creating an object from it.

The constructor keyword is followed by any necessary arguments and the class body to define a primary constructor. For the Person class, for example, you could define a primary constructor that accepts a name and an age argument:

class Person constructor(val name: String, var age: Int) {
    // class body
}

This primary constructor allows you to initialize the name and age properties of the Person class when you create an object from it:

val obj = Person("Alice", 25)

It's also possible to define a primary constructor with default values for its arguments, which allows you to create objects with fewer arguments:

class Person constructor(val name: String = "", var age: Int = 0) {
    // class body
}

val obj1 = Person()      // name = "", age = 0
val obj2 = Person("Bob") // name = "Bob", age = 0

In the next section, we'll take a look at how to define and use secondary constructors in Kotlin.

Defining secondary constructors

Kotlin allows you to define secondary constructors for your classes in addition to primary constructors. A secondary constructor is defined in addition to the primary constructor and allows you to initialize the class in various ways.

The constructor keyword is followed by any necessary arguments and the class body to define a secondary constructor. For example, for the Person class, you could define a secondary constructor that takes a name argument and sets the age property to a default value:

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0) {
        // constructor body
    }
}

This secondary constructor allows you to create a new Person object with just the name property initialized:

val obj = Person("Alice")

It's also possible to define multiple secondary constructors, each with its own set of arguments and initialization logic. For example:

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0) {
        // constructor body
    }

    constructor(age: Int) : this("", age) {
        // constructor body
    }
}

val obj1 = Person("Alice") // name = "Alice", age = 0
val obj2 = Person(25)      // name = "", age = 25

Secondary constructors are useful when you want to provide multiple ways for your class to be initialized based on the data you have available.

In the following section, we'll look at how to use properties and methods from inside as well as outside the class.

Using class properties and methods

Now that we've covered how to define classes, their properties, and methods, let's look at how to use them both within and outside of the class.

Using class properties and methods within the class

To use a class property or method within the class, simply type this keyword followed by the name of the property or method. Here's an example:

class Person(val name: String, var age: Int) {
    fun sayHello() {
        println("Hello, my name is ${this.name} and I am ${this.age} years old.")
    }
}

In this example, the sayHello method uses the this.name and this.age properties to print a greeting.

Using class properties and methods from outside the class

To use a class property or method from outside the class, you use the . operator followed by the property or method name. Here's an example:

val obj = Person("Alice", 25)
val name = obj.name  // access the 'name' property
obj.sayHello()       // call the 'sayHello' method

In this example, the obj variable is an object from the Person class, and the name and sayHello properties and methods are accessed using the . operator.

Conclusion

We've now covered the fundamentals of Kotlin classes and objects! We've learned how to define classes, as well as their primary and secondary constructors, as well as how to create objects from those classes and use class properties and methods.

In the next article in this series, we'll delve even deeper into the world of Kotlin by looking at inheritance and polymorphism. We'll see how to use abstract classes and interfaces to define common methods and properties that can be implemented by multiple classes, as well as how to use polymorphism to allow objects to change forms at runtime.

Stay tuned for more exciting adventures in Android development with Kotlin!

In this article, we'll be introducing you to the basics of Kotlin and getting you set up for success in your Android development journey. We'll cover everything from setting up your development environment to learning the ins and outs of Kotlin syntax.

But before we dive in, let's talk about why Kotlin is such an important language for Android developers. Simply put, Kotlin is a modern, powerful language that makes it easy to build beautiful, efficient apps. It's concise, expressive, and fully interoperable with Java, which means you can use it alongside your existing Java code. Plus, it's been officially supported by Google as a first-class language for Android development since 2017, so you can be confident that it's here to stay.

So, are you ready to take the first step toward becoming a Kotlin pro? Great! Let's get started.

Setting up the development environment

Before we can start writing Kotlin code, we need to set up our development environment. Here's what you'll need:

• A computer with an operating system that supports Android development, such as Windows, macOS, or Linux

• The Android Studio IDE (Integrated Development Environment)

• The Android SDK (Software Development Kit)

Installing Android Studio

First, let's install Android Studio. Here's how:

1. Go to the Android Studio website (https://developer.android.com/studio)

2. Click the "Download Android Studio" button

3. Follow the prompts to install Android Studio on your computer

Once the installation is complete, you can open Android Studio by double-clicking the icon on your desktop or finding it in your start menu (on Windows) or applications folder (on macOS).

Installing the Android SDK

The Android SDK is a collection of tools that you'll need to build Android apps. It includes everything from the Android operating system to a variety of libraries and tools that you can use to develop your apps.

To install the Android SDK:

1. Open Android Studio

2. Click on the "Welcome to Android Studio" screen

3. Click the "Install SDK Platforms" button

4. Select the latest versions of the Android operating system and the Google Play system image, and click "Apply"

5. Click the "Install Build Tools" button

6. Select the latest version of the Android build tools and click "Apply"

That's it! You're now ready to start developing Android apps with Kotlin. In the next section, we'll cover the basics of Kotlin syntax.

Basic Kotlin Syntax

Now that we have our development environment set up, it's time to start learning some Kotlin! If you're familiar with other programming languages, you'll find that Kotlin is easy to pick up. But even if you're new to programming, don't worry – we'll go over everything step by step.

Variable declarations

In Kotlin, you can use the var keyword to declare a mutable variable, and the val keyword to declare an immutable variable. Here's an example:

var greeting = "Hello"
greeting = "Hi" // this is allowed

val answer = 42
answer = 43 // this is not allowed

Data types

In Kotlin, you don't have to specify the type of a variable – the compiler can usually infer it from the value you assign to it. But you can also specify the type if you want to be explicit. Here are some of the basic data types in Kotlin:

• Int: for whole numbers

• Double: for numbers with decimal points

• String: for text

• Boolean: for true/false values

Here's an example of declaring variables with different data types:

val i = 42 // inferred as Int
val d = 3.14 // inferred as Double
val s = "Hello" // inferred as String
val b = true // inferred as Boolean

Please note that each of the above data types has a nullable counterpart. But we will discuss nullability in Kotlin in a future article.

String Templates

Kotlin provides string templates as a way to embed expressions within string literals. String templates start with a dollar sign ($) and can contain either a simple name or an expression in curly braces.

Here is an example of using a string template to print out a message:

val name = "John"
println("Hello, $name!") // Hello, John!

In addition to simple names, string templates can also contain expressions. The expression is evaluated and its result is converted to a string and inserted into the string. Here is an example of using an expression in a string template:

val a = 10
val b = 20
println("The sum of $a and $b is ${a + b}.") 
// The above line outputs:
// The sum of 10 and 20 is 30.

String templates are a useful feature of Kotlin that can make it easier to build strings that contain dynamic content. They can be used in a variety of contexts, such as when constructing SQL queries or building user interfaces.

Conditionals

In Kotlin, you can use conditional statements such as if-else and when to execute code based on certain conditions. Here's an example of an if-else statement:

val num = 42
if (num % 2 == 0) {
    println("Even")
} else {
    println("Odd")
}

And here's an example of a when statement:

val fruit = "apple"
when (fruit) {
    "apple" -> println("red")
    "banana" -> println("yellow")
    else -> println("unknown")
}

Loops

Kotlin has a variety of loops that can be used to execute a block of code multiple times.

The for loop is used to iterate over a range of values or an array. Here is an example of using a for loop to print out the numbers from 1 to 10:

for (i in 1..10) {
    println(i)
}

In the above piece of code, 1..10 is a range, it returns a list of numbers (well, kind of) from 1 to 10. We'll learn more about ranges in a future article.

The while loop is used to execute a block of code as long as a certain condition is true. Here is an example of using a while loop to print out the numbers from 1 to 10:

var i = 1
while (i <= 10) {
    println(i)
    i++
}

The do-while loop is similar to the while loop, but the block of code is always executed at least once. Here is an example of using a do-while loop to print out the numbers from 1 to 10:

var i = 1
do {
    println(i)
    i++
} while (i <= 10)

Kotlin also has a forEach loop that can be used to iterate over the elements of a collection. Here is an example of using a forEach loop to print out the elements of a list:

val list = listOf("apple", "banana", "cherry")
list.forEach { println(it) }

In addition to these loops, Kotlin also has the break and continue statements, which can be used to exit a loop early or skip to the next iteration of the loop, respectively.

That's just a taste of the basics of Kotlin syntax. In the next section, we'll look at how to define and call functions in Kotlin.

Kotlin Functions

In Kotlin, you can use functions to organize your code and reuse it throughout your app. Here's how to define and call functions in Kotlin:

Defining functions

To define a function in Kotlin, you use the fun keyword followed by the function name, a list of parameters (enclosed in parentheses), and a block of code (enclosed in curly braces). Here's an example:

fun sayHello(name: String) {
    println("Hello, $name!")
}

You can also specify the return type of a function by using the : symbol followed by the type. If a function doesn't return anything, you can use the Unit type, which is equivalent to void in Java. Here's an example of a function that returns a value:

fun add(x: Int, y: Int): Int {
    return x + y
}

And here's an example of a function that doesn't return anything:

fun printSum(x: Int, y: Int): Unit {
    println(x + y)
}

Calling functions

To call a function in Kotlin, you simply use the function name followed by the arguments (enclosed in parentheses). Here's an example:

sayHello("Alice") // prints "Hello, Alice!"

val sum = add(3, 4) // sum is 7
printSum(5, 6) // prints 11

Default Arguments and Named Arguments

You can also use default and named arguments to make your functions more flexible.

Default arguments allow you to specify default values for parameters, which means you don't have to specify those values when calling the function.

Named arguments allow you to specify the parameter names when calling the function, which can make it easier to understand the code.

Here's an example of using default and named arguments:

fun greet(greeting: String = "Hello", name: String) {
    println("$greeting, $name!")
}

greet("Hi", "Bob") // prints "Hi, Bob!"
greet(name = "Alice") // prints "Hello, Alice!"

That's a brief overview of how to define and call functions in Kotlin. In the next section, we'll look at how to define and use classes and objects in Kotlin.

Conclusion

Congratulations – you now have a solid foundation in the basics of Kotlin syntax! You've learned how to declare variables, use control flow statements, and define and call functions.

In the next article, we'll dive deeper into Kotlin by exploring classes and objects. You'll learn how to define your own classes, create objects from those classes, and use inheritance and polymorphism to create more complex and powerful code.

So don't stop now – keep learning and practicing, and you'll be on your way to becoming a Kotlin pro in no time!

First, let's start by setting up our project for Jetpack Compose. If you're new to Jetpack Compose, you can check out the official documentation for more information on getting started.

Next, let's create a Theme.kt file to hold our theme state. This file will be responsible for storing the current theme and providing a method for toggling between the light and dark themes.

data class ThemeState(var theme: Theme) {
    fun toggleTheme() {
        theme = if (theme == Theme.Light) Theme.Dark else Theme.Light
    }
}

enum class Theme {
    Light, Dark
}

Now that we have our theme state set up, let's create a button that will allow us to toggle between the light and dark themes. We'll use the @Composable annotation to define a function that will be responsible for rendering the button.

@Composable
fun ToggleThemeButton() {
    val themeState = remember { ThemeState(Theme.Light) }
    Button(onClick = { themeState.toggleTheme() }) {
        Text("Toggle Theme")
    }
}

Finally, we'll need to apply the current theme to our app. We can do this by wrapping our app's content in a MaterialTheme component and setting the theme attribute based on the current value of our ThemeState.

@Composable
fun App() {
    val themeState = remember { ThemeState(Theme.Light) }
    MaterialTheme(
        theme = if (themeState.theme == Theme.Light) lightTheme else darkTheme
    ) {
        // app content goes here
    }
}

That's it! With these steps, you should now have a working light/dark theme toggle in your Android app using Jetpack Compose. You can customize the theme and the toggle button to fit the needs of your app.

I hope this article helps you build a light/dark theme toggle with Jetpack Compose in Android. Let me know if you have any questions or need further clarification on any of the steps.

Are you tired of dealing with pesky type errors in your Android app? Fear not, Kotlin's sealed classes are here to save the day! Sealed classes are a special type of class that can only have a limited number of subclasses, or sealed subclasses. This feature helps to prevent unexpected or invalid types from sneaking into your code and causing problems.

In this article, we'll dive into the world of sealed classes and how they can be used to improve type safety in your Android app. We'll cover the basics of creating and implementing sealed classes, as well as the benefits of using them. We'll also provide some examples of sealed classes in action and offer tips for using them effectively in your Android projects. So buckle up and get ready to say goodbye to those pesky type errors!

What are Sealed Classes in Kotlin?

Sealed classes in Kotlin are a bit like the popular children's game "20 Questions." Just like in the game, sealed classes allow you to create a limited set of options (or subclasses) and then narrow down the possibilities until you find the correct answer (or subclass).

To create a sealed class in Kotlin, you simply use the sealed keyword followed by the class definition. For example:

sealed class Shape {
    class Circle(val radius: Double): Shape()
    class Rectangle(val width: Double, val height: Double): Shape()
    class Triangle(val base: Double, val height: Double): Shape()
}

In this example, the Shape class is the sealed class and Circle, Rectangle, and Triangle are its sealed subclasses. Notice that each sealed subclass must be defined inside the body of the sealed class and must also extend the sealed class.

Unlike traditional inheritance hierarchies, a sealed class can only have a fixed number of subclasses, which must be explicitly listed in the sealed class definition. This helps to ensure that all possible cases are covered and prevents the possibility of unexpected or invalid subclasses.

Using sealed classes in Android can help to improve code readability and organization, as well as simplify null handling and error checking. We'll delve into these benefits in more detail later on in the article. So, the next time you're trying to figure out the shape of an object in your Android app, just think of sealed classes as your very own "20 Questions" game!

Benefits of Using Sealed Classes in Android

Sealed classes in Kotlin are a real treat for Android developers. Not only do they help to improve type safety in your code, but they also make it easier to keep your code clean, organized, and bug-free. Here are just a few of the benefits of using sealed classes in Android:

• Improved type safety: With sealed classes, you can be sure that your code is handling all possible cases and won't break when an unexpected or invalid type is encountered. This can save you a lot of headaches and debugging time in the long run.

• Enhanced code readability and organization: Sealed classes allow you to group related types together and clearly define their relationships. This makes your code easier to understand and navigate, especially for other developers working on the same codebase.

• Simplified null handling and error checking: Sealed classes can help to reduce the risk of null reference errors by ensuring that all possible cases are covered. This can make your code more robust and reliable, especially in situations where null values are expected or allowed.

So the next time you're feeling overwhelmed by the chaos of Android development, just remember that sealed classes are here to help! With their powerful type-safety features and code organization benefits, sealed classes are the ultimate code superheroes. Go forth and conquer those bugs and null references with the power of Kotlin's sealed classes!

How to Use Sealed Classes in Android

Ready to unleash the full power of sealed classes in your Android app? Here's how to get started:

Creating a sealed class and its subclasses

To create a sealed class in Kotlin, use the sealed keyword followed by the class definition. Inside the body of the sealed class, define its sealed subclasses by extending the sealed class. Here's an example of a sealed class with three sealed subclasses:

sealed class PaymentMethod {
    class CreditCard(val cardNumber: String, val expirationDate: String, val cvv: String): PaymentMethod()
    class DebitCard(val cardNumber: String, val expirationDate: String, val cvv: String): PaymentMethod()
    class Paypal(val email: String): PaymentMethod()
}

Implementing sealed classes in functions and when expressions

Once you've created a sealed class and its subclasses, you can use them in your code by matching on the sealed subclasses with a when expression. For example, you might use a sealed class to represent different payment methods in an e-commerce app, like this:

fun processPayment(paymentMethod: PaymentMethod, amount: Double) {
    when (paymentMethod) {
        is PaymentMethod.CreditCard -> println("Charging $${amount} to credit card ${paymentMethod.cardNumber}.")
        is PaymentMethod.DebitCard -> println("Charging $${amount} to debit card ${paymentMethod.cardNumber}.")
        is PaymentMethod.Paypal -> println("Charging $${amount} to Paypal account ${paymentMethod.email}.")
    }
}

In this function, the when expression is used to match on the different sealed subclasses of PaymentMethod. Based on the subclass that is passed to the function, a different message is printed out indicating the payment method being used.

Tips and best practices for working with sealed classes

Here are a few tips and best practices for working with sealed classes in Android:

• Make sure to list all possible sealed subclasses in the sealed class definition. This will help to ensure that all cases are covered and prevent the possibility of unexpected or invalid subclasses.

• Use descriptive names for your sealed subclasses to make your code more readable and easier to understand.

• Consider using sealed classes to represent mutually exclusive types in your code. For example, you might use a sealed class to represent different states in a state machine or different error conditions in an error-handling system.

• Remember that sealed classes are a great way to improve code readability and organization, as well as reduce the risk of null reference errors and other types of bugs. So don't be afraid to use them liberally in your Android projects!

With these tips and best practices in mind, you'll be well on your way to mastering the art of sealed classes in Android.

Conclusion

In conclusion, sealed classes in Kotlin are like a trusty shield for your Android code. They protect you from all the pesky type errors and null reference demons that haunt your codebase, keeping your app running smoothly and your sanity intact.

Using sealed classes is super easy and can make a huge difference in the organization and reliability of your code. They're particularly handy when you need to handle a bunch of different cases, like filtering a list of articles by category or processing a payment with a specific payment method.

So don't be afraid to wield the power of sealed classes in your Android development journey. With their type-safety superpowers and code organization skills, sealed classes are the ultimate code heroes. Go forth and conquer those bugs and null references with the power of Kotlin's sealed classes!

Happy coding!

Why Refactor?

There are several reasons why you might want to refactor your code:

1. Improve readability: Refactoring can make your code more readable by applying consistent naming conventions, breaking up long methods into smaller ones, and organizing code into logical units.

2. Reduce complexity: Refactoring can help to reduce the complexity of your code by identifying and removing unnecessary elements, such as redundant code or dead code.

3. Improve maintainability: Refactoring can make it easier to maintain and update your code by improving its structure and organization.

4. Improve performance: Refactoring can also improve the performance of your code by identifying and optimizing bottlenecks or inefficiencies.

TLDR

1. Rename - Shift + F6

2. Extract Method - Ctrl + Alt + M

3. Extract Variable - Ctrl + Alt + V

4. Extract Constant - Ctrl + Alt + C

5. Inline - Ctrl + Alt + N

6. Change Signature - Ctrl + F6

7. Extract Interface - Ctrl + Alt + B

Refactoring Tools in Android Studio

Android Studio provides several built-in tools to help you refactor your code. These tools can be accessed through the Refactor menu or by using keyboard shortcuts.

Rename

The Rename refactoring tool allows you to change the name of a symbol (e.g., a class, method, or variable) throughout your code. To use it, simply right-click on the symbol and select Refactor > Rename. Alternatively, you can use the keyboard shortcut Shift + F6.

Extract Method

The Extract Method refactoring tool allows you to extract a block of code into a separate method. This can help to reduce the complexity of your code by breaking up long methods into smaller, more manageable chunks. To use it, select the code you want to extract, then right-click and select Refactor > Extract > Method. Alternatively, you can use the keyboard shortcut Ctrl + Alt + M.

Extract Variable

The Extract Variable refactoring tool allows you to extract a value or expression into a separate variable. This can help to improve the readability of your code by giving names to complex expressions or values that are used multiple times. To use it, select the value or expression you want to extract, then right-click and select Refactor > Extract > Variable. Alternatively, you can use the keyboard shortcut Ctrl + Alt + V.

Extract Constant

The Extract Constant refactoring tool is similar to Extract Variable, but it creates a constant instead of a variable. Constants are useful for values that are used frequently and are not expected to change, such as hardcoded strings or magic numbers. To use it, select the value you want to extract, then right-click and select Refactor > Extract > Constant. Alternatively, you can use the keyboard shortcut Ctrl + Alt + C.

Inline

The Inline refactoring tool allows you to replace a method or variable with its body or value, respectively. This can be useful when you have a small or simple method or variable that is not being used elsewhere and is adding unnecessary complexity to your code. To use it, right-click on the method or variable and select Refactor > Inline. Alternatively, you can use the keyboard shortcut Ctrl + Alt + N.

Change Signature

The Change Signature refactoring tool allows you to modify the signature of a method, including its name, return type, and parameters. This can be useful when you want to rename a method or change its parameters to better reflect its functionality. To use it, right-click on the method and select Refactor > Change Signature. Alternatively, you can use the keyboard shortcut Ctrl + F6.

Extract Interface

The Extract Interface refactoring tool allows you to extract the common characteristics of a group of classes into a separate interface. This can help to improve the design of your code by promoting code reuse and abstraction. To use it, select the classes you want to extract, then right-click and select Refactor > Extract > Interface. Alternatively, you can use the keyboard shortcut Ctrl + Alt + B.

Conclusion

In this article, we learned about the importance of refactoring in software development and how to use the refactoring tools in Android Studio to improve the quality of our code. By applying these techniques, we can make our code more readable, maintainable, and efficient, which can save time and effort in the long run.

Remember to always test your code thoroughly after refactoring to ensure that the changes you made did not introduce any unintended bugs or side effects.

By regularly incorporating refactoring into your workflow, you can keep your codebase in top shape and make it easier for yourself and others to work with. Happy refactoring!

To create a search view in Jetpack Compose, we need to define three functions: ExpandableSearchView, CollapsedSearchView, and ExpandedSearchView. The ExpandableSearchView function will contain the logic for expanding and collapsing the search view, while the CollapsedSearchView and ExpandedSearchView functions will define the appearance and behavior of the search view when it is collapsed and expanded, respectively.

First, let's define the ExpandableSearchView function. It should take the following arguments:

• searchDisplay: This is the string that is displayed in the search field when it is collapsed.

• onSearchDisplayChanged: This is a lambda function that is called when the search display is changed. You can use this function to update the UI or perform a search based on the new search display.

• onSearchDisplayClosed: This is a lambda function that is called when the search display is closed. You can use this function to reset the search display or clear the search results.

• modifier: This is an optional argument that allows you to specify a Modifier for the search view.

• expandedInitially: This is an optional argument that specifies whether the search view should be expanded initially. The default value is false.

• tint: This is an optional argument that specifies the color of the search icon and the text in the search field. The default value is the onPrimary color from the MaterialTheme.

Here's the code for the ExpandableSearchView function:

@Composable
fun ExpandableSearchView(
    searchDisplay: String,
    onSearchDisplayChanged: (String) -> Unit,
    onSearchDisplayClosed: () -> Unit,
    modifier: Modifier = Modifier,
    expandedInitially: Boolean = false,
    tint: Color = MaterialTheme.colors.onPrimary
) {
    val (expanded, onExpandedChanged) = remember {
        mutableStateOf(expandedInitially)
    }


    Crossfade(targetState = expanded) { isSearchFieldVisible ->
        when (isSearchFieldVisible) {
            true -> ExpandedSearchView(
                searchDisplay = searchDisplay,
                onSearchDisplayChanged = onSearchDisplayChanged,
                onSearchDisplayClosed = onSearchDisplayClosed,
                onExpandedChanged = onExpandedChanged,
                modifier = modifier,
                tint = tint
            )

            false -> CollapsedSearchView(
                onExpandedChanged = onExpandedChanged,
                modifier = modifier,
                tint = tint
            )
        }
    }
}

The ExpandableSearchView function uses a Crossfade component to switch between the collapsed and expanded states of the search view. When the search view is collapsed, it displays the CollapsedSearchView component. When the search view is expanded, it displays the ExpandedSearchView component.

Next, we need to define the CollapsedSearchView and ExpandedSearchView components.

The CollapsedSearchView component is a simple row that displays a text label and a search icon button. When the search icon button is clicked, the CollapsedSearchView component calls the onExpandedChanged lambda function to expand the search view.

Here is the code for the CollapsedSearchView component:

@Composable
fun CollapsedSearchView(
    onExpandedChanged: (Boolean) -> Unit,
    modifier: Modifier = Modifier,
    tint: Color = MaterialTheme.colors.onPrimary,
) {

    Row(
        modifier = modifier
            .fillMaxWidth()
            .padding(vertical = 2.dp),
        horizontalArrangement = Arrangement.SpaceBetween,
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            text = "Tasks",
            style = MaterialTheme.typography.h6,
            modifier = Modifier
                .padding(start = 16.dp)
        )
        IconButton(onClick = { onExpandedChanged(true) }) {
            SearchIcon(iconTint = tint)
        }
    }
}

The ExpandedSearchView component is a row that contains a back icon button and a text field for entering the search query. The text field is bound to the searchDisplay variable, so any changes to the search query will be reflected in the searchDisplay variable and the onSearchDisplayChanged lambda function will be called. When the user clicks the back icon button or hits the "done" button on the keyboard, the ExpandedSearchView component calls the onSearchDisplayClosed lambda function and collapses the search view.

Here is the code for the ExpandedSearchView component:

@Composable
fun ExpandedSearchView(
    searchDisplay: String,
    onSearchDisplayChanged: (String) -> Unit,
    onSearchDisplayClosed: () -> Unit,
    onExpandedChanged: (Boolean) -> Unit,
    modifier: Modifier = Modifier,
    tint: Color = MaterialTheme.colors.onPrimary,
) {
    val focusManager = LocalFocusManager.current

    val textFieldFocusRequester = remember { FocusRequester() }

    SideEffect {
        textFieldFocusRequester.requestFocus()
    }

    var textFieldValue by remember {
        mutableStateOf(TextFieldValue(searchDisplay, TextRange(searchDisplay.length)))
    }

    Row(
        modifier = modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.Start,
        verticalAlignment = Alignment.CenterVertically
    ) {
        IconButton(onClick = {
            onExpandedChanged(false)
            onSearchDisplayClosed()
        }) {
            Icon(
                painter = painterResource(id = R.drawable.ic_back),
                contentDescription = "back icon",
                tint = tint
            )
        }
        TextField(
            value = textFieldValue,
            onValueChange = {
                textFieldValue = it
                onSearchDisplayChanged(it.text)
            },
            trailingIcon = {
                SearchIcon(iconTint = tint)
            },
            modifier = Modifier
                .fillMaxWidth()
                .focusRequester(textFieldFocusRequester),
            label = {
                Text(text = "Search", color = tint)
            },
            keyboardOptions = KeyboardOptions(
                imeAction = ImeAction.Done
            ),
            keyboardActions = KeyboardActions(
                onDone = {
                    focusManager.clearFocus()
                }
            )
        )
    }
}

Finally, we need to define a SearchIcon function that creates an icon for the search view. This function takes a iconTint argument to specify the color of the icon.

@Composable
fun SearchIcon(iconTint: Color) {
    Icon(
        painter = painterResource(id = R.drawable.ic_search),
        contentDescription = "search icon",
        tint = iconTint
    )
}

With these functions defined, we can now use the ExpandableSearchView to create an expandable search view in Jetpack Compose. To do this, simply call the ExpandableSearchView function and pass the necessary arguments.

That's it! You should now have a working expandable search view in Jetpack Compose. You can customize the appearance and behavior of the search view by modifying the ExpandableSearchView, CollapsedSearchView, and ExpandedSearchView functions as needed.

I hope this tutorial has helped you understand how to create an expandable search view in Jetpack Compose. If you have any questions or comments, feel free to leave them below.

In this article, we will discuss two important data structures in Kotlin: Array and ArrayList. These data structures are used to store and manipulate collections of data in Kotlin.

Array

An array is a collection of elements that are stored in a contiguous block of memory. All elements in an array must be of the same type. In Kotlin, arrays are represented by the Array class, which has a fixed size and provides indexed access to its elements.

Here is an example of how to create and initialize an array in Kotlin:

val numbers = arrayOf(1, 2, 3, 4, 5)

In this example, we have created an array of integers called numbers. The arrayOf function is used to create an array and initialize it with the given elements.

We can also create an array of a specific size and type using the arrayOfNulls function:

val names = arrayOfNulls<String>(5)

This creates an array of strings called names with a size of 5. All elements in the array are initialized to null.

We can access the elements of an array using the index operator ([]):

val firstNumber = numbers[0]  // firstNumber will be 1
val thirdNumber = numbers[2]  // thirdNumber will be 3

We can also use the for loop to iterate over the elements of an array:

for (number in numbers) {
    println(number)
}

This will print all the elements of the numbers array on separate lines.

One important thing to note about arrays in Kotlin is that they are mutable, meaning that we can change the elements of the array after it has been created. Here is an example of how to change the elements of an array:

numbers[0] = 10  // the first element of the array is now 10

ArrayList

An ArrayList is a resizable array implementation of the List interface. It is similar to an array, but it can grow or shrink as needed to accommodate the elements being added or removed. In Kotlin, ArrayList is represented by the ArrayList class.

Here is an example of how to create and initialize an ArrayList in Kotlin:

val numbers = arrayListOf(1, 2, 3, 4, 5)

In this example, we have created an ArrayList of integers called numbers. The arrayListOf function is used to create an ArrayList and initialize it with the given elements.

We can also create an empty ArrayList and add elements to it later:

val names = ArrayList<String>()
names.add("Alice")
names.add("Bob")
names.add("Charlie")

We can access the elements of an ArrayList using the index operator ([]) or the get function:

val firstName = names[0]  // firstName will be "Alice"
val thirdName = names.get(2)  // thirdName will be "Charlie"

We can also use the for loop to iterate over the elements of an ArrayList:

for (name in names) {
    println(name)
}

This will print all the elements of the names ArrayList on separate lines.

We can add or remove elements from an ArrayList using the add and remove functions:

names.add("David")  // the names ArrayList now contains ["Alice", "Bob", "Charlie", "David"]
names.remove("Bob")  // the names ArrayList now contains ["Alice", "Charlie", "David"]

We can also use the clear function to remove all elements from an ArrayList:

names.clear()  // the names ArrayList is now empty

One important thing to note about ArrayList is that it is mutable, meaning that we can change the elements of the ArrayList after it has been created.

In summary, Array and ArrayList are important data structures in Kotlin that are used to store and manipulate collections of data. While both are similar in many ways, ArrayList is more flexible and can grow or shrink as needed, while Array has a fixed size. Both are mutable, which means that we can change the elements of the collection after it has been created.

Anatomy of a basic Linux prompt

• In lines 1 and 2, we see hardik@nitro5-fedora. Here hardik is the username of the logged-in user and nitro5-fedora is the name of the pc.
• In line 1, ~ indicates that we are in the home directory.
• In line 2, / indicates that we are at the root of the filesystem.
• The $ symbol indicates that you are interacting with the system as a regular user. If you have sudo privileges, the $ turns into a #.

NOTE: From here on now, I’ll be using zsh instead of bash. But don't go away just yet. The commands discussed here work just the same on bash as well. :P

Some basic Linux commands

date

date command is used to show the current system date and time.

ls

ls command lists the files present in the current directory.

Let’s take a look at some important flags for ls command

• -R

  This flag lists the files recursively i.e. it will also list the file present in subdirectories and their subdirectories and so on

  Here’s a sample

  

• -l

  This flag shows some additional information about the files like permission string, owner, group of the owner, file size in bytes

  

• -a

  This flag lists hidden files as well

  

cat

cat command is used to display, copy, combine and create new files.

• Creating new files

  

• Viewing a file

  

• Combining two files

  

pwd

pwd stands for print working directory and does the same.

rm

rm is used to delete files. rmdir can be used to delete directories.

You can use -rf flag to delete a directory recursively.

cd

cd stands for change directory and is used to do the same.

Please ignore the warnings. They are related to my prompt configuration.

Some important cd commands

• cd .. is used to navigate to one level up in file system.
• cd ~ navigates you to your home folder.

mkdir

mkdir is used to create a new directory.

mv

mv stands for move. It is used to move files around the file system. It can also be used to rename files

SYNTAX

mv [OPTIONS] source destination

cp

cp stands for copy and is used to copy files and folders

SYNTAX

cp [OPTIONS] source destination

man

man command is used to access documentation of the commands that are available in the os. Here is a sample

man curl

To exit this page, press q

history

history command shows the commands used in this terminal session.

clear

clear command clears the terminal. In modern terminal emulators, you can press Ctrl + L to do the same.

Hope you liked this short article. See you next time. :D

Here's an overview of what we'll be doing.

• We'll create a classic "Hello, World!" program with functions
• We'll write a function to get Covid-19 stats from Covid19Api
• We'll build an android app around the above function

Before we start, if you like to dive directly into the code, here's the github repo

Creating a new Appwrite project

Before we dive into creating functions, let's set up a new Appwrite project to which we will add our functions. If you already have an appwrite project you can skip this section.

To get Appwrite up and running, follow these instructions and create a new account.

Next, follow the onscreen instructions to create a new project -

Hello World with Appwrite Functions

This is a pretty basic project to implement but it will make us familiar with the process of creating a new Appwrite Function. Let's get started -

First of all, we need a new Kotlin project, I'm going to use Intellij Idea as an IDE with gradle build system.

Here's the configuration I'm using to create a new project -

Next, let's create a new file named Main.kt in hello-world/src/main/kotlin and put the following code in it -

fun main() {
    println("Hello, world!")
}

...and we are done!

Now let's add this to an Appwrite function.

Appwrite requires us to create a "fat jar" which is just a fancy way of saying that we need to include all runtime dependencies in our jar file. To achieve this we have to add the following lines to build.gradle.kts -

tasks.withType<Jar>() {
    manifest {
        attributes["Main-Class"] = "MainKt"
    }

    from(sourceSets.main.get().output)

    dependsOn(configurations.runtimeClasspath)
    from({
        configurations.runtimeClasspath.get()
            .filter { it.name.endsWith("jar") }
            .map { zipTree(it) }
    })
}

These lines basically instruct Gradle to build a "fat jar". Now to actually build a jar, we need to run the following task -

This will create the required jar file in hello-world/build/libs/hello-world-1.0-SNAPSHOT.jar

Now, to upload this to Appwrite we need to package this in a tar file. To do this run the following command inside the libs directory -

tar -zcvf code.tar.gz .\hello-world-1.0-SNAPSHOT.jar

This will create a file named code.tar.gz in the libs directory. We will need this file later.

Creating a new Appwrite Function

Now, let's create a new appwrite function from the appwrite console. Navigate to Functions tab on Left pane, and click on Add Function button. Give it a name, in this case I'm using hello-world, and for the runtime, choose Java 16.0

Next, let's create a new deploy tag -

Here's the Command -

java -jar hello-world-1.0-SNAPSHOT.jar

Here we upload the tar file we created earlier. Click Activate and voila, we're done. :D

Let's test out the function. Click on Execute Now we don't need to pass any data to this function. Navigate to logs and check the output

And you just created your first appwrite function. Cheers 🍻

A little upgrade

Now let's make this function a little more useful. Instead of printing Hello, world! all the time, we'll pass a name to this function.

A note on APPWRITE_FUNCTION_DATA and APPWRITE_FUNCTION_EVENT_DATA

As mentioned in the documentation, these environment variables contains the information pertinent to execution of a custom appwrite function.

We use APPWRITE_FUNCTION_DATA when we trigger the function through Appwrite console or via SDK or HTTP API. This variable contains the data passed in those executions.

APPWRITE_FUNCTION_EVENT_DATA is used when the function is triggered by some event like inserting a new document. This variable contains information regarding that event.

Let's get back to the upgrade

Now we need to read the name from the APPWRITE_FUNCTION_DATA variable, to do this we add a new function -

fun getNameFromEnv(): String =
    System.getenv("APPWRITE_FUNCTION_DATA")

and update the println statement as follows -

println("Hello, ${getNameFromEnv()}!")

Let's build the jar and add a new deploy tag to our appwrite console. You can follow the same instructions from above. And then execute the function passing you name as input.

Let's test it out.

Yay! We're done. 🚀

Display Covid-19 stats

By creating the previous project, we got familiar with the process of creating a new Appwrite function with Kotlin. Now, let's build another project which is a little more complex. In this project, we'll see how we can integrate an Appwrite Function with a third-party API. Let's get started.

We will be using Covid19Api to get the data.

Before we dive into implementing the function, let's take a quick look at the requirements of what we'll be building -

• First, we need to read the country from APPWRITE_FUNCTION_DATA.
• Now, we need to check if the country is valid.
• If the country is valid, we return the stats for that country.
• If the country is not valid, we return global stats, with a message indicating the country was not valid.

Let's first create a new project. I'll name it get-covid-stats. Then we need a Main.kt file in get-covid-stats/src/main/kotlin.

Now we need to read the country name from APPWRITE_FUNCTION_DATA. Let's do that -

fun readCountryFromEnv(): String = 
    System.getenv("APPWRITE_FUNCTION_DATA")

and in main let's call it -

suspend fun main() {
    val country = readCountryFromEnv()
}

Next, we need to install some dependencies. We need to make Network Requests for that, I'm going to use Ktor HTTP Client and to parse json let's use kotlinx.serialization. If you don't know these libraries, don't worry, I'll explain how they work. To install these dependencies add the following lines to build.gradle.kts -

dependencies {
    // ....
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.0")
    implementation("io.ktor:ktor-client-core:1.6.4")
    implementation("io.ktor:ktor-client-cio:1.6.4")
    implementation("io.ktor:ktor-client-serialization:1.6.4")
}

There is one more line we need to add for kotlinx.serialization to work properly. You can read more about it here. Let's add the following line to build.gradle.kts -

plugins {
    // ...
    kotlin("plugin.serialization") version "1.5.31"
}

Next, we need some classes to hold responses we receive from Covid19Api. We'll save the classes in model package. Let's create them -

First, let's create an interface with data we need to return in get-covid-stats/src/main/kotlin/model/ICovidStats.kt

package model

interface ICovidStats {
    val newConfirmed: Int
    val totalConfirmed: Int
    val newDeaths: Int
    val totalDeaths: Int
    val newRecovered: Int
    val totalRecovered: Int
}

Now, if we take a look at data returned from the endpoint we see we need three classes Response.kt, GlobalStats.kt and CountryStats.kt. Let's create them -

// GlobalStats.kt

package model

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class GlobalStats(
    @SerialName("NewConfirmed") override val newConfirmed: Int,
    @SerialName("TotalConfirmed") override val totalConfirmed: Int,
    @SerialName("NewDeaths") override val newDeaths: Int,
    @SerialName("TotalDeaths") override val totalDeaths: Int,
    @SerialName("NewRecovered") override val newRecovered: Int,
    @SerialName("TotalRecovered") override val totalRecovered: Int,
) : ICovidStats

@Serializable tells kotlinx.serialization that this class can be parsed to/from JSON and @SerialName is used to indicate the JSON field name.

// CountryStats.kt

package model

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class CountryStats(
    @SerialName("Country") val country: String,
    @SerialName("CountryCode") val countryCode: String,
    @SerialName("Slug") val slug: String,
    @SerialName("NewConfirmed") override val newConfirmed: Int,
    @SerialName("TotalConfirmed") override val totalConfirmed: Int,
    @SerialName("NewDeaths") override val newDeaths: Int,
    @SerialName("TotalDeaths") override val totalDeaths: Int,
    @SerialName("NewRecovered") override val newRecovered: Int,
    @SerialName("TotalRecovered") override val totalRecovered: Int,
) : ICovidStats

// Response.kt

package model

import kotlinx.serialization.Serializable
import kotlinx.serialization.SerialName

@Serializable
data class Response(
    @SerialName("Global") val global : GlobalStats,
    @SerialName("Countries") val countries : List<CountryStats>,
)

Okay 🤯, these are the response models we need.

We also need an object which we will return from this function. Let's do that -

// FunctionResult.kt

package model

import kotlinx.serialization.Serializable

@Serializable
data class FunctionResult(
    val isGlobal: Boolean,
    val newConfirmed: Int,
    val totalConfirmed: Int,
    val newDeaths: Int,
    val totalDeaths: Int,
    val newRecovered: Int,
    val totalRecovered: Int,
)

We will also need a JSON Parser, Let's set up kotlinx.serialization json Parser -

val jsonParser = Json {
    isLenient = true
    ignoreUnknownKeys = true
}

Next, let's get the stats from the API. First, we need an HTTP Client to make the requests. Let's do that -

HttpClient() {
    install(JsonFeature) {
        serializer = KotlinxSerializer(json = jsonParser)
    }
}

Here, we also install JsonFeature which automatically parses the response to classes we created earlier. Now, let's use this client to make a get request to https://api.covid19api.com/summary.

HttpClient() {
    // ...
}.use { client ->
    val response: Response = client.get("https://api.covid19api.com/summary")
}

Now let's get the country or global data from this and create a FunctionResult object -

val result: FunctionResult = response.countries.find {
    it.country.equals(country, ignoreCase = true) ||
            it.countryCode.equals(country, ignoreCase = true) ||
            it.slug.equals(country, ignoreCase = true)
}?.run {
    FunctionResult(
        false, newConfirmed, totalConfirmed, newDeaths,
        totalDeaths, newRecovered, totalRecovered
    )
} ?: response.global.run {
    FunctionResult(
        true, newConfirmed, totalConfirmed, newDeaths,
        totalDeaths, newRecovered, totalRecovered
    )
}

Let's put this information in stdout -

println(jsonParser.encodeToString(result))

Here's the complete code -

import io.ktor.client.*
import io.ktor.client.features.json.*
import io.ktor.client.features.json.serializer.*
import io.ktor.client.request.*
import io.ktor.utils.io.core.*
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import model.FunctionResult
import model.Response

suspend fun main() {
    val country = readCountryFromEnv()

    val jsonParser = Json {
        isLenient = true
        ignoreUnknownKeys = true
    }

    HttpClient() {
        install(JsonFeature) {
            serializer = KotlinxSerializer(json = jsonParser)
        }
    }.use { client ->
        val response: Response = client.get("https://api.covid19api.com/summary")

        val result: FunctionResult = response.countries.find {
            it.country.equals(country, ignoreCase = true) ||
                    it.countryCode.equals(country, ignoreCase = true) ||
                    it.slug.equals(country, ignoreCase = true)
        }?.run {
            FunctionResult(
                false, newConfirmed, totalConfirmed, newDeaths,
                totalDeaths, newRecovered, totalRecovered
            )
        } ?: response.global.run {
            FunctionResult(
                true, newConfirmed, totalConfirmed, newDeaths,
                totalDeaths, newRecovered, totalRecovered
            )
        }

        println(jsonParser.encodeToString(result))
    }
}

fun readCountryFromEnv(): String =
    System.getenv("APPWRITE_FUNCTION_DATA")

Whew, that was a lot of code. Let's add our function to appwrite console (see steps in above example) and test it out.

Here's what it prints -

{"isGlobal":false,"newConfirmed":14623,"totalConfirmed":34108996,"newDeaths":197,"totalDeaths":452651,"newRecovered":0,"totalRecovered":0}

Alright! In this article we learned the basics of Appwrite Function Service. In the next post, I'll show you how to connect an Appwrite Function to an android application. Stay tuned for that.

Both collect and collectLatest are terminal operators i.e. they will actually start the flow.

Now let's see how are they different?

First of all, let's build a flow

fun intFlow() = flow {
    (1..5).forEach {
        delay(50)
        println("Flowing $it...")
        emit(it)
    }
}

Please note that there is a delay of 50 ms in the builder.

collect { }

suspend fun main() {
    intFlow().collect {
        delay(100)
        println("\t\t\t\t$it received")
    }
}

Note that there is a delay of 100 ms in the collector. Next, let's see the execution:

Flowing 1...
                1 received
Flowing 2...
                2 received
Flowing 3...
                3 received
Flowing 4...
                4 received
Flowing 5...
                5 received

At first look, you might not see it but look closely. In this case, the builder suspends until the collector is ready for the next value. That is evident because collector delays for 100 ms while builder only delays for 50.

Now, let's see what happens with collectLatest

collectLatest { }

suspend fun main() {
    intFlow().collectLatest {
        delay(100)
        println("\t\t\t\t$it received")
    }
}

Flowing 1...
Flowing 2...
Flowing 3...
Flowing 4...
Flowing 5...
                5 received

In this case, the collector is canceled when it receives a new value from the builder and starts with that value. This is clear because, after 50 ms, the builder provides a new value to the collector.

How to choose between them?

The tradeoff between collect { ... } and collectLatest { ... } is fairly straightforward. If you need to process all the values you receive you should use collect, if you want only the "latest" value to be processed, use collectLatest.

This is all, if you found this article helpful, please drop a like. :)

Cover Photo by Deepak Rautela on Unsplash

Do you need a Fat Jar?

Before we dive into the process of building a Jar, let's address whether or not you need a fat jar. But wait,

What's a fat jar?

The fat jar is the jar, which contains classes from all the libraries, on which your project depends as well as the classes of the current project.

In other words, a fat jar is self-contained and when executed like java -jar my-fat-jar.jar, it will work without setting up any other dependencies.

Let's see how to set it up.

In your build.gradle.kts add the following lines:

tasks.withType<Jar>() {

    // ...

    from(sourceSets.main.get().output)

    dependsOn(configurations.runtimeClasspath)
    from({
        configurations.runtimeClasspath.get()
            .filter { it.name.endsWith("jar") }
            .map { zipTree(it) }
    })
}

and that's it. This will now build a fat jar, if in case you decide you don't need it, just delete these lines.

Building the Jar

Building a Jar is a fairly simple process

• Open the Gradle tab, go to Tasks/build/jar and create a jar file.

• The jar file would most likely be created at /build/libs/

Credits

Cover Image: Photo by Dan Dennis on Unsplash