DEV Community: Layale Matta

A Different Language for each App

Layale Matta — Sat, 25 Feb 2023 19:18:48 +0000

Android 13 has introduced a new feature that let you assign a different language to individual applications, allowing you to navigate each app with a specific language without the need to change the Language settings on my whole Android device.

What's the benefit of switching languages per app?

Several users are bilingual, so they may require certain apps to be in different languages. For example, you might be able to communicate in both English and French, with French being your native language. On your device, you might have set your system’s default language to English. The majority of apps can use this well, while some, like financial ones, would be far better in French since it's more comfortable.

In my case, I am trying to learn a new foreign language. Changing the app language has allowed me to access some apps for brief periods of time while keeping my system's default language set to English. This has helped me become more familiar with the language, encouraging me to use it in order to navigate the app.

Whatever your case may be, using this feature will allow you to fine-tune your experience to ideally fit you (and the user of your app), no matter what language or combination you choose.

📱 Try it on your device

Navigate to your System settings: Settings > System > Languages & Input > App Languages. Select an app and then choose a specific language for it.
Or you can navigate to your Apps settings: Settings > Apps. Select an app, then under Language you can also choose a specific language for it.

📋 Add it to your App

If your app supports different languages, you're ready to implement this feature. Otherwise, look into localizing your Android app first, because adding per-app language settings to your app doesn't translate your app's resources automatically.

Implementing this feature in your app requires 3 simple steps:

1️⃣ Add your app's supported languages to the System Settings

Create a file called res/xml/locales_config.xml. This sample file will help you construct yours. Make sure to only have your localized languages specified there. Otherwise selecting a language that's not supported by your app will fall back to the default language, which is the locale specified in res/values/strings.xml

2️⃣ Edit the Manifest

In the manifest, add a line that points to this new file as follows:

3️⃣ Add your supported languages in Gradle

Use the resourceConfiguration property in your app's module-level build.gradle file to specify the same languages. As long as the resourceConfigurations property is present, the build system will only include these specified languages in the APK, avoiding the inclusion of translated strings from libraries that may support languages other than the ones your app supports.

🎉 And you're done!

To test how this feature looks on your app: navigate to your app's info, find the Language section, change the Language of your app and check if it shows the correct language.

⏭ Up next

If this post was of any help to you, or if you'd like me to write about any specific Android related topics, let me know! Drop me a DM on Twitter @yalematta ✌🏼

Persisting Typed Objects with DataStore

Layale Matta — Tue, 25 May 2021 14:28:22 +0000

In a previous post we have explored how to use Preferences DataStore to migrate our SharedPreferences. And in this post we will focus on Proto DataStore.

🤔 What makes Proto DataStore different?

While both Preferences and Proto DataStore allow saving data, they do this in different ways. One important feature is applied only when using Proto DataStore, and it is Type Safety.

With Proto DataStore we don't have to use keys. Instead we define a schema using Protocol Buffers. And with Protocol Buffers we can persist strongly typed data.

One of the downsides of SharedPreferences and Preferences DataStore is that there is no way to ensure that keys are accessed with the correct type. Using Proto DataStore, we know what types are stored and we will just provide them.

🔍 What's Protocol Buffers?

Protocol Buffers were developed by Google for storing and interchanging all kinds of structured information. They are used for serializing structured data. It is similar to XML and other similar data formats, but it's smaller, faster and simpler.

If you don't know what serialization is, it's the process of translating a data structure or object state into a format that can be stored, like for example, a file or a memory data buffer.

👷🏻 How Protocol Buffers work?

We need to define how we want our data to be structured once, and the compiler will generate the source code for us to easily read and write the structured data.

That said, with Proto Datastore we will serialize and save our custom data structure using Protocol Buffers and of course deserialize and read the values whenever we need to.

🤿 Let's dive

In this simple project, we are implementing the same Remember Me functionality as in the previous post. We are currently using SharedPreferences to store this value and redirect the user to the Welcome screen once it's checked. We will migrate the code to use Proto DataStore.

To get your hands on the code, consider checking this GitHub repo.
The final code is located in the proto_datastore branch.

🏷️ Define Protobuf schema

In order to use Proto Datastore we will need to define our Protobuf schema in a new .proto file. So instead of creating a model class in Kotlin, we will define it in a Protobuf schema instead. And there's a new syntax that we need to follow when writing this schema.

We will install a plugin in Android Studio called Protocol Buffer Editor that will help us write the Proto file. Make sure to install it before creating your proto files.

Once installed, we switch to our Project View and under app/src/main we create a new directory called proto. Inside this directory we create a new file user_prefs.proto where we define our Protocol Buffer schema as follows:

syntax = "proto3";

option java_package= "com.yalematta.datastore_demo";
option java_multiple_files = true;

message UserPreferences {
  bool remember = 1;
  string username = 2;
  int32 luckyNumber = 3;
}

Let me walk you through this syntax:

1️⃣ Syntax

There are 2 versions for the Protobuff syntax: proto2 and proto3. You can check the documention for more info regarding these two different versions. In our case, we are going to use proto3.

2️⃣ Options

Then, we are going to write 2 options:
First, our java_package name. We need it in order to tell our compiler where to generate our classes from this protocol buffer.
The second option is java_multiple_files. We will set it to true and this means that we need to create a separate file for each top level message object of this proto file.

3️⃣ Message

The message keyword defines the data structure. And inside it, we define the members of this structure. As you may have noticed we have different primitive types in this syntax.

By taking a look at the documentation, we can learn that: int32 in Java represents an Integer, int64 a Long and bool is a Boolean.

We create an object UserPreferences with 2 member fields: a bool, a string and an int32. Don't be confused when you see these 1, 2 and 3. These are not actual values but unique numbers to identify our fields in the message binary format and they should not be changed once our message object is in use.

🔌 Dependencies

Before we continue let's place this plugin at the top of our build.gradle file.

plugins {
    id "com.google.protobuf" version "0.8.12"
}

Then we need to add two dependencies, one for Protobuf and one for Proto DataStore.

// proto dataStore
implementation  "androidx.datastore:datastore:1.0.0-beta01"
implementation  "com.google.protobuf:protobuf-javalite:3.10.0"

And finally at the end of our build.gradle file we configure Protobuf and we sync our project.

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.10.0"
    }

    // Generates the java Protobuf-lite code for the Protobufs in this project. See
    // https://github.com/google/protobuf-gradle-plugin#customizing-protobuf-compilation
    // for more information.
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                java {
                    option 'lite'
                }
            }
        }
    }
}

Now that we have added this plugin, we should be able to see the automatically generated files by this plugin from our user_prefs.proto file.

Rebuild the project to see those files inside the java (generated) folder.

We find a new UserPrefs folder that represents our proto file, and a UserPreferences class that represents our message object. Inside it we have java code that implements some getters and setters for this UserPreferences message object.

↪️ Serializer

To tell DataStore how to read and write the data type we defined in the proto file, we need to implement a Serializer. The Serializer defines also the default value to be returned if there's no data saved yet.

Back in our project, we create a class called UserPreferencesSerializer which extends Serializer. We implement its two methods readFrom and writeTo. In these methods we define how we want to read and write this object into our DataStore.

object UserPreferencesSerializer : Serializer<UserPreferences> {
    override val defaultValue: UserPreferences = UserPreferences.getDefaultInstance()
    override suspend fun readFrom(input: InputStream): UserPreferences {
        try {
            return UserPreferences.parseFrom(input)
        } catch (exception: InvalidProtocolBufferException) {
            throw CorruptionException("Cannot read proto.", exception)
        }
    }

    override suspend fun writeTo(t: UserPreferences, output: OutputStream) = 
        t.writeTo(output)
}

🗃️ DataStore Repository

Next we create our Repository which we call UserPreferencesRepository.

class UserPreferencesRepository(private val userPreferencesStore: DataStore<UserPreferences>){
    ...
}

📋 Read from DataStore

We create a new variable called userPreferencesFlow of type Flow. We use our dataStore to read the data and catch exceptions if there is any and emit the default instance of UserPreferences in that case.

    val userPreferencesFlow: Flow<UserPreferences> = userPreferencesStore.data
        .catch { exception ->
            // dataStore.data throws an IOException when an error is encountered when reading data
            if (exception is IOException) {
                Log.e(TAG, "Error reading sort order preferences.", exception)
                emit(UserPreferences.getDefaultInstance())
            } else {
                throw exception
            }
        }

📝 Write to DataStore

We create the suspend updateUsername function which will update one field from our UserPreferences member values. We will call preference.toBuilder(). and we choose the setter method that we need from our generated class.

    suspend fun updateUsername(username: String) {
        userPreferencesStore.updateData { preferences ->
            preferences.toBuilder().setUsername(username).build()
        }
    }

P.S: Don't forget to create a method to update each field.

🆑 Clear DataStore

To clear data, we can either clear the preferences all together or clear a specific preference by its method from our generated class.

    suspend fun clearDataStore() {
        userPreferencesStore.updateData { preferences ->
            preferences.toBuilder().clear().build()
        }
    }

    suspend fun clearUsername() {
        userPreferencesStore.updateData { preferences ->
            preferences.toBuilder().clearUsername().build()
        }
    }

🤙🏼 Call it from the ViewModel

In our LoginViewModel, we create a variable for our UserPreferences, read its data from our DataStore as a Flow and then convert it to LiveData.

Next we create a new function named saveUserPreferences and we pass to it the values that we want to update. We call viewModel scope and run the following code inside a coroutine since our update functions in our Repository are using Kotlin Coroutines.

class LoginViewModel(private val userPreferencesRepository: UserPreferencesRepository) : ViewModel() {

    val userPreferencesFlow = userPreferencesRepository.userPreferencesFlow.asLiveData()

    fun saveUserPreferences(remember: Boolean, username: String, luckyNumber: Int) {
        viewModelScope.launch(Dispatchers.IO) {
            userPreferencesRepository.updateRemember(remember)
            userPreferencesRepository.updateUsername(username)
            userPreferencesRepository.updateLuckyNumber(luckyNumber)
        }
    }

    fun clearUserPreferences() {
        viewModelScope.launch(Dispatchers.IO) {
            userPreferencesRepository.clearDataStore()
        }
    }
}

class LoginViewModelFactory(
    private val userPreferencesRepository: UserPreferencesRepository
) : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(LoginViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return LoginViewModel(userPreferencesRepository) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }
}

LoginViewModelFactory is a ViewModelProvider.Factory that is responsible to create our instance of LoginViewModel later in our Activity. We will pass to it the DataStoreRepository which is need in LoginViewModel's constructor.

🔬 Observe it in the Activity

In our Activity, we first create our userPreferencesDataStore and we initialize it and pass to it a file name as well as our Serializer class.

🗄️ Create DataStore

private const val DATA_STORE_FILE_NAME = "user_prefs.pb"

val Context.userPreferencesStore: DataStore<UserPreferences> by dataStore(
    fileName = DATA_STORE_FILE_NAME,
    serializer = UserPreferencesSerializer
)

📦 Migrate from SharedPreferences

If we are migrating our existing data from the SharedPreferences, when creating our DataStore, we should add a migration based on the SharedPreferences name.

And when creating the dataStore we need to update the DataStore builder and assign to the migrations parameter a new list that contains an instance of our SharedPreferencesMigration.

Define the mapping logic from SharedPreferences to UserPreferences inside your SharedPreferencesMigration.

DataStore will be able to migrate from SharedPreferences to DataStore automatically, for us.

const val USER_PREFERENCES_NAME = "user_preferences"
private const val DATA_STORE_FILE_NAME = "user_prefs.pb"

val Context.userPreferencesStore: DataStore<UserPreferences> by dataStore(
    fileName = DATA_STORE_FILE_NAME,
    serializer = UserPreferencesSerializer,
    produceMigrations = { context ->
        listOf(sharedPrefsMigration(context))
    }
)

fun sharedPrefsMigration(context: Context) = SharedPreferencesMigration(
    context, USER_PREFERENCES_NAME) { sharedPrefs: SharedPreferencesView, currentData: UserPreferences ->
    // Define the mapping from SharedPreferences to UserPreferences
    currentData
}

Inside our onCreate function, we initialize our ViewModel and we observe our fields' values, so that whenever this data changes we will update it in its corresponding text field.

And whenever we click our login button, we store the value from our editText and checkBox field and update it in our DataStore using the saveUserPreferences function.

class LoginActivity : AppCompatActivity() {

    private lateinit var binding: ActivityLoginBinding
    private lateinit var viewModel: LoginViewModel

    private var rememberMe = false
    private var luckyNumber = 0
    private lateinit var username: String

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityLoginBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        viewModel = ViewModelProvider(
            this,
            LoginViewModelFactory(UserPreferencesRepository(userPreferencesStore))
        ).get(LoginViewModel::class.java)

        viewModel.userPreferencesFlow.observe(this, { userPreferences ->
            rememberMe = userPreferences.remember
            username = userPreferences.username
            luckyNumber = userPreferences.luckyNumber
            if (rememberMe) {
                startActivity(Intent(this, WelcomeActivity::class.java))
            }
        })

        binding.login.setOnClickListener {
            if (binding.remember.isChecked) {
                val name = binding.username.text.toString()
                var number = luckyNumber
                if (binding.luckyNumber.text.toString().isNotEmpty()) {
                    number = binding.luckyNumber.text.toString().toInt()
                }
                viewModel.saveUserPreferences(true, name, number)
            }
            startActivity(Intent(this, WelcomeActivity::class.java))
        }

        binding.remember.setOnCheckedChangeListener { compoundButton: CompoundButton, b: Boolean ->
            if (!compoundButton.isChecked) {
                viewModel.clearUserPreferences()
            }
        }

    }
}

💡 Key Takeaways

Now that we migrated to Preferences DataStore let's recap!

DataStore:

is a replacement for SharedPreferences addressing most of its downsides
has a fully asynchronous API using Kotlin coroutines and Flow
guarantees data consistency
handles data migration
handles data corruption

DataStore has 2 different implementations:

Preferences DataStore:

stores and accesses data using keys

Proto DataStore:

ensures Type Safety
requires defining a schema using Protocol Buffers

⏭ Up next

If this post was of any help to you, or if you'd like me to write about any specific Android related topics, let me know! Drop me a DM on Twitter @yalematta ✌🏼

DataStore is the new SharedPreferences

Layale Matta — Fri, 14 May 2021 18:00:40 +0000

You've definitely used SharedPreferences to store small or simple data sets. But SharedPreferences' API has a series of downsides and luckily the Jetpack DataStore library aims at addressing those issues.

So if you're currently using SharedPreferences, consider migrating to DataStore instead. And good news, it's now in Beta 🎉

🔍 What is DataStore?

Jetpack DataStore is a data storage solution that provides two different implementations: Preferences DataStore and Proto DataStore.

Preferences DataStore stores and accesses data using keys.

Proto DataStore stores data as instances of a custom data type and requires creating a schema using protocol buffers.

DataStore uses Kotlin coroutines and Flow to store data asynchronously, consistently, and transactionally unlike SharedPreferences.

🤿 Let's dive

In this article, we will focus on Preferences DataStore.

In this simple project, we are implementing the Remember Me functionality of a Login screen. We are currently using SharedPreferences to store this value and redirect the user to the Welcome screen once it's checked. We will migrate the code to use DataStore.

To get your hands on the code, consider checking this GitHub repo.
The final code is located in the preferences_datastore branch.

🛑 SharedPreferences Limitations

The biggest downsides of SharedPreferences include:

Lack of safety from runtime exceptions
Lack of a fully asynchronous API
Lack of main thread safety
No type safety

Luckily Jetpack DataStore addresses those issues. Since it's powered by Flow, DataStore saves the preferences in a file and performs all data operations on Dispatchers.IO under the hood. And your app won't be freezing while storing data.

🏁 Let's get started...

First, add the Preference DataStore dependency in the build.gradle file:

implementation "androidx.datastore:datastore-preferences:1.0.0-beta01"

We have also added the Lifecycle dependencies for using ViewModel:

// architecture components
implementation "androidx.core:core-ktx:$coreVersion"
implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycleVersion"
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycleVersion"
implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycleVersion"

🗃️ DataStore Repository

Inside a new package called repository, create the Kotlin class DataStoreRepository.kt. In this class we are going to store all the logic necessary for writing and reading DataStore preferences. We will pass to it a dataStore of type DataStore<Preferences> as a parameter.

class DataStoreRepository(private val dataStore: DataStore<Preferences>) {
    ...
}

Let's create a data class called UserPreferecences. It will contain the two values we're going to save.

data class UserPreferences(
    val username: String,
    val remember: Boolean
)

Unlike SharedPreferences, in DataStore we cannot add a key simply as a String. Instead we have to create a Preferences.Key<String> object or simply by using the extension function stringPreferencesKey as follows:

class DataStoreRepository(private val dataStore: DataStore<Preferences>) {

    private object PreferencesKeys {
        val USERNAME = stringPreferencesKey("username")
        val REMEMBER = booleanPreferencesKey("remember")
    }

 }

📝 Write to DataStore

In order to save to DataStore, we use the dataStore.edit method using the keys we created above.

suspend fun saveToDataStore(username: String, remember: Boolean) {
    dataStore.edit { preference ->
        preference[USERNAME] = username
        preference[REMEMBER] = remember
    }
}

You may have noticed that we're using a suspend function here. This is because dataStore.edit uses Coroutines. This function accepts a transform block of code that allows us to transactionally update the state in DataStore. It can also throw an IOException if an error was encountered while reading or writing to disk.

📋 Read from DataStore

To read our data, we will retrieve it using dataStore.data as a Flow<UserPreferences>.
Later, we are going to convert this Flow emitted value to LiveData in our ViewModel.

val readFromDataStore : Flow<UserPreferences> = dataStore.data
    .catch { exception ->
        if (exception is IOException) {
            Log.d("DataStoreRepository", exception.message.toString())
            emit(emptyPreferences())
        } else {
            throw exception
        }
    }
    .map { preference ->
        val username = preference[USERNAME] ?: ""
        val remember = preference[REMEMBER] ?: false
        UserPreferences(username, remember)
    }

Make sure to handle the IOExceptions, that are thrown when an error occurs while reading data. Do this by using catch() before map() and emitting emptyPreferences().

🆑 Clear DataStore

To clear data, we can either clear the preferences all together or clear a specific preference by its key.

suspend fun clearDataStore() {
    dataStore.edit { preferences ->
        preferences.clear()
    }
}

suspend fun removeUsername() {
    dataStore.edit { preference ->
        preference.remove(USERNAME)
    }
}

🤙🏼 Call it from the ViewModel

In another viewmodel package, create the LoginViewModel class.

class LoginViewModel(private val dataStoreRepository: DataStoreRepository)
    : ViewModel() {

    val userPreferences = dataStoreRepository.readFromDataStore.asLiveData()

    fun saveUserPreferences(username: String, remember: Boolean) {
        viewModelScope.launch(Dispatchers.IO) {
            dataStoreRepository.saveToDataStore(username, remember)
        }
    }

    fun clearUserPreferences() {
        viewModelScope.launch(Dispatchers.IO) {
            dataStoreRepository.clearDataStore()
        }
    }
}

class LoginViewModelFactory(
    private val dataStoreRepository: DataStoreRepository) 
    : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(LoginViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return LoginViewModel(dataStoreRepository) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }
}

We're retrieving userPreferences and converting the Flow into LiveData in order to observe it in our Activity. And since saveToDataStore and clearDataStore are suspended functions, we need to run them from inside a coroutine scope, which is the viewmodel scope in this case.

LoginViewModelFactory is a ViewModelProvider.Factory that is responsible to create our instance of LoginViewModel later in our Activity. We will pass to it the DataStoreRepository which is need in LoginViewModel's constructor.

Create DataStore 🗄️

private const val USER_PREFERENCES_NAME = "user_preferences"

val Context.dataStore by preferencesDataStore(
    name = USER_PREFERENCES_NAME
)

📦 Migrate from SharedPreferences

If we are migrating our existing data from the SharedPreferences, when creating our DataStore, we should add a migration based on the SharedPreferences name. DataStore will be able to migrate from SharedPreferences to DataStore automatically, for us.

private const val USER_PREFERENCES_NAME = "user_preferences"

private val Context.dataStore by preferencesDataStore(
    name = USER_PREFERENCES_NAME,
    produceMigrations = { context ->
        listOf(SharedPreferencesMigration(context, USER_PREFERENCES_NAME))
    }
)

🔬 Observe it in the Activity

In our activity, we first observe our userPreferences as liveData from our ViewModel.

class LoginActivity : AppCompatActivity() {

    private lateinit var binding: ActivityLoginBinding
    private lateinit var viewModel: LoginViewModel

    private var rememberMe = false
    private lateinit var username: String

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityLoginBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        viewModel = ViewModelProvider(this,
            LoginViewModelFactory(DataStoreRepository(dataStore)))
                .get(LoginViewModel::class.java)

        viewModel.userPreferences.observe(this, { userPreferences ->
            rememberMe = userPreferences.remember
            username = userPreferences.username
            if (rememberMe) {
                startActivity(Intent(this, WelcomeActivity::class.java))
            }
        })

        binding.login.setOnClickListener {
            if (binding.remember.isChecked) {
                val name = binding.username.text.toString()
                viewModel.saveUserPreferences(name, true)
            }
            startActivity(Intent(this, WelcomeActivity::class.java))
        }

        binding.remember.setOnCheckedChangeListener { 
                compoundButton: CompoundButton, b: Boolean ->
            if (!compoundButton.isChecked) {
                viewModel.clearUserPreferences()
            }
        }

    }
}

Whenever Remember Me is observed as checked, we redirect the user to the Welcome screen. Whenever we click the login button, if our checkbox is checked we update our userPreferences, otherwise we clear our saved user preferences.

For the simplicity of our application, we will use the same ViewModel in our WelcomeActivity as well. We observe the username and display it whenever it is not empty. And once we log out we clear our saved userPreferences.

class WelcomeActivity : AppCompatActivity() {

    private lateinit var binding: ActivityWelcomeBinding
    private lateinit var viewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityWelcomeBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        viewModel = ViewModelProvider(this,
            LoginViewModelFactory(DataStoreRepository(dataStore)))
                .get(LoginViewModel::class.java)

        viewModel.userPreferences.observe(this, { userPreferences ->
            val username = userPreferences.username
            if (username.isNotEmpty()) {
                binding.welcome.text = 
                    String.format(getString(R.string.welcome_user), username)
            }
        })

        binding.logout.setOnClickListener {
            viewModel.clearUserPreferences()
            startActivity(Intent(this, LoginActivity::class.java))
        }
    }
}

💡 Key Takeaways

Now that we migrated to Preferences DataStore let's recap!

DataStore:

is a replacement for SharedPreferences
has a fully asynchronous API using Kotlin coroutines and Flow
guarantees data consistency
handles data migration
handles data corruption

⏭ Up next

Join me in the next post to learn how to use Proto DataStore.

If this post was of any help to you, or if you think it requires further explanation, I'd love to know! Drop me a DM on Twitter @yalematta ✌🏼

New to Android? Start here

Layale Matta — Thu, 18 Mar 2021 19:27:58 +0000

New to Android? That's great! You'll need to know a little bit of Kotlin and Android. The beauty of computer programming is that you do not need to formally go to school to learn how to program. You can learn almost everything that you would need to know online, and for free.

The following resources are some that I have personally used and that I highly recommend for anyone looking to learn how to build Android applications.

Android Basics in Kotlin

These are free online training courses developed by Google that help you learn how to build basic Android apps. The courses are made up of units. And units are composed of pathways. You may be wondering, what is a pathway? It’s an ordered sequence of activities to learn a specific skill.
An activity can be a video, hands-on coding tutorial (known as a codelab), an article, or quiz. All these activities are meant to help you reach specific learning objectives by the end of each pathway.

Android Kotlin Fundamentals

This course is also developed by Google, and has ten pathways available. This track requires you to have prior programming experience.
You will learn about:

Navigation
Activity and Fragment lifecycles
Architecture components
Databases and RecyclerView
Repository and WorkManager
Material Design

Learn Android by Example

As you get into more advanced features, you will likely need to learn more programming concepts. You can check out this resource for that.
This is an official set of small and simple annotated examples designed for those new to Kotlin by the Jetbrains team. No prior knowledge of any programming language is required.

Kotlin Koans

This is a series of exercises to get you familiar with the Kotlin syntax and language features. Each exercise is created as a failing unit test, and you need to make it pass.

Udacity

This course is built in collaboration with Google, but it is not free. It will prepare you to become a professional Android developer and allow you to create a diverse portfolio of projects to show employers.
By the end of this program, you will be able to use Android development platform best-practices, Android Jetpack, and Kotlin to build your own Android apps.

Ray Wenderlich

All of Ray Wenderlich's tutorials are created by a community of mobile development experts from around the world. No matter how long you’ve been coding, their courses format will help you become a better developer!
Some of these courses are free, but some others will require you to have a monthly subscription on their platform to be able to access them.

Learn More

Kotlin Vocabulary series
Official Android Developers Blog (for announcements)
Android Developers Medium Blog (for more technical articles)
Android Developers YouTube channel
Follow @AndroidDev on Twitter

I hope these resources will help you get started. I’d love to hear your thoughts and experiences on how you got started with Android development. Hit me up!