What is Jetpack with examples. - devshafique/Native-Android-Development-Blogs GitHub Wiki

Jetpack is a collection of libraries and tools for Android app development provided by Google. It is designed to help developers quickly and easily add advanced features to their apps, while also improving the app's performance, maintainability, and usability.

The main goal of Jetpack is to make it easier for developers to build high-quality, modern apps that take full advantage of the latest Android features and technologies. The Jetpack libraries provide a set of pre-built, high-quality components that can be easily integrated into an app, as well as a set of tools and best practices for app development.

Some of the main features of Jetpack include:

This component includes a set of core libraries for Android app development, such as AppCompat, Android KTX, and Test. These libraries provide basic functionality such as support for different Android versions, extension functions for easier and more concise code, and testing tools.

dependencies {
    implementation "androidx.core:core-ktx:1.3.2"
    implementation "androidx.appcompat:appcompat:1.2.0"
    testImplementation "junit:junit:4.13"
    androidTestImplementation "androidx.test.ext:junit:1.1.2"
    androidTestImplementation "androidx.test.espresso:espresso-core:3.3.0"
}

You can include foundation libraries in your app by adding them to your app's build.gradle file. In this example, we are using the core-ktx, appcompat, junit, and espresso libraries for testing.

This component includes a set of libraries and tools for managing the data and navigation of an app. The main libraries in this component include Room for database access, ViewModel for managing UI data, and LiveData for handling data updates.

import androidx.lifecycle.LiveData
import androidx.lifecycle.ViewModel
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query

class MyViewModel: ViewModel() {
    private val repository = MyRepository()
    val data: LiveData<List<MyData>> = repository.getData()
    
    fun insertData(data: MyData) {
        repository.insertData(data)
    }
}

class MyRepository {
    private val dao = MyDatabase.getDao()
    fun getData(): LiveData<List<MyData>> {
        return dao.getData()
    }
    
    fun insertData(data: MyData) {
        dao.insertData(data)
    }
}

@Dao
interface MyDao {
    @Query("SELECT * FROM my_table")
    fun getData(): LiveData<List<MyData>>
    
    @Insert
    fun insertData(data: MyData)
}

In this example, we are using the ViewModel, LiveData, and Room libraries to manage data in our app. We have a viewmodel that retrieves data from a repository class which in turn uses a Dao interface to interact with the Room database.

This component includes a set of libraries for building the user interface of an app. Some of the main libraries in this component include ConstraintLayout for creating complex layouts, Material Design for implementing Material design principles, and RecyclerView for displaying large lists of data.

import androidx.compose.foundation.Text
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Surface
import androidx.compose.runtime.Composable

@Composable
fun MyScreen() {
    MaterialTheme {
        Surface {
            Text("Hello, world!")
        }
    }
}

In this example, we are using the Compose UI libraries to create a simple screen with a Surface containing a Text element. The MaterialTheme is used to provide Material design styling to the screen.

Here we would love to give explain about "Jetpack Compose" which is the part of Jetpack UI component:

Jetpack Compose is a modern, reactive, and declarative UI toolkit for Android. It allows developers to build beautiful, responsive, and interactive user interfaces using a simple and intuitive API. Compose is built on top of the existing Android framework and is fully compatible with existing Android apps.

One of the main advantages of Compose is its ability to create UI elements in a declarative manner. Instead of specifying how the UI should look, developers specify what the UI should be. This makes the code more readable and maintainable, and also allows for better performance and flexibility.

Compose also supports reactive programming, which means that the UI can automatically update when the underlying data changes. This eliminates the need for manual updates and improves the overall performance of the app.

There are several different types of UI elements that can be created with Compose. Some of the most commonly used types include:

1. Text: A simple text element that displays a string of text.
2. Image: A simple image element that displays an image from a file or URL.
3. Button: A button that can be clicked to perform an action.
4. TextField: A text field that allows the user to enter text.
5. List: A list that displays a collection of items.
6. Column/Row: A layout element that arranges its children in a column or row.
7. Card: A card that displays information in a consistent format.
8. Surface: A surface that can be used to create a material design card.

Here's an example of how to create a simple button with Jetpack Compose:

import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material.Button
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier

@Composable
fun MyButton() {
    Column(modifier = Modifier.fillMaxWidth()) {
        Button(onClick = { /* Perform action */ }, modifier = Modifier.fillMaxWidth()) {
            /* Text or other child elements */
        }
    }
}

In this example, we first import the necessary Compose modules. Next, we define a composable function called "MyButton" that creates a column layout element with a fillMaxWidth modifier. Inside the column, we add a button element that has an onClick callback and fillMaxWidth modifier. The button element can also contain other child elements like text inside the {} block.

In this way, Jetpack Compose provides a modern, reactive and declarative way to build UI for Android apps. With its simple, intuitive API, and support for a wide range of UI elements, it makes it easy for developers to create beautiful and responsive apps.

This component provides an easy-to-use API for scheduling background tasks in your app. It allows you to schedule tasks with a variety of options, such as recurring tasks, tasks that run only when the device is charging, and tasks that run only when the device is connected to the internet.

import androidx.work.WorkManager
import androidx.work.OneTimeWorkRequest
import androidx.work.Worker

class MyWorker: Worker() {
    override fun doWork(): Result {
        // perform background task
        return Result.success()
    }
}

val workManager = WorkManager.getInstance(context)
val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
workManager.enqueue(workRequest)

In this example, we are using the WorkManager library to schedule a background task. We create a worker class that performs the task, then we enqueue a OneTimeWorkRequest to the WorkManager instance with the worker class.

This component provides a simple and efficient way to handle navigation within an app. It includes a navigation architecture that makes it easy to manage the back stack and handle deep linking, as well as a navigation editor for creating and editing navigation in a visual way.

import androidx.navigation.NavController
import androidx.navigation.Navigation

val navController = Navigation.findNavController(this, R.id.nav_host_fragment)
navController.navigate(R.id.action_destination)

In this example, we are using the Navigation library to handle navigation within our app. We first get a reference to the NavController and then we use the navigate method to navigate to a destination, specified by the action_destination.

This component enables you to load and display large data sets in a list or a grid in an efficient and memory-safe way. It provides a simple API for loading and displaying data, and supports both local and remote data sources.

import androidx.paging.PagedListAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView

class MyAdapter: PagedListAdapter<MyData, MyViewHolder>(diffCallback) {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
        // create view holder
    }

    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
        // bind data to the view holder
    }
}

val diffCallback = object : DiffUtil.ItemCallback<MyData>() {
    override fun areItemsTheSame(oldItem: MyData, newItem: MyData): Boolean {
        // compare items
    }

    override fun areContentsTheSame(oldItem: MyData, newItem: MyData): Boolean {
        // compare contents
    }
}

In this example, we are using the Paging library to load and display a large data set in a RecyclerView. We create a PagedListAdapter that takes care of loading and displaying the data, we also create a DiffCallback object to handle the comparison of items in the dataset.

This component provides a consistent and easy-to-use API for working with the camera on Android devices. It supports a wide range of features such as capturing images and video, previewing the camera feed, and applying image enhancements.

import androidx.camera.core.CameraX
import androidx.camera.core.Preview
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageCapture.Metadata
import androidx.camera.core.ImageCapture.OutputFileOptions

val preview = Preview.Builder().build()
val imageCapture = ImageCapture.Builder().build()
val imageAnalysis = ImageAnalysis.Builder().build()

CameraX.bindToLifecycle(this, preview, imageCapture, imageAnalysis)

// Take a photo
val file = File(... path to save the photo ...)
val outputOptions = OutputFileOptions.Builder(file).build()
val metadata = Metadata().apply {
    // Additional metadata to include in the photo
}
imageCapture.takePicture(outputOptions, metadata, object : ImageCapture.OnImageSavedCallback {
    override fun onImageSaved(outputFileResults: OutputFileResults) {
        // Handle the result of saving the photo
    }
    override fun onError(exception: ImageCaptureException) {
        // Handle errors
    }
})

In this example, we are using the CameraX library to work with the camera on an Android device. We create objects for the preview, image capture, and image analysis use cases, then we bind them to the lifecycle of the app. We also use the takePicture function to take a photo and save it to a file, and handle the result in a callback.

This component is a dependency injection library that provides a standard way to manage dependencies in your app. It allows you to define and manage dependencies in a modular and testable way.

import javax.inject.Inject
import dagger.hilt.android.AndroidEntryPoint
import dagger.hilt.android.scopes.ActivityScoped

@AndroidEntryPoint
class MyActivity: AppCompatActivity() {
    @Inject lateinit var myRepository: MyRepository

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        myRepository.doSomething()
    }
}

@ActivityScoped
class MyRepository @Inject constructor() {
    fun doSomething() {
        // Perform some action
    }
}

In this example, we are using the Hilt library to manage dependencies in our app. We have an MyActivity and a MyRepository class. We use the @Inject annotation to indicate that the MyRepository class should be provided by Hilt and the @AndroidEntryPoint annotation to indicate that this class should be used as an entry point for Hilt's dependency injection.

In the MyActivity class, we can directly inject the MyRepository class into the activity and use it. The @ActivityScoped annotation is used to scope the MyRepository class to the activity.

In this way, Hilt provides a standard way to manage dependencies in your app, it allows you to define and manage dependencies in a modular and testable way.

It is important to note that you need to include Hilt in your app gradle file and also configure it in your Application class before using it.

This component allows you to surface rich, dynamic, and interactive content from your app in the Google Search results. This can be used to surface relevant content from your app in Google Search results.

import android.content.Context
import androidx.core.graphics.drawable.IconCompat
import androidx.slice.Slice
import androidx.slice.SliceProvider
import androidx.slice.builders.ListBuilder
import androidx.slice.builders.ListBuilder.RowBuilder
import androidx.slice.builders.SliceAction

class MySliceProvider : SliceProvider() {

    override fun onCreateSliceProvider(): Boolean {
        return true
    }

    override fun onBindSlice(sliceUri: Uri): Slice? {
        val context = context ?: return null
        val listBuilder = ListBuilder(context, sliceUri, ListBuilder.INFINITY)
        listBuilder.setAccentColor(ContextCompat.getColor(context, R.color.colorAccent))

        // Add rows to the slice
        val row1 = RowBuilder(listBuilder)
        row1.setTitle("Row 1")
        row1.setPrimaryAction(createAction(context))

        val row2 = RowBuilder(listBuilder)
        row2.setTitle("Row 2")
        row2.setPrimaryAction(createAction(context))

        return listBuilder.build()
    }

    private fun createAction(context: Context): SliceAction {
        val intent = Intent(context, MyActivity::class.java)
        val icon = IconCompat.createWithResource(context, R.drawable.ic_launcher)
        return SliceAction.create(
            PendingIntent.getActivity(context, 0, intent, 0),
            icon,
            ListBuilder.ICON_IMAGE,
            "My Action"
        )
    }
}

In this example, we are using the Slices feature to create a slice that displays a list of rows.

Jetpack components are built on top of the Android framework and are fully compatible with existing Android apps. They are updated regularly to take advantage of the latest Android features and technologies, and are designed to work well together, making it easy for developers to add advanced features to their apps.