Android Doc.

Activity lifecycle

onCreate() onRestart(): (Only called after onStop()) onStart() onResume() onPause() onStop() onDestroy()

Fragment lifecycle

onAttach() onCreate() onCreateView() onActivityCreated() onStart() onResume() onPause() onStop() onDestroyView() onDestroy() onDetach()

onCreate() method

It's the one method every activity must implement. The onCreate() method is where you should do any one-time initializations for your activity. For example, in onCreate() you inflate the layout, define click listeners, or set up data binding.

onStart() method

The onStart() lifecycle method is called just after onCreate(). After onStart() runs, your activity is visible on the screen. Unlike onCreate(), which is called only once to initialize, onStart() can be called many times in the lifecycle of your activity.

on Restart() method

It is invoked after the activity has been stopped and prior to its starting stage and thus is always followed by onStart() when any activity is revived from background to on-screen.

on Resume() method

invoked when the activity starts interacting with the user. At this point, the activity is at the top of the activity stack, with a user interacting with it. Always followed by onPause() when the activity goes into the background or is closed by the user.

onPause() method

invoked when an activity is going into the background but has not yet been killed. It is a counterpart to onResume(). When an activity is launched in front of another activity, this callback will be invoked on the top activity (currently on screen).

onStop() method

invoked whenthe activity isnot visible to the user. It is followed by onRestart() when the activity is revoked fromthe background, followed by onDestroy()when the activity is closed or finished, and nothing when the activity remains onthe background only.

onDestroy() method

The final call received before the activity is destroyed. This can happen either because the activity is finishing (when finish() is invoked) or because the system is temporarily destroying this instance of the activity to save space.

MVVM (Model View ViewModel)

is the industry-recognized software architecture pattern that overcomes all drawbacks of MVP and MVC design patterns. MVVM suggests separating the data presentation logic(Views or UI) from the core business logic part of the application.

MVVM (Model)

This layer is responsible for the abstraction of the data sources. Model and ViewModel work together to get and save the data.

MVVM (View)

The purpose of this layer is to inform the ViewModel about the user’s action. This layer observes the ViewModel and does not contain any kind of application logic.

MVVM (ViewModel)

It exposes those data streams which are relevant to the View. Moreover, it servers as a link between the Model and the View.

Jetpack Architecture Components in Android

is a set of software components, libraries, tools, and guidance to help in developing robust Android applications.

Architecture Components (Room)

is Google's new persistence library designed to make it easier to build offline apps. It tries to expose APIs that can leverage the full power of SQL while still providing an abstraction layer for managing the data as Java objects.

Room sub-components (Entity)

It is the annotated class for which the Room creates a table within the database. The field of the class represents columns in the table.

Room sub-components (DAO)

(Data Access Object): It is responsible for defining the methods to access the database and to perform operations.

Room sub-components (Database)

It is an abstract class that extends RoomDatabase class and it serves as the main access point to the underlying app’s relational data.

Architecture Components (ViewModel)

is one of the most critical classes of the Android Jetpack Architecture Component that support data for UI components. Its purpose is to hold and manage UI-related data.

Architecture Components (LiveData)

LiveData is an observable data holder class. LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services.

Dependency injection

Classes often require references to other classes. For example, a Car class might need a reference to an Engine class.

Dependency injection Hilt

library for Android that reduces the boilerplate of doing manual dependency injection in your project.

Hilt application class

All apps that use Hilt must contain an Application class that is annotated with @HiltAndroidApp.

Inject dependencies into Android classes

Once Hilt is set up in your Application class and an application-level component is available, Hilt can provide dependencies to other Android classes that have the @AndroidEntryPoint annotation:

Service

is an application component that can perform long-running operations in the background. It does not provide a user interface. Once started, a service might continue running for some time, even after the user switches to another application.