Every android application contains a splash screen to display the app name and app version at the launch of the application. Also, it’s used to load initial data for the application in the background. So the data will be ready before moving to the main screen.

The splash screen is one of the main screens that every android application is having it. So, let’s see the steps to create the splash screen on our jetpack compose the project.

Also, I have created a tutorial on jetpack compose basic, I strongly recommend you learn before creating the project on jetpack compose.

Getting started with jetpack compose — Basic components

Getting started with jetpack compose — Layouts

Getting started with jetpack compose — Modifiers

Getting started with jetpack compose — Theming

Dependencies

In the beginning, we need to add the dependencies for the project. Splash screens don’t have any dependencies. But, after displaying the splash screen, we need to navigate to different screens. For the navigation, we need to add navigation dependency.

implementation "androidx.navigation:navigation-compose:2.6.0-alpha02"

Implementation

let’s get started with the implementing splash screen with animation on the jetpack compose.

Setup navigation controls

First, create a new jetpack compose the project. After that, we need to set up the navigation control for the screen available on the application. create screens.kt file and add all the screen names for better navigation.

screens.kt

object Screens {
    const val Splash = "Splash"
    const val Dashboard = "Dashboard"
}

Add navigation code in MainAcitivity.kt.

val navController = rememberNavController()
NavHost(navController = navController, startDestination = Screens.Splash) {
    composable(route = Screens.Splash) {
        SplashScreen(navController = navController)
    }

    composable(route = Screens.Dashboard) {
        DashBoardScreen(navController = navController)
    }
}

Create Splash screen UI

In the example, I have created splash and dashboard screens. On the splash screen, we need to create an image view to animate and text to display application information.

@Composable
fun SplashScreen(navController: NavController) = Box(
    Modifier
        .fillMaxWidth()
        .fillMaxHeight()
) {
   Image(
        painter = painterResource(id = R.drawable.app_icon),
        contentDescription = "",
        alignment = Alignment.Center, modifier = Modifier
            .fillMaxSize().padding(40.dp)
            .scale(scale.value)
    )

    Text(
        text = "Version - ${BuildConfig.VERSION_NAME}",
        textAlign = TextAlign.Center,
        fontSize = 24.sp,
        modifier = Modifier.align(Alignment.BottomCenter).padding(16.dp)
    )
}

And, the preview of the above code,

Animate the image on the splash screen

Already, we have created the splash UI design the next step is to animate the splash image and navigate to the dashboard screen.

@Composable
fun SplashScreen(navController: NavController) = Box(
    Modifier
        .fillMaxWidth()
        .fillMaxHeight()
) {

    val scale = remember {
        androidx.compose.animation.core.Animatable(0.0f)
    }

    LaunchedEffect(key1 = true) {
        scale.animateTo(
            targetValue = 0.7f,
            animationSpec = tween(800, easing = {
                OvershootInterpolator(4f).getInterpolation(it)
            })
        )
        delay(1000)
        navController.navigate(Screens.Dashboard) {
            popUpTo(Screens.Splash) {
                inclusive = true
            }
        }
    }

    Image(
        painter = painterResource(id = R.drawable.app_icon),
        contentDescription = "",
        alignment = Alignment.Center, modifier = Modifier
            .fillMaxSize().padding(40.dp)
            .scale(scale.value)
    )

    Text(
        text = "Version - ${BuildConfig.VERSION_NAME}",
        textAlign = TextAlign.Center,
        fontSize = 24.sp,
        modifier = Modifier.align(Alignment.BottomCenter).padding(16.dp)
    )
}

In the above code, started the image animation at the start of the splash screen. after the 1000ms it will navigate to the dashboard screen.

also, I have added code to the popup splash screen. So that when pressing the back button it won’t come to the splash screen again.

navController.navigate(Screens.Dashboard) {
    popUpTo(Screens.Splash) {
        inclusive = true
    }
}

Conclusion

The splash screen is the most needed screen for all the applications to load initial data or set up the app configurations. So, try this example and let me know your feedback in the comments.

You can download this example on Github.

Android-Example/SplashScreenExample at master · velmurugan-murugesan/Android-Example (github.com)

Originally published at https://howtodoandroid.com on October 10, 2022.

Easy animation on splash screen In android using jetpack compose was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this tutorial, I will explain the MVVM architecture with kotlin coroutines and kotlin flow with hilt dependency injection. Also, I will explain the Room database with the flow in this tutorial.

let’s begin with a short introduction about the features I will use in this tutorial.

What is MVVM?

MVVM (Model-View-ViewModel) pattern helps to separate the business and presentation logic from the UI completely, and the business logic and UI can be separated for easier testing and maintenance. Let’s take a look at View, ViewModel, and Model.

View

The view is responsible for the layout structure displayed on the screen. You can also execute UI logic.

ViewModel

The ViewModel implements the data and commands connected to the View to notify the View of state changes via change notification events. Then, the View that receives the state change notification determines whether to apply the change.

Model

Model is a non-visual class that has the data to use. Examples include DTO (Data Transfer Objects), POJO (Plain Old Java Objects), and entity objects. It is a commonly used service or repository that needs to access or cache data.

If you want to learn more about MVVM, check the below tutorials,

MVVM with Kotlin Coroutines and Retrofit [Example] — Howtodoandroid

MVVM With Retrofit and Recyclerview in Kotlin [Example] (howtodoandroid.com)

Basic of Kotlin Coroutines

A coroutine is a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. Coroutines were added to Kotlin in version 1.3 and are based on established concepts from other languages.

The main advantages of using Coroutines

• They are light-weight
• Built-in cancellation support
• Lower chances for memory leaks
• Jetpack libraries provide coroutines support

To know more about the kotlin coroutines,

MVVM with Kotlin Coroutines and Retrofit [Example] — Howtodoandroid

MVVM With Retrofit and Recyclerview in Kotlin [Example] (howtodoandroid.com)

Introduction to Kotlin flow

• The Flow is a type that can emit multiple values sequentially, as opposed to suspending functions that return only a single value. For example, you can use a flow to receive live updates from a database.
• Flows are built on top of coroutines and can provide multiple values.
• A flow is conceptually a stream of data that can be computed asynchronously.
• The emitted values must be of the same type.

Hilt dependency injection

The hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection in your project. Hilt provides a standard way to use DI in your application by automatically providing containers for every Android class in your project and managing their lifecycles.

Also, check the below link to know more about the hilt,

Dependency injection on Android with Hilt[Example] — Howtodoandroid

Enough theory, let’s start with creating an android application using MVVM, kotlin coroutines, and flow.

MVVM + Coroutines + Flow + Hilt Example

The first step is to add dependencies for the components, like ViewModel, Coroutines, Hilt, Flow, Room, Retrofit, etc.

//coroutines
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2'

//hilt
    implementation "com.google.dagger:hilt-android:2.38.1"
    kapt "com.google.dagger:hilt-compiler:2.38.1"

// retrofit
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation "com.squareup.okhttp3:okhttp:4.7.2"
    implementation "com.squareup.okhttp3:logging-interceptor:4.7.2"
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

//ktx
    implementation "androidx.activity:activity-ktx:1.4.0"
    implementation "androidx.fragment:fragment-ktx:1.4.1"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.4.1"
    // glide
    implementation 'com.github.bumptech.glide:glide:4.13.0'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.13.0'

Hilt Dependency injection setup

Set the application as HiltAndroidApp.

@HiltAndroidApp
class MyApplication: Application() {

override fun onCreate() {
        super.onCreate()
    }
}

Also, don’t forget to add the application class and internet permission to the AndroidManifest.xml file.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.example.mvvmwithretrofitandflow">

<uses-permission android:name="android.permission.INTERNET"/>

<application
        android:name=".MyApplication"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:usesCleartextTraffic="true"
        android:theme="@style/Theme.MVVMWithRetrofitAndFlow"
        tools:targetApi="31">
        <activity
            android:name=".ui.MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

create the network module for retrofit setup.

NetworkModule.kt

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    
    @Singleton
    @Provides
    fun provideOkHttp() : OkHttpClient{
        return OkHttpClient.Builder()
            .build()
    }

@Singleton
    @Provides
    @Named("loggingInterceptor")
    fun provideLoggingInterceptor(): HttpLoggingInterceptor {
        return HttpLoggingInterceptor().apply {
            this.level = HttpLoggingInterceptor.Level.BODY
        }
    }

@Provides
    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://imdb-api.com/en/")
            .addConverterFactory(GsonConverterFactory.create())
            .client(okHttpClient)
            .build()
    }

@Provides
    fun provideApiClient(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
    
}

for the API calls, I am using https://imdb-api.com/en/. To use this API need an account with IMDb-api.com.

and the Response Model, Model.kt

@Entity
data class Movie(
    @PrimaryKey
    val id: String,
    val title: String,
    val year: String,
    val image: String,
    val imDbRating: String
)

data class MovieResponse(val items: List<Movie>, val errorMessage: String)

Repository setup with flow

On the repository, I am calling the API service and returning the response as flow to ViewModel. Also, I am using NetworkResult sealed class to emit different statuses of the network call.

NetworkResult.kt

sealed class NetworkResult<T> {
    data class Loading<T>(val isLoading: Boolean) : NetworkResult<T>()
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Failure<T>(val errorMessage: String) : NetworkResult<T>()
}

MainRepository.kt

class MainRepository @Inject constructor(private val apiService: ApiService) {

suspend fun getPopularMovies()  = flow {
        emit(NetworkResult.Loading(true))
        val response = apiService.getMostPopularMovies()
       emit(NetworkResult.Success(response.items))
    }.catch { e ->
        emit(NetworkResult.Failure(e.message ?: "Unknown Error"))
    }
}

ViewModel setup with Livedata

In the ViewModel collect the flow and set the response to livedata for UI changes.

@HiltViewModel
class MainViewModel @Inject constructor(
    private val mainRepository: MainRepository
) : ViewModel() {

private var _movieResponse = MutableLiveData<NetworkResult<List<Movie>>>()
    val movieResponse: LiveData<NetworkResult<List<Movie>>> = _movieResponse

init {
        fetchAllMovies()
    }

private fun fetchAllMovies() {
        viewModelScope.launch {
            mainRepository.getPopularMovies().collect {
                _movieResponse.postValue(it)
            }
        }
    }
}

Observe the changes in UI

finally, I have observed the changes from ViewModel to UI class.

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

private lateinit var binding: ActivityMainBinding

private val mainViewModel: MainViewModel by viewModels()
    @Inject
    lateinit var movieAdapter: MovieAdapter

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

binding.rvMovies.adapter = movieAdapter

movieAdapter.setItemClick(object : ClickInterface<Movie> {
            override fun onClick(data: Movie) {
                Toast.makeText(this@MainActivity, data.title, Toast.LENGTH_SHORT).show()
            }
        })

mainViewModel.movieResponse.observe(this) {
            when(it) {
                is NetworkResult.Loading -> {
                    binding.progressbar.isVisible = it.isLoading
                }

is NetworkResult.Failure -> {
                    Toast.makeText(this, it.errorMessage, Toast.LENGTH_SHORT).show()
                    binding.progressbar.isVisible = false
                }

is  NetworkResult.Success -> {
                    movieAdapter.updateMovies(it.data)
                    binding.progressbar.isVisible = false
                }
            }
        }

}

}

that’s it. we have done with the coding let’s run the code and check it. Now you can able to see the list of movies in recyclerview.

you can download this example from GitHub.

https://github.com/velmurugan-murugesan/Android-Example/tree/master/MVVMWithRetrofitAndFlow

Originally published at https://howtodoandroid.com on July 25, 2022.

Creating android app using MVVM + Coroutines + Flow + Hilt was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

From the beginning with Android 6.0 Marshmallow, Google has introduced a new runtime permission model, users are not asked for permissions at the time of installation rather developers need to request the permissions at the run time. Only the permissions that are defined in the manifest file can be requested at run time.

This helps in protecting the privacy of an Android Device user. So for example you(your apps) have to request permissions to:

1. Access sensitive user data (such as contacts and SMS).
2. Access certain system features (such as camera and internet).

Depending on the feature, the system might grant the permission automatically or might prompt the user to approve the request.

Type of permissions

Android defines basically three types of permissions:

1. Normal Permissions
2. Signature Permissions
3. Dangerous Permissions

Both Normal and Dangerous permissions must be defined in the Manifest file. But only Dangerous permissions are checked at runtime, Normal permissions are not.

Normal Permissions

These are required when your app needs to access data or resources outside the app’s sandbox, but where there’s very little risk to the user’s privacy or the operation of other apps.

If an app declares in its manifest that it needs normal permission, the system automatically grants the app that permission at install time. and users cannot revoke these permissions.

Permissions like INTERNET, BLUETOOTH, ACCESS_WIFI_STATE, ACCESS_NETWORK_STATE, etc are normal permissions.

For more details about the permission check the permission API reference page.

Signature Permissions

A permission that the system grants only if the requesting application is signed with the same certificate as the application that declared the permission. If the certificates match, the system automatically grants permission without notifying the user.

Permissions like BIND_AUTOFILL_SERVICE, BIND_INPUT_METHOD, BIND_NFC_SERVICE, etc are signature permissions.

Dangerous permissions

Some permissions may affect the user’s private information, or could potentially affect his data or the operation of other applications are called Dangerous Permissions. For example, the ability to read the user’s contacts is a dangerous permission.

Permissions like CAMERA, READ_CALL_LOG, ACCESS_FINE_LOCATION, READ_SMS, READ_EXTERNAL_STORAGE, etc aredangerous permissions.

For more details about the permission check the permission API reference page.

How to Check for permissions

If your app needs dangerous permission, you must check whether you have that permission every time you perform an operation that requires that permission.

you do it using the ContextCompat.checkSelfPermission() method with the permission name.

if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) 
    == PackageManager.PERMISSION_GRANTED) {
    // permission granted
} else {
    // permission not granted
}

This will return two types of responses.

• PackageManager.PERMISSION_GRANTED — This means permission granted. So you can proceed with your operations.
• PackageManager.PERMISSION_DENIED — This means pemission not granted. So you need to ask the permission again or you can skip that process.

Request permissions

If the permission is not granted, we need to ask for permission to access certain features like camera, storage, etc.

To ask permission, we need to use ActivityCompat.requestPermission() method with the permission name and the request code.

First, we need to add the requested permission into the manifest.xml file.

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

Note: don’t forget to add all the needed permission into the manifest file. otherwise, run time permission won’t work.

ActivityCompat.requestPermissions( this, arrayOf(Manifest.permission.CAMERA), request_code )

This will pop up the permission dialog for the defined permission. Users can able to Allow or deny permission.

Handle the permission request response

Once the user responded to the permission request, the result will be received in the onRequestPermissionResult. based on the request code, we can check our permission granted or denied.

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == 201) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(this, "Permission granted", Toast.LENGTH_SHORT).show()
            openCamera()
        } else {
            Toast.makeText(this, "Permission denied", Toast.LENGTH_SHORT).show()
        }
    }
}

Requesting multiple permissions

Previously, we checked about requesting single permission at a time. In android, it’salso possible to ask for multiple permission at a time. We can use the same ActivityCompat.requestPermissions() method as above by passing anarray of permissions.

ActivityCompat.requestPermissions(
    this,
    arrayOf(Manifest.permission.CAMERA, Manifest.permission.READ_EXTERNAL_STORAGE),
    request_code
)

But, we cannot check the multiple permission at a time. We need to check the permission status individually.

Handle the permission denial

When the user is denied permission for the first time. It means that the user doesn’t understand the purpose of the particular permission. So, we need to show some additional messages to explain the purpose of the permission.

To do that we need to check for the shouldShowRequestPermissionRationale() method with the permission to check, whether the permission is already denied or not. If denied already need to show some additional message using the dialog.

if (checkPermission(Manifest.permission.CAMERA)) {
    openCamera()
} else {
    if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
        AlertDialog.Builder(this)
            .setMessage("Need camera permission to capture image. Please provide permission to access your camera.")
            .setPositiveButton("OK") { dialogInterface, i ->
                dialogInterface.dismiss()
                ActivityCompat.requestPermissions(
                    this,
                    arrayOf(Manifest.permission.CAMERA),
                    201
                )
            }
            .setNegativeButton("Cancel") { dialogInterface, i ->
                dialogInterface.dismiss()
            }
            .create()
            .show();
    } else {
        ActivityCompat.requestPermissions(
            this,
            arrayOf(Manifest.permission.CAMERA,Manifest.permission.READ_EXTERNAL_STORAGE),
            201
        )
    }
}

One-time permissions

Starting in Android 11, whenever your app requests permission related to location, microphone, or camera, the user-facing permissions dialog contains an option called Only this time. If the user selects this option in the dialog, your app is granted temporary one-time permission.

checks more about one-time permission.

Android Runtime Permission Example

check out my final code for Runtime permission MainActivity.kt,

class MainActivity : AppCompatActivity() {

    lateinit var btnCamera: Button
    lateinit var btnLocation: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        btnCamera = findViewById(R.id.btnCamera)
        btnLocation = findViewById(R.id.btnLocation)

        btnCamera.setOnClickListener {

            if (checkPermission(Manifest.permission.CAMERA)) {
                //openCamera()
            } else {
                if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
                    AlertDialog.Builder(this)
                        .setMessage("Need camera permission to capture image. Please provide permission to access your camera.")
                        .setPositiveButton("OK") { dialogInterface, i ->
                            dialogInterface.dismiss()
                            ActivityCompat.requestPermissions(
                                this,
                                arrayOf(Manifest.permission.CAMERA),
                                201
                            )
                        }
                        .setNegativeButton("Cancel") { dialogInterface, i ->
                            dialogInterface.dismiss()
                        }
                        .create()
                        .show();
                } else {
                    ActivityCompat.requestPermissions(
                        this,
                        arrayOf(Manifest.permission.CAMERA,Manifest.permission.READ_EXTERNAL_STORAGE),
                        201
                    )
                }
            }


            /**/

        }

    }

    private fun checkPermission(permission: String): Boolean {
        return ContextCompat.checkSelfPermission(
            this,
            permission
        ) == PackageManager.PERMISSION_GRANTED
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == 201) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this, "Permission granted", Toast.LENGTH_SHORT).show()
                //openCamera()
            } else {
                Toast.makeText(this, "Permission denied", Toast.LENGTH_SHORT).show()
            }
        }
    }

}

also, updated Manifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.velmurugan.runtimepermissionandroid">

    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.RuntimePermissionAndroid">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Thanks for reading. let me know your feedback on comments. Also, you can download this example on GITHUB.

Originally published at https://howtodoandroid.com on March 18, 2022.

Android Runtime Permissions[Updated with Android 11] — Howtodoandroid was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

It’s very important to handle the exception occurs during the networking operation or any IO operations in kotlin coroutines. So, in this tutorial, we are going to see how to handle the exceptions and how to cancel the particular job running on the kotlin coroutines.

Before getting into this tutorial, If you are not familiar with kotlin coroutines, I strongly recommend you to read another tutorial on kotlin coroutines.

Kotlin Coroutines for Android Development

In Kotlin Coroutines, we can handle the exceptions in two ways, one is using the try/catch block, another way is using the CoroutineExceptionHandler. let’s see how to implement both on kotlin coroutines.

Handling Exception With Try / Catch

In this method, we can use try/ catch in the way we are using the kotlin programming. But when we are working with kotlin coroutines, we need to put the try/catch block inside the Coroutine Scope Functions.

fun handleExceptionWithTryCatch() {
    viewModelScope.launch() {
        try {
            val movies = ApiService.getInstance().getAllMovies401()
            movieList.postValue(movies)
        } catch (e: Exception) {
            Log.d("Exception", "${e.message.toString()} handled !")
        }
    }
}

In the above code, I have created a ViewModelScope, that is Coroutines Scope Function to perform a networking operation. The API call returns 401 Exception, In normal cases, it will crash the application. But we are using try/catch around the API call. So the exception will be handled.

Output:

com.example.kotlincoroutines D/Exception: HTTP 401 401 Unauthorized handled !

Handle Exception And Return Result

In some cases, we need to return the default response when the exception occurs. To do this we need to add the default response in the catch block to return the default response. If we are using multiple operations then we need to use separate try/catch blocks to handle to separately.

fun returnDefaultResultOnException() {
    viewModelScope.launch {
        try {
            val movie1 = try {
                ApiService.getInstance().getAllMovies()
            } catch (e: Exception) {
                listOf()
            }

            val movie2 = try {
                ApiService.getInstance().getAllMovies401()
            } catch (e: Exception) {
                listOf()
            }

            Log.d("Movie 1", movie1.toString())
            Log.d("Movie 2", movie2.toString())

        } catch (e: Exception) {
            Log.d("Exception", "${e.message.toString()} handled !")
        }
    }
}

In the above code, I am called two API calls. The first API call returns a successful response with a list of movies. But the second API call returns 401 exceptions. So, I have handled that API using the try/catch block and returned the empty movie list as a response.

Output:

com.example.kotlincoroutines D/Movie 1: [Movie(category=Latest, imageUrl=https://howtodoandroid.com/images/coco.jpg, name=Coco, desc=Coco is a 2017 American 3D computer-animated musical..
com.example.kotlincoroutines D/Movie 2: []

Handling Exception With CoroutineExceptionHandler

In this way, we need to attach the separate CoroutineExceptionHandler variable and attach this variable to Coroutine Builder. So, when the exception occurs in the coroutine scope it will be forwarded to the exception handler.

private val handler = CoroutineExceptionHandler { _, exception ->
    Log.d("Exception", "${exception.message.toString()} handled !")
}

fun handleExceptionWithCoroutineExceptionHandler() {
    viewModelScope.launch(handler) {
        val moviesList = ApiService.getInstance().getAllMovies401()
        movieList.postValue(moviesList)
    }
}

In the above code, I have created the CoroutineExceptionHandler variable and attached that variable to ViewModelScope. Now, The API call returns the 401 Exception. So the exception will be directed to the exception handler to handle it.

In this way, we have a generic exception handler and attached the multiple Coroutine Builder.

Output:

com.example.kotlincoroutines D/Exception: HTTP 401 401 Unauthorized handled !

Canceling the Kotlin Coroutine

when the user leaves the screen or user wants to cancel some operation, then we need to cancel the operation running on the coroutine scope. to do this first, we need to create a Coroutine Scope variable called Job. Job used to do operation on coroutines including canceling.

var printingJob: Job? = null

fun startPrint() {

    printingJob = viewModelScope.launch {

        try {
            for (i in 1..1000) {
                delay(20)
                println(i)
            }
        } catch (e: Exception) {
            Log.d("Exception", "${e.message.toString()} handled !")
        } finally {
            Log.d("finally", "clear all resources")
        }
    }
}

fun stopPrint() {
    printingJob?.cancel()
}

In the above code, I have created a job variable and by calling the startPrint() function I will set the coroutine scope instance into it. Once started, it will print 1 to 1000 in the delay of 20 milliseconds.

whenever we need to cancel the job need to call the stopPrint() function to call the cancel() on the job.

Output:

com.example.kotlincoroutines I/System.out: 86 com.example.kotlincoroutines I/System.out: 87 com.example.kotlincoroutines I/System.out: 88 com.example.kotlincoroutines I/System.out: 89 com.example.kotlincoroutines I/System.out: 90 com.example.kotlincoroutines D/Exception: Timed out waiting for 2000 ms handled ! com.example.kotlincoroutines D/finally: clear all resources

Timeout on Kotlin Coroutine

Are you want to cancel the particular operation, if it takes a long time to complete in kotlin coroutines. Then you need to run the operation with withTimeout(timeInMilliseconds) function inside the coroutine scope. This will cancel the operation automatically after the defined time is reached.

fun startPrintWithTimeout() {

    viewModelScope.launch {
        try {
            withTimeout(2000) {
                for (i in 1..1000) {
                    delay(20)
                    println(i)
                }
            }
        } catch (e: Exception) {
            Log.d("Exception", "${e.message.toString()} handled !")
        }
        finally {
            Log.d("finally", "clear all resources")
        }
    }
}

In the above code, I am printing 1 to 1000 numbers in a 20 milliseconds delay inside the ViewModelScope. Also, I have surrounded the printing operation with the withTimeOut(2000) function. So, the printing operation will be canceled after 2000 milliseconds. Also, the printing operation is surrounded by a try/catch block. So the canceled operation with be caught.

Output:

com.example.kotlincoroutines I/System.out: 71 com.example.kotlincoroutines I/System.out: 72 com.example.kotlincoroutines I/System.out: 73 com.example.kotlincoroutines I/System.out: 74 com.example.kotlincoroutines D/Exception: Timed out waiting for 2000 ms handled ! com.example.kotlincoroutines D/finally: clear all resources

you can download this example on Github.

What’s Next:

• Kotlin Scope Functions Explained [Example]
• Koin — Dependency Injection Framework For Android

Conclusion

I hope you learned about the kotlin coroutine and how to handle the exception and cancel the kotlin coroutines. let me know your feedback in the comments.

Originally published at https://howtodoandroid.com on November 25, 2021.

Kotlin Coroutines — Exception Handling and Cancellation was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

By definition, Scoped functions are functions that execute a block of code within the context of an object.

Kotlin “scope functions” are functions that allow for changing the scope, or the range, of a variable. There are five such functions included in the Kotlin standard library: apply, run, with, let, and also.

before getting started into scope functions, i have explained about the basic of kotlin in details.

• Beginning Android Development with Kotlin
• Koin — Dependency Injection Framework For Android
• Ktor — Networking Client For Android — Howtodoandroid.com

Object References

To use these functions, we must understand a couple of things.

Inside a lambda of a scope function, this(lambda receiver) is used to access the context object. The same object can be accessed by using it(lambda argument). In general, both can perform similar things.

This

Inside a scope function, you will be able to reference the context object by a short word (this), instead of the name itself.

Note: We can exclude this keyword to refer to members of the class.

fun main() {
    var user = User("Joe","London")
    val username = with(user) {
        name = "Palani"
        address = "India"
        println("Name = $name , Address = $address")
        name
    }
}

data class User(var name: String, var address: String)

It

‘ let’ and ‘ also ‘ functions refer to the object’s context as a lambda argument.

fun main() {
    var user = User("Joe","London")
    user.let {
        println("Name : ${it.name}")
        println("Address : ${it.address}")
    }
}

data class User(var name: String, var address: String)

Return values

There are two types of return values that a scope function can return:

Lambda result

If we write any expression at the end of the code block, it becomes the return value for the scope function. Return value for ‘ let’, ‘ run’, and ‘ with ‘ functions is the lambda result.

fun main() {
    var user = User("Joe","London")
    val updatedUsername = user.let {
        it.name = "John"
        it.name
    }
    println("Updated Username : $updatedUsername")
}

data class User(var name: String, var address: String)

Context object

‘ apply’ and ‘ also’ functions return the context object itself. In this case, we don’t need to specify the return value. The context object is automatically returned.

fun main() {
    var user = User("Joe","London")
    val updatedUser = user.apply {
        name = "John"    
    }
    println("Updated Username : ${updatedUser.name}")
}

data class User(var name: String, var address: String)

Check the below table for the comparison.

let’s see the kotlin scope functions in detail.

Let

Mostly used for null checks, when applying ?.let on an object, we can rest safe that every time we access that object inside the scope function, the object will be not null. To reference the object inside the scope function, we use the keyword it.

• Context Object — it
• Returns — last statement
• Use case — let function is often used to provide null safety calls. Use safe call operator(?.) with ‘let’ for null safety. It executes the block only with the non-null value.

fun main() {
    
    var user:User? = null
    user?.let {
        println("First Time : User $user")
    }
    user = User("John","India")
    user?.let {
        println("Second Time : User $user")
    }
}

data class User(var name: String, var address: String)

Run

‘run’ function can be said as the combination of ‘ let’ and ‘ with ‘ functions.

• Context Object — it
• Returns — last statement
• Use Case — Used when the object lambda contains both initialization and the computation of the return value. Using run we can perform null safety calls as well as other computations.

It is the only scope function that has two variants.

run as extension

used to create a scope to run an operation over an object, and get a result.

fun main() {
    val user = User("mani","India")
    val username = user?.run {
        name = generateFullName(name)
        name
    }
    println(username)
}

fun generateFullName(name: String) : String {
    return name + " kandam"
}

data class User(var name: String, var address: String)

Note: run returns the last statement of the function.

run as function

reduce the scope of certain variables, to avoid unnecessary access.

fun main() {
    val user = User("mani","India")
    
    val username = run {
        generateFullName(user.name)
    }
    println(username)
}

fun generateFullName(name: String) : String {
    return name + " kandam"
}

data class User(var name: String, var address: String)

With

Similar to apply function, with is also used to change properties of an instance i.e. object configuration. The only difference is with is not an extension function. The last expression of with function returns a result.

• Context Object — this
• Returns — last statement
• Use Case — Run multiple operations on an object

fun main() {
    val user = User("mani","India")
    
    val username = with(user) {
    	name = "Sathish"
        address = "USA"
        name
    }
    
    println(username)
    
}

data class User(var name: String, var address: String)

Apply

Basically, if you are initializing an object, and setting a bunch of properties like in this case, you have a pretty solid candidate to apply this scope function.

• Context Object — this
• Returns — same object
• Use Case — Initialize and configure an object

fun main() {
    val user = User("mani","India")
    
    val updatedUser = user.apply {
        name = "Siva"
        address = "London"
    }
    
    println(updatedUser)
    
}

data class User(var name: String, var address: String)

Also

A common use also is for side effects without modifying the object. We can use it for doing some operations on the intermediate results. also does not transform the object. It returns the same object.

• Context Object — it
• Returns — same object
• Use Case — It is used where we have to perform additional operations when we have initialized the object members.

fun main() {
    val user = User("mani","India")
    
    val updatedUser = user.apply {
        name = "Siva"
        address = "London"
    }.also {
        println(it)  
    }
   
}

data class User(var name: String, var address: String)

That’s it. Thanks for reading.

Originally published at https://howtodoandroid.com on September 17, 2021.

Kotlin Scope Functions Explained [Example] was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

The rail is a side navigation component that displays three to seven app destinations and, optionally, a Floating Action Button. Each destination is represented by an icon and a text label.

The rail can function on its own at larger screen sizes, such as desktop and tablet. When users transition between screen sizes and devices, the rail can also complement other navigation components, such as bottom navigation.

Before getting into details, Checkout my other post on material design,

• Sliders — Material Component For Android
• ShapeableImageView — Material components for android
• Progress Indicators — Material Components For Android
• Android Chips — Material Component For Android

Navigation rails shouldn’t be used for:

• Small screen sizes
• Single tasks, such as viewing a single email
• Secondary navigation destinations

Before we can get started, you need to add the dependency for the Android Material Components library. The Navigation Rail is only currently available in the latest release of1.4.0.

implementation 'com.google.android.material:material:1.4.0'

Adding Navigation Rail in layout

Create a new layout file or just add the NavigationRailView to one of your existing layouts like in the following XML snippet.

<com.google.android.material.navigationrail.NavigationRailView
    android:id="@+id/navigation_rail"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    app:menu="@menu/navigation_rail_menu"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    style="@style/Widget.MaterialComponents.NavigationRailView.Colored" />

When adding this view to your layout, there are some typical guidelines that should be followed. These most likely depend on what your view hierarchy consists of, but as a general guide:

• The Navigation Rail should sit below the TopBar of the current screen. This Rail should not overlap the top bar or be shown underneath this. Its height should fill the space between the bottom of the top app bar and the bottom of the screen
• The Navigation Rail should be shown at the side of the main content area of the current screen. It should not be shown on top of this content, instead the content area should be shown next to the Navigation Rail.

Adding Menu

The parameter app:menu takes a menu reference and holds all the navigation views to be displayed in the NavigationRailas menu items.

<com.google.android.material.navigationrail.NavigationRailView
    android:id="@+id/navigation_rail"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    app:menu="@menu/navigation_rail_menu" />

An example menu navigation_rail_menu.xml look like this:

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/inbox"
        android:enabled="true"
        android:icon="@drawable/ic_baseline_inbox_24"
        android:title="Inbox"/>
    <item
        android:id="@+id/sent"
        android:enabled="true"
        android:icon="@drawable/ic_baseline_send_24"
        android:title="Sent"/>
    <item
        android:id="@+id/draft"
        android:enabled="true"
        android:icon="@drawable/ic_baseline_drafts_24"
        android:title="Draft"/>
    <item
        android:id="@+id/trash"
        android:enabled="true"
        android:icon="@drawable/ic_baseline_restore_from_trash_24"
        android:title="Trash"/>
</menu>

Menu Gravity

Navigation rail destinations can be aligned as a group to the top, bottom, or center of a layout. On tablets, bottom alignment can make destinations easier for a user to reach with their thumbs.

app:menuGravity=”top | center | bottom”

<com.google.android.material.navigationrail.NavigationRailView
    android:id="@+id/navigation_rail"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    app:menu="@menu/navigation_rail_menu"
    app:menuGravity="top" />

Menu Label Visibility

The label is only being shown for the currently selected item within the Rail. This is the default behavior for the label visibility and we can control this using the labelVisibilityMode attribute.

app:labelVisibilityMode=”auto | labeled | selected | unlabeled”

<com.google.android.material.navigationrail.NavigationRailView
    android:id="@+id/navigation_rail"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    app:menu="@menu/navigation_rail_menu"
    app:labelVisibilityMode="auto"
    app:menuGravity="top"/>

auto — when there are more than 3 items the Rail will use the selected option, otherwise, the labeled option will be applied.

labeled — Persistent text labels are visible at all times, regardless of a destination’s state.

selected — Selected text labels appear only when a destination is activated.

unlabeled — If all icons in the navigation rail can be expected to have clear meaning to users, labels can be omitted as a group.

Adding Layout Header

The rail provides a convenient container for anchoring the Floating Action Button (FAB) to the top of a screen, placing the app’s key action above navigation destinations.

Other than showing a menu inside of our Navigation Rail, we can provide a layout reference for the headerLayout attribute of the view.

app:headerLayout=”@layout/layout_fab”

<com.google.android.material.navigationrail.NavigationRailView
    android:id="@+id/navigation_rail"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    app:menu="@menu/navigation_rail_menu"
    app:headerLayout="@layout/layout_fab"
    app:labelVisibilityMode="labeled"
    app:menuGravity="top" />

layout_fab .xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/fabMain"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@android:drawable/ic_input_add"/>

</LinearLayout>

Styling the Navigation Rail

There are several bundled styles that can be used to control how the Navigation Rail is displayed on the screen.

Default

With this default style applied, the different parts of the Navigation Rail have the following attributes applied to them:

• Rail Width: 72dp
• Rail background: colorSurface
• Selected Icon color: colorPrimary
• Unselected Icon color: colorOnSurface (at 60%)

style="@style/Widget.MaterialComponents.NavigationRailView"

Colored

Similar to the PrimarySurface style.

• Rail Width: 72dp
• Rail background: colorPrimary
• Selected Icon color: colorOnPrimary
• Unselected Icon color: colorOnPrimary (at 60%)

style="@style/Widget.MaterialComponents.NavigationRailView.Colored"

Compact

In some cases, we may want our Navigation Rail to take up less width in the screen. If the default width appears to take up more space than is needed, the following style can be used to use a reduced width:

• Rail Width: 52dp
• Rail background: colorSurface
• Selected Icon color: colorPrimary
• Unselected Icon color: colorOnSurface (at 60%)

style="@style/Widget.MaterialComponents.NavigationRailView.Compact"

Colored.Compact

Similar to the PrimarySurface style that we previously covered, the Colored.Compact style uses the same attributes here with the small change of width:

• Rail Width: 52dp
• Rail background: colorPrimary
• Selected Icon color: colorOnPrimary
• Unselected Icon color: colorOnPrimary (at 60%)

style="@style/Widget.MaterialComponents.NavigationRailView.Colored.Compact"

PrimarySurface

The W idget.MaterialComponents.NavigationRailView.PrimarySurface style will automatically switch between the component’s primary-colored style in light theme and surface-colored style in dark theme.

• Rail Width: 72dp
• Rail background: colorPrimary
• Selected Icon color: colorOnPrimary
• Unselected Icon color: colorOnPrimary (at 60%)

style="@style/Widget.MaterialComponents.NavigationRailView.PrimarySurface"

Displaying Badges

Rail icons can include badges in the upper right corner of the icon. Badges convey dynamic information about the associated destination, such as counts or status.

To apply a badge we need to utilize the getOrCreateBadge function on our navigation rail.

val inboxBadge = mainBinding.navigationRail.getOrCreateBadge(R.id.inbox)

Change visibility of the badge using the visibility parameter.

inboxBadge.isVisible = true

Set the badge text using the number parameter.

inboxBadge.number = 10

Badge Gravity

We can control the positioning of the badge using the badgeGravity attribute of the BadgeDrawable.

inboxBadge.badgeGravity = BadgeDrawable.TOP_START

We can set the different badge gravity attributes.

• TOP_END
• TOP_START
• BOTTOM_END
• BOTTOM_START

Badge Color

We can set the colors for the badges individually, by using the backgroundColor and badgeTextColor on any of the BadgeDrawable references.

val inboxBadge = mainBinding.navigationRail.getOrCreateBadge(R.id.inbox)
inboxBadge.isVisible = true
inboxBadge.number = 10
inboxBadge.badgeGravity = BadgeDrawable.TOP_END
inboxBadge.backgroundColor = Color.GRAY
inboxBadge.badgeTextColor = Color.WHITE

Badge Overflow

If we want to manually adjust the maximum number of characters that are to be displayed within a badge, we can do so using the maxCharacterCount attribute.

val inboxBadge = mainBinding.navigationRail.getOrCreateBadge(R.id.inbox)
inboxBadge.isVisible = true
inboxBadge.number = 56
inboxBadge.maxCharacterCount = 2

Badge Offset

The navigation badges are displayed outside of the icon area with enough space to not cause any overlapping. The verticalOffset and horizontalOffset attributes can be used to provide a pixel value offset for our navigation badge.

val inboxBadge = mainBinding.navigationRail.getOrCreateBadge(R.id.inbox)
inboxBadge.isVisible = true
inboxBadge.number = 56
inboxBadge.badgeGravity = BadgeDrawable.TOP_END
inboxBadge.backgroundColor = Color.GRAY
inboxBadge.badgeTextColor = Color.WHITE
inboxBadge.maxCharacterCount = 2
inboxBadge.verticalOffset = 10
inboxBadge.horizontalOffset = 10

Handling Item Selected

we can set an item selection listener on our Navigation Rail and use this to react to any interactions with menu items — using the ID of the menu item to handle the corresponding menu item.

mainBinding.navigationRail.setOnItemSelectedListener { item ->
    when(item.itemId) {
        R.id.inbox -> {
            // Respond to navigation item 1 click
            true
        }
        R.id.sent -> {
            true
        }
        R.id.draft -> {
            true
        }
        R.id.trash -> {
            true
        }
        else -> false
    }
}

There’s also a method for detecting when navigation items have been reselected:

mainBinding.navigationRail.setOnNavigationItemReselectedListener { item ->
    when(item.itemId) {
        R.id.item1 -> {
            // Respond to navigation item 1 reselection
        }
        R.id.item2 -> {
            // Respond to navigation item 2 reselection
        }
    }
}

That’s it. Thanks for reading.

You can download this example on Github.

Originally published at https://howtodoandroid.com on September 15, 2021.

Navigation rail — Material Component For Android was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this post, I am going to explain about using the retrofit and recyclerview in jetpack compose with MVVM pattern. Everybody knows that the Jetpack Compose is a modern toolkit designed to simplify UI development.

Before jump in this example on retrofit and recyclerview. I have created posts on jetpack compose components, layouts, modifiers, and themes. go through this for a better understanding of jetpack compose.

• Getting started with jetpack compose — Basic components
• Getting started with jetpack compose — Layouts
• Getting started with jetpack compose — Modifiers
• Getting started with jetpack compose — ConstraintLayout
• Getting started with jetpack compose — Theming

Setup jetpack compose on android studio

Method 1 — Creating new Jetpack compose Project

Create New Project by selecting “ Empty Compose Activity “, It will add all the Gradle dependencies in the Gradle file and MainAcitivity to accept composable. So, straightaway we can start working on the project.

Method 2 — Migrate Existing Android Studio Project

Add jetpack compose version in the project build.gradle file.

buildscript {
    ext {
        compose_version = '1.0.0'
    }
    ...
}

Then, add the build features and compose options in your module-level build.gradle file.

compileOptions {
        sourceCompatibility "1.8"
        targetCompatibility "1.8"
    }
    kotlinOptions {
        jvmTarget = '1.8'
        useIR = true
    }
    buildFeatures {
        compose true
    }
    composeOptions {
        kotlinCompilerExtensionVersion compose_version
        kotlinCompilerVersion '1.5.10'
    }
    packagingOptions {
        resources {
            excludes += '/META-INF/{AL2.0,LGPL2.1}'
        }
    }

The next step is to add the jetpack compose dependencies in the gradle file.

implementation "androidx.compose.ui:ui:$compose_version"
    implementation "androidx.compose.material:material:$compose_version"
    implementation "androidx.compose.ui:ui-tooling-preview:$compose_version"
    implementation 'androidx.activity:activity-compose:1.3.1'
    debugImplementation "androidx.compose.ui:ui-tooling:$compose_version"

Finally, change your MainAcitivity.kt to extends ComponentActivity. Also, add the setContent to accept the composable content on oncreate().

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        }
    }
}

Setup Retrofit for jetpack compose

To getting started with a retrofit first, we need to add the retrofit dependencies.

implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation "com.squareup.okhttp3:okhttp:5.0.0-alpha.2" implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

Next, we need to create to ApiService to fetch data from the API.

In this example, I am using “https://howtodoandroid.com/apis/movielist.json" API to get a list of movies. the response object will be,

[{
        "category": "Latest",
        "imageUrl": "https://howtodoandroid.com/images/coco.jpg",
        "name": "Coco",
        "desc": "Coco is a 2017 American 3D computer-animated musical fantasy adventure film produced by Pixar"
    },
    {
        "category": "Latest",
        "imageUrl": "https://howtodoandroid.com/images/terminator_2.jpg",
        "name": "Terminator 2: Judgment Day 3D",
        "desc": "Similar to Cameron's Titanic 3D, Lightstorm Entertainment oversaw the work on the 3D version of Terminator 2, which took nearly a year to finish."
    },
    ....
]

So, let’s create a Model class to hold the response data.

Model.kt

data class Movie(val name: String, val imageUrl: String, val desc: String, val category: String)

Then, create an ApiService interface and a method to get list of movies.

interface ApiService {

    @GET("movielist.json")
    suspend fun getMovies() : List<Movie>
}

In this same ApiService, we can get the instance of the ApiService using the companion object.

interface ApiService {

    @GET("movielist.json")
    suspend fun getMovies() : List<Movie>

    companion object {
        var apiService: ApiService? = null
        fun getInstance() : ApiService {
            if (apiService == null) {
                apiService = Retrofit.Builder()
                    .baseUrl("https://howtodoandroid.com/apis/")
                    .addConverterFactory(GsonConverterFactory.create())
                .build().create(ApiService::class.java)
            }
            return apiService!!
        }
    }

}

Now, we have created ApiService for the API call. let’s create ViewModel to consume data.

Setup ViewModel

We can create a ViewModel by extending the ViewModel() class. So, Create a class MainViewModel and extends the ViewModel.

class MainViewModel : ViewModel() {

}

Next, we need to create mutablestateof() observable to notify the changes to composable at runtime.

check this to know more about State and Jetpack Compose | Android Developers.

Call the apiService.getMovies() inside the viewModelScope and set the response in the mutablestate variable.

class MainViewModel : ViewModel() {
    var movieListResponse:List<Movie> by mutableStateOf(listOf())
    var errorMessage: String by mutableStateOf("")
    fun getMovieList() {
        viewModelScope.launch {
            val apiService = ApiService.getInstance()
            try {
                val movieList = apiService.getMovies()
                movieListResponse = movieList
            }
            catch (e: Exception) {
                errorMessage = e.message.toString()
            }
        }
    }
}

Now the data is ready. Next, we need to display the data using the LazyColumn composable component.

Creating LazyColumn: Easy way to Recyclerview

If you need to display a large number of items (or a list of an unknown length), using a layout such as a Column can cause performance issues, since all the items will be composed and laid out whether or not they are visible.

Compose provides a set of components that only compose and lay out items that are visible in the component’s viewport. These components include LazyColumn and LazyRow.

A LazyColumn is a vertically scrolling list that only composes and lays out the currently visible items. It’s similar to a Recyclerview in the classic Android View system.

check more about lazyColumn.

Let’s create a composable function for the movie item.

MovieItem() composable

in this example, I am using the coil library to load images from API. please add the coil dependency in Gradle file.

implementation "io.coil-kt:coil-compose:1.3.2"

I have created a movie item in Card and set corner radius 8dp and elevation. Also, created a row with 20% for the image and the remaining 80% for the text data.

I am not explaining the movie item components here. I have explained the composable components in another post. please check that for a better understanding of creating composable components.

the movie composable function code,

@Composable
fun MovieItem(movie: Movie) {
    Card(
        modifier = Modifier
            .padding(8.dp, 4.dp)
            .fillMaxWidth()
            .height(110.dp), shape = RoundedCornerShape(8.dp), elevation = 4.dp
    ) {
        Surface() {

            Row(
                Modifier
                    .padding(4.dp)
                    .fillMaxSize()
            ) {

                Image(
                    painter = rememberImagePainter(
                        data = movie.imageUrl,

                        builder = {
                            scale(Scale.FILL)
                            placeholder(R.drawable.placeholder)
                            transformations(CircleCropTransformation())

                        }
                    ),
                    contentDescription = movie.desc,
                    modifier = Modifier
                        .fillMaxHeight()
                        .weight(0.2f)
                )


                Column(
                    verticalArrangement = Arrangement.Center,
                    modifier = Modifier
                        .padding(4.dp)
                        .fillMaxHeight()
                        .weight(0.8f)
                ) {
                    Text(
                        text = movie.name,
                        style = MaterialTheme.typography.subtitle1,
                        fontWeight = FontWeight.Bold
                    )
                    Text(
                        text = movie.category,
                        style = MaterialTheme.typography.caption,
                        modifier = Modifier
                            .background(
                                Color.LightGray
                            )
                            .padding(4.dp)
                    )
                    Text(
                        text = movie.desc,
                        style = MaterialTheme.typography.body1,
                        maxLines = 2,
                        overflow = TextOverflow.Ellipsis
                    )

                }
            }
        }
    }

}

the preview of the movie item,

The view for the movie item is ready. let’s use the lazyColumn to make it look like the recyclerview.

using lazyColumn, loop through all the items, and add the movie items.

@Composable
fun MovieList(movieList: List<Movie>) {
    LazyColumn {
        itemsIndexed(items = movieList) { index, item ->
            MovieItem(movie = item)
        }
    }
}

Making item Selectable

To make the item in lazyColumn is selected. First, we need to create the mutableState() variable to save the selected item position.

Also, pass the current index and selected item index to every item in the lazyColumn. along with the position we need to pass the lambda function for the click listener. on click of the movie item, we need to change the selected item position.

@Composable
fun MovieList(movieList: List<Movie>) {
    var selectedIndex by remember { mutableStateOf(-1) }
    LazyColumn {

        itemsIndexed(items = movieList) { index, item ->
            MovieItem(movie = item, index, selectedIndex) { i ->
                selectedIndex = i
            }
        }
    }

}

In this movie item compensable, we need to check that the current position and the selected position are the same or not. if same then we need to set the selected background for the item.

Also, add the clickable modifier for the movie item. by clicking the card, we need to change the selectedIndex . that will reload the composable and make the clicked item selected.

@Composable
fun MovieItem(movie: Movie, index: Int, selectedIndex: Int, onClick: (Int) -> Unit) {

    val backgroundColor =
        if (index == selectedIndex) MaterialTheme.colors.primary else MaterialTheme.colors.background
    Card(
        modifier = Modifier
            .padding(8.dp, 4.dp)
            .fillMaxWidth()
            .clickable { onClick(index) }
            .height(110.dp), shape = RoundedCornerShape(8.dp), elevation = 4.dp
    ) {
        Surface(color = backgroundColor) {
    ....
}

That’s it. Thanks for reading. You can download this example on Github.

Originally published at https://howtodoandroid.com on September 13, 2021.

Jetpack compose — Retrofit with Recyclerview was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

Jetpack Compose implements Material Theming and supports a dark theme by default. You can customize color, typography, and shape theming values to fit your product’s brand, and get access to convenient functions for working with a system of dark themes (like isSystemInDarkTheme, lightColors, and darkColors).

The default MaterialTheme from the documentation looks like this:

MaterialTheme(
    colors = colors,
    typography = Typography,
    shapes = Shapes,
    content = content
)

We can set custom attributes:

• colors: A complete definition of the Material Color theme for this hierarchy.
• typography: A set of text styles to be used as this hierarchy’s typography system.
• shapes: A set of shapes to be used by the components in this hierarchy.

Check out the example I have created for jetpack compose material theming:

you can download this example from github.

If you’re new to Compose, I highly recommend going through the following articles:

• Getting started with jetpack compose — Basic components
• Getting started with jetpack compose — Layouts
• Getting started with jetpack compose — Modifiers
• Getting started with jetpack compose — ConstraintLayout
• Getting started with jetpack compose — Scaffold layout

Let’s see the material theme attributes in detail.

Color

Jetpack Compose uses the Color class from Compose’s graphics package. We have many ways to define a color, but there are two common ways we use it more frequently.

One Way is defining the hex code of the color

valPurple200 = Color(0xFFBB86FC)

The other way is specifying the RGB values to the Color class:

val blue = Color(red = 0f, green = 0f, blue = 1f)

Since ARGB Hex is just a bunch of jargon to describe what the heck “ 0XFF00bc00 " means, let me translate:

• First two characters 0x tell the compiler that this is a hexadecimal number
• Second two characters , “FF" or "DC", represent Transparency/Opaqueness/Alpha in Hex
• The remaining six character pairs represent Red, Green, and Blue

Create a file called something like Color.kt (the name does not matter) and fill it with immutable values:

Color.kt

import androidx.compose.ui.graphics.Color

val Purple200 = Color(0xFFBB86FC)
val Purple500 = Color(0xFF6200EE)
val Purple700 = Color(0xFF3700B3)
val Teal200 = Color(0xFF03DAC5)

Accessing the Color from the color.kt when required.

Text(text = "Jetpack compose" , color = Purple500)

Colors class

The colors class allows us to define different Material Design Color System.

class Colors(
    primary: Color,
    primaryVariant: Color,
    secondary: Color,
    secondaryVariant: Color,
    background: Color,
    surface: Color,
    error: Color,
    onPrimary: Color,
    onSecondary: Color,
    onBackground: Color,
    onSurface: Color,
    onError: Color,
    isLight: Boolean
)

There are around 13 attributes in the constructor of Colors. Let's see what each attribute means.

• Primary — color displayed most frequently across your app’s screens and components;
• Primary Variant — color is used to distinguish elements using primary colors, such as top app bar and the system bar.
• Secondary — color provides more ways to accent and distinguish your product. Having a secondary color is optional, and should be applied sparingly to accent select parts of your UI;
• SecondaryVariant — color is used to distinguish elements using secondary colours;
• Background — color appears behind scrollable content;
• Surface — color uses on surfaces of components, like cards and menus;
• Error — color used for indicating an error.
• OnPrimary — color of text and icons displayed on top of the primary color.
• OnSecondary — color of text and icons displayed on top of the secondary color;
• OnBackground — color of text and icons displayed on top of the background color;
• OnSurface — color of text and icons displayed on top of the surface color;
• OnError — color of text and icons displayed on top of the error color.
• IsLight — Whether these colors are considered as a “light” or “dark” set of colors.

To make our support for DarkMode and LightMode easier, Jetpack Compose also provides two functions that generates default colors for these modes.

• darkColors
• lightColors

private val DarkColorPalette = darkColors(
    primary = Purple200,
    primaryVariant = Purple700,
    secondary = Teal200,
    onPrimary = Color.White,
    onSecondary = Color.Black
)

private val LightColorPalette = lightColors(
    primary = Purple500,
    primaryVariant = Purple700,
    secondary = Teal200,
    onPrimary = Color.White,
    onSecondary = Color.Black
)

We have successfully created colors for the Material Theme. Let’s create the Typography.

Typography

The Typograph is a class that helps us to style the texts. With the help of the Typograph class, we can customize FontFamily, FontStyle, FontWeight, LetterSpacing, TextDecoration, Color, and many more attributes related to texts.

class Typography(
    defaultFontFamily: FontFamily = FontFamily.Default,
    h1: TextStyle,
    h2: TextStyle,
    h3: TextStyle,
    h4: TextStyle,
    h5: TextStyle,
    h6: TextStyle,
    subtitle1: TextStyle,
    subtitle2: TextStyle,
    body1: TextStyle,
    body2: TextStyle,
    button: TextStyle,
    caption: TextStyle,
    overline: TextStyle
)

In addition to this, we should configure a Typography object with the following parameters:

• h1 is the largest headline, reserved for short and important text.
• h2 is the second-largest headline, reserved for short and important text.
• h3 is the third-largest headline, reserved for short and important text.
• h4 is the fourth-largest headline, reserved for short and important text.
• h5 is the fifth-largest headline, reserved for short and important text.
• h6 is the sixth-largest headline, reserved for short and important text.
• subtitle1 is the largest subtitle and is typically reserved for medium-emphasis text that is shorter in length.
• subtitle2 is the smallest subtitle and is typically reserved for medium-emphasis text that is shorter in length.
• body1 is the largest body and is typically reserved for a long-form text that is shorter in length.
• body2 is the smallest body and is typically reserved for a long-form text that is shorter in length.
• button is reserved for a button text.
• caption is one of the smallest font sizes it reserved for annotating imagery or introduce a headline.
• overline is one of the smallest font sizes.

We can override the needed font Style like h1, body1, button, etc as below,

Type.kt

val Typography = Typography(
    body1 = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Normal,
        fontSize = 16.sp
    ),
    button = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.W500,
        fontSize = 14.sp
    ),
    caption = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Normal,
        fontSize = 12.sp
    )
    
)

The example I have created,

@Composable
fun TypographyPreview() {

    Column(Modifier.width(400.dp).padding(10.dp)) {
        Text(text = "H2 " ,style = MaterialTheme.typography.h2)
        Spacer(modifier = Modifier.padding(4.dp))
        Text(text = "Subtitle 1 " ,style = MaterialTheme.typography.subtitle1)
        Spacer(modifier = Modifier.padding(4.dp))
        Text(text = "Body 1 " ,style = MaterialTheme.typography.body1)
        Spacer(modifier = Modifier.padding(4.dp))
        Text(text = "Button " ,style = MaterialTheme.typography.button)
        Spacer(modifier = Modifier.padding(4.dp))
        Text(text = "Caption " ,style = MaterialTheme.typography.caption)

    }
}

Done with the Typography. finally, create the shape.

Shape

Creating shapes with Jetpack Compose is super easy. Similar to how we created the Typography instance, we also create the instance of Shapes.

Shape.kt

import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.Shapes
import androidx.compose.ui.unit.dp

val Shapes = Shapes(
    small = RoundedCornerShape(4.dp),
    medium = RoundedCornerShape(4.dp),
    large = RoundedCornerShape(0.dp)
)

Let’s Create a Material Theme

By using the instances of colors, typography, and shapes above, we can make a material theme that can be used across the application.

@Composable
fun JetpackComposeThemingTheme(
    colors: Colors,
    content: @Composable() () -> Unit
) {
    MaterialTheme(
        colors = colors,
        typography = Typography,
        shapes = Shapes,
        content = content
    )
}

CustomComposeTheme is a composable function with two attributes:

isDarkTheme — To set the dark or light color scheme based on checking isSystemInDarkTheme.
content — A composable function where the MaterialTheme is to be used.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                Column {
                    Text(text = "Jetpack Compose")
                }
            }
        }

    }
}

Dark theme

Material composable that make use of a Surface (like Card, TopAppBar, etc.) automatically include dark theme properties like desaturated colors for accessibility, elevation overlays, and limited color accents. You can also incorporate these in custom scenarios.

isSystemInDarkTheme() is a call that asks any compatible Android device for the user's preference of a light or dark theme.

It returns a boolean value which we can use in a Ternary (Conditional) Assignment expression such as

colors = if (darkTheme) DarkColorPalette else LightColorPalette.

code to add the dark mode in theme,

@Composable
fun PurpleTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable() () -> Unit
) {
    val colors = if (darkTheme) DarkColorPalette else LightColorPalette
    MaterialTheme(
        colors = colors,
        typography = Typography,
        shapes = Shapes,
        content = content
    )
}

Material Icons

Jetpack Compose also provides a convenient means of using icons listed in the Material Icons tool, including all icon styles-filled, outlined, rounded, two-tone, and sharp. With this artifact, you can use icons directly, without the need to download SVGs and convert them to VectorDrawables in Android Studio.

Add dependency in module build.gradle

implementation "androidx.compose.material:material-icons-extended:$compose_version"

You can get the icon by,

Icon(Icons.Default.Add) // Default == Filled
Icon(Icons.Outlined.Notifications)
Icon(Icons.Rounded.ArrowForward)
Icon(Icons.TwoTone.Menu)
Icon(
   Icons.Sharp.Edit,
   tint = MaterialTheme.colors.primary
)

That’s all about jetpack compose theming.

You can download this example from Github.

Originally published at https://howtodoandroid.com on September 3, 2021.

Getting started with jetpack compose — Theming was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

A Scaffold is a layout that implements the basic material design layout structure. You can add things like a TopBar, BottomBar, FAB, or a Drawer. Jetpack Compose provides Scaffold Composable which can save a lot of time. It’s like a prebuilt template.

If you’re new to Compose, I highly recommend going through the following articles:

• Getting started with jetpack compose — Basic components
• Getting started with jetpack compose — Layouts
• Getting started with jetpack compose — Modifiers
• Getting started with jetpack compose — ConstraintLayout

looks at my sample scaffold layout,

setContent {
            JetpackComposeScaffoldLayoutTheme {
                // A surface container using the 'background' color from the theme
                Surface(color = MaterialTheme.colors.background) {
                    var toolbarTitle by remember {
                        mutableStateOf("Home")
                    }
                    val scaffoldState =
                        rememberScaffoldState(rememberDrawerState(initialValue = DrawerValue.Closed))
                    val scope = rememberCoroutineScope()

                    Scaffold(
                        modifier = Modifier.background(Color.White),
                        scaffoldState = scaffoldState,
                        topBar = {
                            AppToolbar(
                                scaffoldState = scaffoldState,
                                scope = scope,
                                toolbarTitle = toolbarTitle
                            )
                        }, drawerContent = {
                            DrawerView(scaffoldState = scaffoldState, scope = scope)
                        },
                        content = {},
                        bottomBar = { AppBottomBar() },
                        snackbarHost = { state -> MySnackHost(state) },
                        isFloatingActionButtonDocked = true,
                        floatingActionButtonPosition = FabPosition.Center,
                        floatingActionButton = { MyFloatingButton(scaffoldState) }
                        )
                }
            }
        }

and the output of this code,

Looks very simple. let’s see all the composable in detail,

Modifier

A modifier is a way to modify certain aspects of the component that result in how it’s displayed on the screen.

I am explained modifiers in another post. Please check it.

Getting started with jetpack compose — Modifiers

scaffoldState

It maintains the state of the scaffold composable. It contains drawerState and snackbarHostState to perform operations like close, opening the drawer. Also, show and hide the snackbar.

class ScaffoldState(
    val drawerState: DrawerState,
    val snackbarHostState: SnackbarHostState
)

set the scaffoldState in scaffold composable.

val scaffoldState = rememberScaffoldState(rememberDrawerState(initialValue = DrawerValue.Closed))
 Scaffold(modifier = Modifier.background(Color.White),
          scaffoldState = scaffoldState,
          ...
 }

rememberCoroutineScope

As LaunchedEffect is a composable function, it can only be used inside other composable functions. In order to launch a coroutine outside of a composable, but scoped so that it will be automatically canceled once it leaves the composition, use rememberCoroutineScope.

rememberCoroutineScope is a composable function that returns a CoroutineScope bound to the point of the Composition where it’s called. The scope will be canceled when the call leaves the Composition.

For example, display s snackbar we need to use remeberCoroutineScope,

val scope = rememberCoroutineScope()
    FloatingActionButton(onClick = {
        scope.launch {
            when (scaffoldState.snackbarHostState.showSnackbar(
                message = "Jetpack Compose Snackbar",
                actionLabel = "Ok"
            )) {
                SnackbarResult.Dismissed ->
                    Log.d("TAB", "Dismissed")
                SnackbarResult.ActionPerformed ->
                    Log.d("TAB", "Action!")
            }
        }
    }) {
        Text("X")
    }

TopAppBar

It’s a simple composable function to design the top bar of the app.

Let’s see the function of the TopAppBar:

@Composable
fun TopAppBar(
    title: @Composable () -> Unit,
    modifier: Modifier = Modifier,
    navigationIcon: @Composable (() -> Unit)? = null,
    actions: @Composable RowScope.() -> Unit = {},
    backgroundColor: Color = MaterialTheme.colors.primarySurface,
    contentColor: Color = contentColorFor(backgroundColor),
    elevation: Dp = AppBarDefaults.TopAppBarElevation
)

Parameters

title — provide the title text for the TopAppBar.

title = { Text(text = "Home") }

Modifier — Used to modify the background of the TopAppBar.

navigationIcon — Used to set the Navigation Icon like Drawer menu and handle the functions alike open the drawer by clicking the menu icon.

navigationIcon = {
    Icon(
        painter = painterResource(id = R.drawable.ic_baseline_menu_24),
        contentDescription = "Menu", modifier = Modifier.clickable {
            scope.launch {
                scaffoldState.drawerState.open()
            }
        }
    )
}

actions — The actions displayed at the end of the TopAppBar. This should typically be IconButtons. The default layout here is a Row, so icons inside will be placed horizontally.

actions = {
    val context = LocalContext.current
    Icon(
        painter = painterResource(id = R.drawable.ic_baseline_settings_24),
        contentDescription = "Setting", modifier = Modifier.clickable {
            Toast.makeText(context, "Open Setting", Toast.LENGTH_SHORT).show()
        }
    )
}

backgroundColor — Set the background color for the TopApBar.

elevation — the elevation of this TopAppBar.

This is the code for the sample I have created for the TopAppBar.

@Composable
fun AppToolbar(scaffoldState: ScaffoldState, scope: CoroutineScope, toolbarTitle: String) {
    TopAppBar(
        title = { Text(text = toolbarTitle) },
        modifier = Modifier.background(Color(0xFF008800)),
        navigationIcon = {
            Icon(
                painter = painterResource(id = R.drawable.ic_baseline_menu_24),
                contentDescription = "Menu", modifier = Modifier.clickable {
                    scope.launch {
                        scaffoldState.drawerState.open()
                    }
                }
            )
        },
        actions = {
            val context = LocalContext.current
            Icon(
                painter = painterResource(id = R.drawable.ic_baseline_settings_24),
                contentDescription = "Setting", modifier = Modifier.clickable {
                    Toast.makeText(context, "Open Setting", Toast.LENGTH_SHORT).show()
                }
            )
        }
    )
}

The Drawer Content

In the drawerContent, we need to provide the content for the Drawer. content of the Drawer sheet that can be pulled from the left side.

Let check out my sample drawer composable.

@Composable
fun DrawerContent(scaffoldState: ScaffoldState, scope: CoroutineScope) {

    Column(modifier = Modifier.fillMaxWidth()) {
        Image(
            painter = painterResource(id = R.drawable.ic_baseline_face_24),
            modifier = Modifier
                .size(100.dp)
                .align(Alignment.CenterHorizontally), contentDescription = "Face"
        )

        Spacer(modifier = Modifier.padding(4.dp))
        Text(
            text = "Velmurugan",
            style = MaterialTheme.typography.subtitle1,
            modifier = Modifier.align(
                Alignment.CenterHorizontally
            )
        )
        Spacer(modifier = Modifier.padding(4.dp))
        Text(text = "User1",
            Modifier
                .fillMaxWidth()
                .background(Color.Gray)
                .padding(8.dp, 4.dp)
                .clickable {
                    scope.launch {
                        scaffoldState.drawerState.close()
                    }
                })
        Spacer(modifier = Modifier.padding(4.dp))
    }
}

By using the scaffoldState we can show and close the drawer content.

scaffoldState.drawerState.open() — display the drawer

scaffoldState.drawerState.close() — close the drawer

BottomAppBar

The bottomAppBar is used to display the menu at bottom of the screen same as the bottom.

To create bottomAppBar, First, we need to create Menu items for the Bottom Navigation.

data class MenuItem(val title: String, val icon: ImageVector)

    fun getMenuList() : List<MenuItem> {
        val menuItems = mutableListOf<MenuItem>()
        menuItems.add(MenuItem(Navigations.HOME.name, Icons.Filled.Home))
        menuItems.add(MenuItem(Navigations.SEARCH.name, Icons.Filled.Search))
        menuItems.add(MenuItem(Navigations.FAVORITE.name, Icons.Filled.Favorite))
        menuItems.add(MenuItem(Navigations.SETTINGS.name, Icons.Filled.Settings))
        return menuItems
    }

    val bottomMenuList = getMenuList()

Next, we need to create BottomNavigation composable to create Menu item using the BottomNavigationItem.

@Composable
fun RowScope.BottomNavigationItem(
    selected: Boolean,
    onClick: () -> Unit,
    icon: @Composable () -> Unit,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    label: @Composable (() -> Unit)? = null,
    alwaysShowLabel: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    selectedContentColor: Color = LocalContentColor.current,
    unselectedContentColor: Color = selectedContentColor.copy(alpha = ContentAlpha.medium)
)

Parameters

selected — set the select state for the bottom navigation menu item.

onClick() — set the click listener for the menu item click.

i con:@Composable() — set the icon for the bottom navigation menu item.

icon = {
    Icon(
        imageVector = bottomMenu.icon,
        contentDescription = bottomMenu.title
    )
}

label — add the label for the menu item.

alwaysShowLabel: Boolean — show and hide the menu item label.

selectedContentColor: Color — content color for the selected menu item

unselectedContentColor: Color — content color for the unselected menu item.

Let’s see the example BottomAppBar,

@Composable
fun BottomAppBar() {
    data class MenuItem(val title: String, val icon: ImageVector)

    fun getMenuList() : List<MenuItem> {
        val menuItems = mutableListOf<MenuItem>()
        menuItems.add(MenuItem(Navigations.HOME.name, Icons.Filled.Home))
        menuItems.add(MenuItem(Navigations.SEARCH.name, Icons.Filled.Search))
        menuItems.add(MenuItem(Navigations.FAVORITE.name, Icons.Filled.Favorite))
        menuItems.add(MenuItem(Navigations.SETTINGS.name, Icons.Filled.Settings))
        return menuItems
    }

    val bottomMenuList = getMenuList()

    BottomNavigation {
        bottomMenuList.forEach { bottomMenu ->
            BottomNavigationItem(
                selected = bottomMenu.title == "Home",
                onClick = {
                },
                icon = {
                    Icon(
                        imageVector = bottomMenu.icon,
                        contentDescription = bottomMenu.title
                    )
                })
        }
    }
}

FloatingActionButton

we can create FAB using the FloatingActionButton composable function.

@OptIn(ExperimentalMaterialApi::class)
@Composable
fun FloatingActionButton(
    onClick: () -> Unit,
    modifier: Modifier = Modifier,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
    shape: Shape = MaterialTheme.shapes.small.copy(CornerSize(percent = 50)),
    backgroundColor: Color = MaterialTheme.colors.secondary,
    contentColor: Color = contentColorFor(backgroundColor),
    elevation: FloatingActionButtonElevation = FloatingActionButtonDefaults.elevation(),
    content: @Composable () -> Unit
)

Parameters

onClick() — set click listener for the FAB.

modifier — add view modification for the FAB.

shape = MaterialTheme.shapes.small.copy( CornerSize(percent = 50)) — Provide the shape for the FAB.

backgroundColor — set the background color for the FAB.

contentColor — set the content color on the FAB.

content — provide the content composable for the FAB.

Let’s see the sample FAB,

@OptIn(ExperimentalMaterialApi::class)
@Composable
fun FloatingActionButtonSample() {
    FloatingActionButton(onClick = {
        
    }) {
        Text("+")
    }
}

FloatingActionButtonPosition

When you have added a FAB, you can use FloatingActionButtonPosition to specify its position. The default position is at the end of your layout.

Now, I changed the position to the center using,

floatingActionButtonPosition = FabPosition.Center

Snackbar

By default, a Snackbar is provided, and we can just call it to show without setting it up. However, if we want to customize it, we can still set it up and customize it as below.

@OptIn(ExperimentalMaterialApi::class)
@Composable
fun MySnackHost(state: SnackbarHostState) {
    SnackbarHost(
        state,
        snackbar = { data ->
            Snackbar(
                modifier = Modifier
                    .padding(8.dp)
                    .background(Color.Black, RoundedCornerShape(8.dp)),
                action = {
                    Text(
                        text = "HIDE",
                        modifier = Modifier
                            .padding(8.dp)
                            .clickable {
                                state.currentSnackbarData?.dismiss()
                            },
                        style = androidx.compose.ui.text.TextStyle(
                            fontWeight = FontWeight.Bold,
                            color = MaterialTheme.colors.primary,
                            fontSize = 18.sp
                        )
                    )
                }
            ) {
                Text(text = data.message)
            }
        })
}

Now we can set the customized snackbar into the scaffold.

Scaffold(modifier = Modifier.background(Color.White),
                        scaffoldState = scaffoldState,
                        topBar = {
                        }, drawerContent = {
                            
                        },
                        content = {},
                        bottomBar = { BottomAppBar() },
                        snackbarHost = { state -> MySnackHost(state) },
                        isFloatingActionButtonDocked = true,
                        floatingActionButtonPosition = FabPosition.Center,
                        floatingActionButton = { FloatingActionButtonSample() }
                    )

Now, we set the custom snackbar into the scaffold layout.

The next step is to display the snackbar using the scaffoldState.

whenever we need to show the snackbar, we need to pass the message and the click action.

I have created a FAB composable, a click of the FAB, I am displaying the snackbar. please check the code below,

@OptIn(ExperimentalMaterialApi::class)
@Composable
fun FloatingActionButtonSample(scaffoldState: ScaffoldState) {
    val scope = rememberCoroutineScope()
    FloatingActionButton(onClick = {
        scope.launch {
            when (scaffoldState.snackbarHostState.showSnackbar(
                message = "Snackbar",
                actionLabel = "Ok"
            )) {
                SnackbarResult.Dismissed ->
                    Log.d("TAB", "Dismissed")
                SnackbarResult.ActionPerformed ->
                    Log.d("TAB", "Action!")
            }
        }
    }) {
        Text("X")
    }
}

That’s it. Thanks for reading.

You can download this example on GitHub.

Originally published at https://howtodoandroid.com on August 27, 2021.

Getting started with jetpack compose — Scaffold layout was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.

ConstraintLayout can help place composable relative to others on the screen and is an alternative to using multiple nested Row, Column, Box, and custom layout elements. ConstraintLayout is useful when implementing larger layouts with more complicated alignment requirements. — Android Developers

If you’re new to Compose, I highly recommend going through the following articles:

• Getting started with jetpack compose — Basic components
• Getting started with jetpack compose — Layouts
• Getting started with jetpack compose — Modifiers
• Getting started with jetpack compose — Scaffold layout

To use ConstraintLayout in Compose, you need to add this dependency in your build.gradle:

implementation "androidx.constraintlayout:constraintlayout-compose:1.0.0-beta02"

Steps to setup constraintLayout in jetpack compose

• Create reference for each composable in constraintLayout using createRefs() or createRef().
• Constraints are provided using the constrainAs modifier which takes the reference as a parameter and lets you specify its constraints in the body lambda.
• Constraints are specified using linkTo or other helpful methods.
• parent is an existing reference that can be used to specify constraints towards the ConstraintLayout composable itself.

Create constraintLayout

As mentioned earlier, First need to crate reference of each composable using createRefs() inside a constraintLayout.

ConstraintLayout() {
        val (textTopStart, textTopCenter, textTopEnd, textCenterStart,textCenter, textCenterEnd, textBottomStart, textBottomCenter, textBottomEnd) = createRefs()
     ....
}

Next, create a composable and add a constraint using constraintAs modifier. Also, specify constraints to the composable using linkTo().

Text(text = "Top start", Modifier.constrainAs(textTopStart) {
            top.linkTo(parent.top, 8.dp)
            start.linkTo(parent.start, 8.dp)
        })

Here’s an example of a composable using a ConstraintLayout:

@Composable
fun ConstraintLayoutLinkToParentExample() {

    ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .height(200.dp)) {

        val (textTopStart, textTopCenter, textTopEnd, textCenterStart,textCenter, textCenterEnd, textBottomStart, textBottomCenter, textBottomEnd) = createRefs()

        Text(text = "Top start", Modifier.constrainAs(textTopStart) {
            top.linkTo(parent.top, 8.dp)
            start.linkTo(parent.start, 8.dp)
        })

        Text(text = "Top Center", Modifier.constrainAs(textTopCenter) {
            top.linkTo(parent.top, 8.dp)
            start.linkTo(parent.start, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })

        Text(text = "Top End", Modifier.constrainAs(textTopEnd) {
            top.linkTo(parent.top, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })

        Text(text = "Center start", Modifier.constrainAs(textCenterStart) {
            top.linkTo(parent.top, 8.dp)
            bottom.linkTo(parent.bottom, 8.dp)
        })

        Text(text = "Center", Modifier.constrainAs(textCenter) {
            top.linkTo(parent.top, 8.dp)
            bottom.linkTo(parent.bottom, 8.dp)
            start.linkTo(parent.start, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })

        Text(text = "Center end", Modifier.constrainAs(textCenterEnd) {
            top.linkTo(parent.top, 8.dp)
            bottom.linkTo(parent.bottom, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })


        Text(text = "Bottom start", Modifier.constrainAs(textBottomStart) {
            start.linkTo(parent.start, 8.dp)
            bottom.linkTo(parent.bottom, 8.dp)
        })

        Text(text = "Bottom Center", Modifier.constrainAs(textBottomCenter) {
            bottom.linkTo(parent.bottom, 8.dp)
            start.linkTo(parent.start, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })

        Text(text = "Bottom end", Modifier.constrainAs(textBottomEnd) {
            bottom.linkTo(parent.bottom, 8.dp)
            end.linkTo(parent.end, 8.dp)
        })
    }
}

In the above code, I have created 9 different composable and aligned them in different parts of the constraint layout. the output of the above code.

ConstraintLayout using constraintSet

In the ConstraintLayout example, constraints are specified inline, with a modifier in the composable they’re applied to. If you want to decouple the constraint from the constraintLatyout, then we need to use constraintSet.

• create constraintSet using composable references and constraints.
• create constraintLayout by passing constraintSet as a parameter.
• Assign references created in the ConstraintSet to composables using the layoutId modifier.

We Will see the point in detail here,

First, need to create constraintSet.

val constraintSet = ConstraintSet {
        val buttonLogin = createRefFor("buttonLogin")
        val inputUsername = createRefFor("inputUsername")
        val inputPassword = createRefFor("inputPassword")

        constrain(inputUsername) {
            top.linkTo(parent.top, 32.dp)
            start.linkTo(parent.start, 16.dp)
            end.linkTo(parent.end, 16.dp)
        }

        constrain(inputPassword) {
            top.linkTo(inputUsername.bottom, 8.dp)
            start.linkTo(parent.start, 16.dp)
            end.linkTo(parent.end, 16.dp)
        }

        constrain(buttonLogin) {
            top.linkTo(inputPassword.bottom, 16.dp)
            start.linkTo(parent.start, 16.dp)
            end.linkTo(parent.end, 16.dp)
        }

    }

In the above code, First I have created references for the composable like buttonLogin, inputUsername.

Then, created constraints for the references. for the inputUsername , set top to parent and start to parent and end to parent. like that we need to create constraints for all the references.

Next, we need to pass the constraintSet as a parameter for the constraintLayout.

ConstraintLayout(constraintSet) {
        .....
    }

Finally, Assign references created in the ConstraintSet to composable using the layoutId modifier.

ConstraintLayout(constraintSet, modifier = Modifier
        .fillMaxWidth()
        .height(250.dp)) {
        val context = LocalContext.current
        var username by remember {
            mutableStateOf("")
        }
        var password by remember {
            mutableStateOf("")
        }
        TextField(value = username,  onValueChange = { username = it } , label = { Text(text = ("Username"))},  modifier =  Modifier.layoutId("inputUsername"))

        TextField(value = password, onValueChange = { password = it }, label = { Text("Password")},        visualTransformation = PasswordVisualTransformation(),
            modifier = Modifier.layoutId("inputPassword"))

        Button(onClick = { Toast.makeText(context, "Username $username , Password: $password ", Toast.LENGTH_SHORT).show()}, Modifier.layoutId("buttonLogin")) {
            Text(text = "Login")
        }
    }

We need to apply the created constraints by adding layoutId modifier to the composable. For the first TextField(), I have applied the inputUsername constraints.

Output for the above code,

Guildline

A guideline is an invisible view through which we can constraint the composables. The guideline can be aligned using percentage, offset, and padding. As guidelines are invisible, we can create responsive UI using them.

Types of guidelines

• createGuidelineFromTop — Creates a guideline at a specific offset/percentage from the top of the ConstraintLayout.
• createGuidelineFromRight — Creates a guideline at a width offset/percentage from the right of the ConstraintLayout.
• createGuidelineFromLeft — Creates a guideline at a width offset/percentage from the left of the ConstraintLayout.
• createGuidelineFromBottom — Creates a guideline at a specific offset/percentage from the bottom of the ConstraintLayout.

        // guideline 20 percentage from top
        val guildLineFromTop = createGuidelineFromTop(0.2f)
        // guideline 20 Dp from top
        val guildLineFromTop = createGuidelineFromTop(20.dp)

Let’s create a guideline of 20 percentage from the top of the contraintlayout. and link the guideline to composable.

@Composable
fun ConstraintLayoutGuideLine() {

    ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .height(100.dp)
        .padding(12.dp)) {

        val (input) = createRefs()
        val guildLineFromTop = createGuidelineFromTop(0.2f)

        Text(text = "GuildLine From top and start", modifier = Modifier.constrainAs(input) {
            top.linkTo(guildLineFromTop, 8.dp)
            start.linkTo(parent.start, 8.dp)
            end.linkTo(parent.end, 8.dp)
        } )
    }
}

Also, we can set multiple guidelines for the composable. Below, I have created two guidelines, one from the top of the parent layout and the other one is from the start of the parent layout.

@Composable
fun ConstraintLayoutGuideLine() {

    ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .height(100.dp)
        .padding(12.dp)) {

        val (input) = createRefs()
        val guildLineFromTop = createGuidelineFromTop(0.2f)
        val guildLineFromStart = createGuidelineFromStart(50.dp)

        Text(text = "GuildLine From top and start", modifier = Modifier.constrainAs(input) {
            top.linkTo(guildLineFromTop, 8.dp)
            start.linkTo(guildLineFromStart, 8.dp)
        } )
    }
}

Barrier

A Barrier is similar to a Guideline. But the barrier has reference to the views that you wish to use to form a “barrier” against. If anyone of the views grows, the barrier will adjust its size to the largest height or width of the referenced items.

Types of barriers

We can create four different barriers.

• createStartBarrier(vararg elements: ConstrainedLayoutReference)
• createEndBarrier(vararg elements: ConstrainedLayoutReference)
• createTopBarrier(vararg elements: ConstrainedLayoutReference)
• createBottomBarrier(vararg elements: ConstrainedLayoutReference)

Let’s see in the example,

First, create a reference for the components.

val (input1, input2, input3) = createRefs()

Next, create a barrier using the reference of the components.

val barrier = createEndBarrier(input1, input2)

here, I have created a createEndBarrier referencing input1, and input2.

finally, add the barrier to another component, that always wants to be the end of the barrier.

@Composable
fun BarrierExample() {
    ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .padding(12.dp)) {
        val (input1, input2, input3) = createRefs()

        val barrier = createEndBarrier(input1, input2)

        Text(text = "Iuput 1 Large", modifier = Modifier.constrainAs(input1) {
            top.linkTo(parent.top, 8.dp)
            start.linkTo(parent.start, 8.dp)
        } )

        Text(text = "Iuput 2", modifier = Modifier.constrainAs(input2) {
            top.linkTo(input1.bottom, 8.dp)
            start.linkTo(parent.start, 8.dp)
        } )

        Text(text = "Iuput 3", modifier = Modifier.constrainAs(input3) {
            top.linkTo(input1.bottom, 8.dp)
            start.linkTo(barrier, 8.dp)
        } )
    }
}

the output of the above code,

Chains

Chains allow us to align the views vertically or horizontally and also control the space between them, along with how the views use the space.

Type of chains

createHorizontalChain() -create horizontal chain.

createVerticalChain() — create vertical chain.

ChainStyle

we have three different types of chain styles.

• Spread : The views are evenly distributed.
• Spread inside : The first and last views are aligned to the constraints on each end of the chain, and the rest are evenly distributed.
• Packed : The views are packed together.

Let’s see the example,

First, I am creating three buttons with references inside a constaintLayout.

ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .padding(12.dp)) {
        val (button1, button2, button3) = createRefs()
    ....
}

Next, I am creating a horizontal chain with all the button references. also, I am using Spread inside chain style.

@Composable
fun ChainExample() {
    ConstraintLayout(modifier = Modifier
        .fillMaxWidth()
        .padding(12.dp)) {
        val (button1, button2, button3) = createRefs()

        createHorizontalChain(button1, button2, button3, chainStyle = ChainStyle.SpreadInside)


        Button(onClick = { }, modifier = Modifier.constrainAs(button1) {
            centerHorizontallyTo(parent)
        }) {
            Text(text = "Button 1")
        }

        Button(onClick = { }, modifier = Modifier.constrainAs(button2) {
            centerVerticallyTo(parent)
        }) {
            Text(text = "Button 2")
        }

        Button(onClick = { }, modifier = Modifier.constrainAs(button3) {
            centerHorizontallyTo(parent)
        }) {
            Text(text = "Button 3")
        }
    }
}

chain output with spread inside style,

chain with spread style,

chain with packed style,

That’s all about the constraintLayout.

You can download this example on GitHub.

Originally published at https://howtodoandroid.com on August 27, 2021.

Getting started with jetpack compose — ConstraintLayout was originally published in Howtodoandroid on Medium, where people are continuing the conversation by highlighting and responding to this story.