Android Flashcards

Question

How do you handle it?

Answer 1

Kotlin offers some operators to handle this, for example: ● Safe calls operator (?): It is used in case you want to check the null condition and if the expression is null then by default it will return null or else it will return the value. ● Elvis operator (? :): This operator simplifies the validation of a value that could be null. This can guarantee that an expression won't return a null value, as you will provide a non-nullable value if the provided value is null. ● The not-null assertion operator (!!): As Kotlin's documentation says, this is for NullPointerExcetion-lovers. This operator converts any value to a non-null type and throws an exception if the value is null. But that is returning Java. We have some other features, but those are the most important. (Safe cast and Collections of a nullable type)

Answer 2

Never. Google doesn't recommend using it, but maybe some Java implementation or API requires it, and if this is the case, we need to use a try-catch to protect against exceptions.

Answer 3

The purpose of a Data Class is to simplify classes whose main purpose is to hold data. For this class, the compiler automatically generates: - copy() function, - equals() and hashCode() pair, - toString() form of the primary constructor, - And componentN() functions

Answer 4

An extension function provides a better way of extending a class without modifying the original class. It is important to say that by defining an extension do not actually modify the classes they extend, only making new functions callable with the dot-notation on variables of this type.

Answer 5

Scope functions are whose sole purpose is to execute a block of code within the context of an object. When you call such a function on an object with a lambda expression provided, it forms a temporary scope. In this scope, you can access the object without its name. let , run , with , apply , also

Answer 6

Sealed classes are used for representing restricted class hierarchies, when a value can have one of the types from a limited set, but cannot have any other type. Sealed classes can have fields and methods defined in them, including both abstract and implemented functions.

Answer 7

When using lambdas, the extra memory allocations and extra virtual method call, introduce some runtime overhead. When using inline functions, the compiler inlines the function body. That is, it substitutes the body directly into places where the function gets called. When using inline functions, there is no extra object allocation and no extra virtual method calls. However, we should not overuse the inline functions, especially for long functions since the inlining may cause the generated code to grow quite a bit. By default, all lambdas passed to an inline function would be inlined, too. However, we can mark some of the lambdas with the noinline keyword to exclude them from inlining.

Answer 8

High order function is one which can accept a function as a parameter or can return a function.We can pass a lambda expression as a parameter which is essentially anonymous functions that we can treat as values. Finally, in High-Order functions we have two types of functions which can be passed: - a function which returns Unit, - And a function which returns any of the value integer, string etc.

Answer 9

Object represents a single static instance, and can never have any more or any less than this one instance. Object expressions create objects of anonymous classes, that is, classes that aren't explicitly declared with the class declaration. This is useful for various techniques, including singleton objects and simple packaging up of functionality for encapsulation.

Answer 10

Companion objects are singleton objects whose properties and functions are tied to a class but not to the instance of that class. So, basically like the “static” keyword in Java.

Answer 11

Val - Is a read-only local variable (can be assigned a value only once) - is assigned one time on runtime execution. Var - Is a mutable variable (I mean, can be reassigned) So, var can be re-assigned and val can not be.

Answer 12

Val is assigned in runtime and Const val in compile time.

Answer 13

Lateinit - It is used with VAR - Reserves a space in memory - And you promise Kotlin that you will initialize it before you use it, or else the app will crash (Throws: Property not initialized) Lazy - It is used with VAL - Creates a wrapper class and delegates the value to it (by Lazy) - Used usually if getting the value requires expensive computation. - It will assign the value when you read it for the first time.

Answer 14

Migrate Whole Project 1. We want to do a meeting with the team, to plan and prioritize what modules we need to migrate first Migrate Module 2. Make sure we have the documentation from the module we want to migrate or create it if necessary. 3. Start by taking smaller to bigger and complex classes to migrate. Migrate Class 4. We take a Class and pass it through the IntelliJ Idea migration tool to convert Java to Kotlin 5. It is not perfect, but at least we have a starting point. 6. We now check for optimizations in the resultant code with the Kotlin features (scope functions, extensions, when, if, for statements, etc) 7. Also it is important to review Null cases, because Java doesn’t work with this unless you annotate with @Nullable or @Non-Nullable. 8. Finally we can run the class tests to make sure it still works as expected.

Answer 15

The superclass is Any.

Answer 16

by lazy use it when you must waiting a event to initialize the val and this val cant not be null. Late init use when yo dou want initialize a var and you assign which type is

Answer 17

null safety, less verbosal , clearer code

Answer 18

safety call verify if a variable is null and double bang you affirm your variable is not null. Also you never must use double bang

Answer 19

: there are simple classes used as data containers and do not encapsulate any additional logic. Simply put, Kotlin’s solution enables us to avoid writing a lot of boilerplate code.

Answer 20

1. Open the . java file. 2. Copy all the code to the clipboard. 3. Create the corresponding Kotlin. kt file. 4. Paste the code. (Click “Yes” when it asks for your permission to convert the code.) 5. If needed, check the class and update it.

Answer 21

● Change Java models to Kotlin first. ● Use default parameters and partialize annotation. ● While converting utils classes to extension function, use the same class name. ● To avoid changing the client code, use Kotlin JVM Annotation. ● Avoid loops with collection extensions. ● Kotlin recommends using “if” for binary for three or more options.

Answer 22

when you need that a class have inheritance because , kotlin class created by default are final

Answer 23

We have ConstraintLayout, LinearLayout, RelativeLayout, FrameLayout and TabLayout.

Answer 24

This layout allows you to create large and complex layouts that are responsive. It is similar to RelativeLayout because all views are laid out according to relationships between views and the parent layout but ConstraintLayout is more flexible and easier to use with Android Studio’s Layout Editor. To define the view’s position, you must add at least one horizontal and one vertical, if you missed it, you will get a compilation error.

Answer 25

This layout allows you to position the views or components by relations between components and parent

Answer 26

LinearLayout aligns the views or components one by one horizontally or vertically and ConstraintLayout uses relations to position and size the views or components and you can easily edit with the LayoutEditor.

Answer 27

Basically, ConstraintLayout comes to update RelativeLayout. They look similar but the big difference is that the ConstraintLayout uses a lower cost , and is faster than RelativeLayout since it only does one pass to calculate the views position. Constraint layout has many attributes and tools that allow us to better position the content, like vertical/horizontal bias, barriers, guidelines and chains. Also ConstraintLayout is optimized to use the Android Layout editor.

Answer 28

It is when you create a class and extend from View in order to create a totally new view Overriding the OnDraw method and OnMeasure. Like one I created for Gaszen, it was a specific circular progress bar that they wanted. I had to draw it using Paths with circles and arcs. Provide some methods to set the progress and colors.

Answer 29

It is when you create a class that extends from a ViewGroup (usually FrameLayout), where we inflate a group of views that we want to reuse. We can also provide methods to set/access the information.

Answer 30

CompoundView is when you have a group of views that you reuse by inflating them in a class that extends from a ViewGroup. On the other hand, a custom view refers to a class that you extend from View in order to draw it manually using Canvas in the methods onDraw and onMeasure.

Answer 31

It is a set of libraries for Android development created by Google, some of these libraries are LiveData, Databinding, viewBinding, ViewModel, Room, WorkManager, Hilt, CameraX, Navigation component and Compose.

Answer 32

LiveData, Databinding, viewBinding, ViewModel, Room, WorkManager, Hilt, CameraX, Navigation component and Compose.

Answer 33

It is a class that is responsible for preparing and managing the data for an Activity or a Fragment. It handles the communication between the view (Activity / Fragment) and the business logic classes. It is used also to retain data on view when there is configuration change (for example: when you rotate the device)

Answer 34

Because ViewModel is always created in association with a scope and will be retained as long as the scope is alive.

Answer 35

It is a library that allows you to bind UI components in your layouts (XML) to data sources in your app. It is really easy to implement, you just need to enable it on the Gradle.Build file, then implement it on the XML and finally on the UI (activity or fragment). (other answer) The Data Binding Library is a support library that allows you to bind UI components in your layouts to data sources in your app using a declarative format rather than programmatically.

Answer 36

There are One-way and Two-way binding, One-way is just for updating the view and Two-way is for getting the value from the XML or updating the value on the view.

Answer 37

It is an observable data holder class. It is not like a regular observable because It is lifecycle-aware which means it respects the lifecycle of other app components such as activities, fragments and service. It is used for allowing communication between the View (Activity, Fragment, etc) and the source of the data (ViewModel).

Answer 38

The main advantage is you do not need to manually cancel subscriptions between View and ViewModel.

Answer 39

he main disadvantage is that it does not come with a toolkit for combining streams of data or managing threads, like Rx does.

Answer 40

It is a LiveData subclass which may observe other LiveData objects and react on OnChanged events from them. It is used when you need to merge the emissions from 2 LiveData objects.

Answer 41

The use of signature-based permissions. Ask for credentials before showing sensitive information. For example you can ask for a PIN/ password/Pattern or a biometric credential. Use permissions with content providers. Use the HTTPS request if your application communicates with a web service that has a certificate. Use Webviews carefully, don’t allow users to navigate to sites that are outside of your control Store sensitive data safely, you can use Jetpack Security that gives us a way to encrypt files or data in Sharedpreferences. You can use SQLCipher to encrypt your data in your database.

Answer 42

It is a shrinker, optimizer and obfuscator, recently called R8. It detects and safely removes unused classes, fields, methods and attributes and also removes unused resources. It shortens the name of classes and members, which results in reduced DEX file sizes. It inspects and rewrites your code to further reduce the size of your app’s DEX files.

Answer 43

If you are using reflection, there are some classes that proguard does not detect as they are used, so Proguard removes those classes. You have to establish rules in proguard or with the use of Dagger you can solve this. Another issue is when you are using the property name sensible parser, for example GSON library, if you do not use the serializedName, Proguard could change the name of the attributes, thus the attribute will not match, you can solve this by using serializedName or you can use -keepclassmembers

Answer 44

It is a SQLite extension that adds an encryption layer to SQLite. The encryption is pretty strong, it is using AES-256 which is a standard in the industry.

Answer 45

You just need to implement the library on the Gradle file, then you have to instantiate a SupportFactory class, write a passphrase as a parameter and in the builder of the Room database you have to add the factory.

Answer 46

It is a library that provides the implementation of the best practices related to reading and writing data, as well as key creation and verification. It provides the level of security that is appropriate for banking and chat apps. This library uses a 2-part system for key management, a keyset that contains the keys to encrypt a file and a masterkey that encrypts all keysets. This library includes 2 libraries which are EncryptedFile and EncryptedSharedPreferences.

Answer 47

It provides custom implementations of FileInputStream and FileOutputStream, these provide secure read and write operations from file streams using the Streaming Authenticated Encryption with Associated Data.

Answer 48

It wraps the SharedPreferences class and automatically encrypts keys and values, key are encrypted using a deterministic encryption algorithm and values are encrypted using AES-256 and are non deterministic.

Answer 49

They are symmetric encryption, asymmetric encryption, hashing, digital signature, end to end encryption, elliptic-curve cryptography and HMAC.

Answer 50

is a type of encryption where only one key (a secret key) is used to both encrypt and decrypt electronic information There are two types of symmetric encryption algorithms: 1. Block algorithms. 2. Stream algorithms.

Answer 51

is when you use two keys for the process. ● The public key used for encryption is available to everyone but the private key is not disclosed. ● This encryption method is used in everyday communication over the internet.

Answer 52

Hashing is the process of transforming any given key or a string of characters into another value

Answer 53

A digital signature is a mathematical technique used to validate the authenticity and integrity of a message

Answer 54

End-to-end encryption (E2EE) is a method of secure communication that prevents third parties from accessing data while it's transferred from one end system or device to another

Answer 55

is a key-based technique for encrypting data. ECC focuses on pairs of public and private keys for decryption and encryption of web traffic.

Answer 56

Hash-based Message Authentication Code (HMAC) is a message authentication code that uses a cryptographic key in conjunction with a hash function. Hash-based message authentication code (HMAC) provides the server and the client each with a private key that is known only to that specific server and that specific client.

Answer 57

rapid feedback, early failure detection, safer code refactoring and stable development velocity.

Answer 58

Testing is a very important part of the app development process, because you can verify your app’s correctness, functional behavior and usability before you release it publicly.

Answer 59

Small 70%,medium 20%, large 10%

Answer 60

Dagger, Koin and most recently Hilt (You can mention that is something new that you are learning and practicing).

Answer 61

Dependency injection, is a design pattern that abstract the creation logic of dependencies and provides it to classes that need them. It helps us to make testing and mocking dependencies easier. It follows the dependency inversion principle.

Answer 62

Dagger 2 is a dependency injection framework. It is based on the Java Specification Request. It uses code generation and is based on annotations. The generated code is very relatively easy to read and debug. Dagger 2 uses the following annotations: ● @Module and @Provides: define classes and methods which provide dependencies ● @Inject: request dependencies. Can be used on a constructor, a field, or a method ● @Component: enable selected modules and used for performing dependency injection Dagger 2 uses generated code to access the fields and not reflection. Therefore it is not allowed to use private fields for field injection.

Answer 63

Hilt defines a standard way to do dependency injection (DI) in your application by providing containers for every Android class in your project and managing their lifecycles automatically for you.

Answer 64

Coroutines, RxJava and Asynctask I am using coroutines in my current project, but I have used RxJava and many years ago Asynctask.

Answer 65

: It is an API for asynchronous programming with Observable streams, It is a combination of the best ideas from the observer pattern, the iterator pattern, and functional programming. RxJava is easy for multi-threading, it has simple error handling and it avoids the callback hell.

Answer 66

It is the source that emits the data to the Observers, the Observers need to subscribe first to get the data emitted.

Answer 67

Cold Observable is the one that needs an Observer subscribed to start emitting data, and the Hot Observable is the opposite. It is emitting data even if there is no Observer subscribed.

Answer 68

It is component that tells the Observable or Observer on which thread they should run, we can use the method subscribeOn() to tell the Observable on which thread it should run and we can use the method observeOn() to tell the Observable on which thread they should emit the data. There are different schedulers for example: Schedulers.io() -> This one is used generally for network requests and database requests. Schedulers.computation() -> This one is used for performing CPU-intensive operations like processing huge data or bitmap processing. AndroidSchedulers.mainThread() -> This one is used for bringing back the execution to the main thread so UI updates can be done when required.

Answer 69

It is the instance created after an Observer subscribes to an Observable. We can unsubscribe to an Observable by calling the dispose() method on the Disposable instance.

Answer 70

It is the instance created after an Observer subscribes to an Observable. We can unsubscribe to an Observable by calling the dispose() method on the Disposable instance.

Answer 71

It is a class which is able to store many disposables in it, let say we have multiple calls happening, if would need to prematurely dispose, you need to dispose every disposable, but with CompositeDisposable you can add many disposables and if you need to dispose all at once, you just need to call dispose() method once.

Answer 72

is used for transformation only, but flatMap() is used for both transformation and flattening.

Answer 73

is the combination of a map and a flat operation i.e, it applies a function to elements as well as flatten them

Answer 74

concat combines a number of observables streams and sequentially emits all values from every given input stream. operator is basically a combination of two operators - concat and map. The map part lets you map a value from a source observable to an observable stream. does not subscribe to the next observable until the previous completes

Answer 75

Both map and flatMap can be applied to a Stream and they both return a Stream. The difference is that the map operation produces one output value for each input value, whereas the flatMap operation produces an arbitrary number (zero or more) values for each input value.

Answer 76

Flat map uses merge operator while concatMap uses concat operator.

Answer 77

Observable ● Flowable ● Single ● Maybe ● Completable

Answer 78

A coroutine is an instance of suspendable computation. It is conceptually similar to a thread, in the sense that it takes a block of code to run that works concurrently with the rest of the code.

Answer 79

new ,active ,completing, cancelling,cancelled ,completed

Answer 80

Flow is a better way to handle the stream of data asynchronously that executes sequentially. Flow lets you implement the observer pattern: a software design pattern that consists of an object (a.k.a. observable, producer, source, emitter) that maintains a list of its dependents, called observers (subscribers, collectors, receivers, etc.), and notifies them automatically of any state changes. Observables can be either hot or cold. Hot observables send or emit data even if no one is watching them and cold observables emit data only if they have an active observer. By default, Kotlin flows are cold.

Answer 81

There are the following basic ways to create a flow: ● flowOf(...) functions to create a flow from a fixed set of values. ● asFlow() extension functions on various types to convert them into flows. ● flow { ... } builder function to construct arbitrary flows from sequential calls to emit function. ● channelFlow { ... } builder function to construct arbitrary flows from potentially concurrent calls to the send function. ● MutableStateFlow and MutableSharedFlow define the corresponding constructor functions to create a hot flow that can be directly updated.

Answer 82

All implementations of the Flow interface must adhere to two key properties described in detail below: ● Context preservation. ● Exception transparency. These properties ensure the ability to perform local reasoning about the code with flows and modularize the code in such a way that upstream flow emitters can be developed separately from downstream flow collectors. A user of a flow does not need to be aware of implementation details of the upstream flows it uses.

Answer 83

Google Firebase is a Google-backed application development software that enables developers to develop iOS, Android and Web apps. ... The data is synced across all clients in real time and is still available when an app goes offline.

Answer 84

1.Register your app with Firebase 2. Add a Firebase configuration file 3.Add Firebase SDKs to your app

Answer 85

1.Register your app with Firebase 2. Add a Firebase configuration file 3.Add Firebase SDKs to your app

Answer 86

A push notification is a message that pops up on a mobile device. App publishers can send them at any time; users don’t have to be in the app or using their devices to receive them.

Answer 87

● App server sends a data message to FCM server ● The FCM message is delivered to the client app ● User opens the app

Answer 88

Cloud Firestore is a NoSQL document database that lets you easily store, sync, and query data for your mobile and web apps - at global scale.

Answer 89

The superclass is Object

Answer 90

public , private

Answer 91

Answer: It is design principles intended to make software more understandable, flexible and maintainable. The “S” is for Single Responsibility Principle: Every module, class or method should have a responsibility over a single part. We should not have objects which know too much and have unnecessary behavior. So, a class will do only one job. Thus, this class should have only one reason to change. The “O” is for Open-Closed Principle: Open means that we can add new features to class and Closed means that base features of class should not be able to change. The “L” is for Liskov Substitution Principle: We should be able to use subclasses instead of the parent classes which class they have extended, without the need to make any changes in our code. In simple words, a child class must be substitutable for the parent class. The “I” is for Interface Segregation Principle: As we know, interfaces provide layers of abstraction that simplify code and create barriers which are preventing coupling to dependencies. Classes should not implement interfaces which they are not going to use. The “D” is for the Dependency Inversion Principle: It tells us about the coupling between the different classes or modules. Higher level classes should not be dependent on lower level classes. Both should be dependent on abstractions.

Answer 92

Inheritance is the procedure in which one class inherits the attributes and methods of another class. The class whose properties and methods are inherited is known as the Parent class. The class that inherits the properties from the parent class is the Child class. And the child class can have its own properties and methods.

Answer 93

Inheritance is the procedure in which one class inherits the attributes and methods of another class. The class whose properties and methods are inherited is known as the Parent class. The class that inherits the properties from the parent class is the Child class. And the child class can have its own properties and methods.

Answer 94

It allows us to perform a single action in different ways. In other words, polymorphism allows you to define one interface and have multiple implementations. There are 2 types of polymorphism: Compile time Polymorphism and Runtime Polymorphism. Compile-time polymorphism is also known as static polymorphism, it is to achieve overloading that is when there are multiple functions with the same name but different parameters. Runtime polymorphism is achieved by method overriding; this occurs when a derived class has a definition for one of the member functions of the base class.

Answer 95

Using simple things to represent complexity. We all know how to turn the TV on, but we don’t need to know how it works in order to enjoy it. In Java, abstraction means simple things like objects, classes and variables represent more complex underlying code and data. This is important because it lets you avoid repeating the same work multiple times.

Answer 96

The practice of keeping fields within a class private, then providing access to those fields via public methods. Encapsulation is a protective barrier that keeps the data and code safe within the class itself. We can then reuse objects like code components or variables without allowing open access to the data system-wide.

Answer 97

hash table based implementation of Java's Map interface. A Map, as you might know, is a collection of key-value pairs.

Answer 98

In this interface class you define methods. Unlike a class, an interface never implements methods; instead, classes that implement the interface implement the methods defined by the interface. Another thing to mention is a class can implement multiple interfaces.

Answer 99

An abstract class is a class that is declared abstract —it may or may not include abstract methods

Answer 100

you can use only one abstract inheritance class and you can implement many interfaces has you want

Answer 101

Object is an instance of a class and a Class is a blueprint or template from which objects are created.

Answer 102

reusable solution to a commonly occurring problem within a given context in software design

Answer 103

Creational : Factory Method (Class) , Abstract Factorty ,Build , Prototype , Singleton (Object) Structural : Adapter (Class) , Adapter (Object), Bridge , Composite, Decorator , Facade , Flyweight , Proxy (Object) Behavioral : Interpreter, Template Method (Class), Chain of responsability, Command , iterador , Mediator , Memento , Observer , State , Strategy , Visitor

Answer 104

When I started programming in Android, I implemented a MVC pattern (in 2015), then I noticed that this pattern was difficult to test, because we had the majority of code in the Activity, so then, some years after, I started migrating the code to MVP pattern. In this pattern we had to separate the logic with the application’s view and communication through a contract between the MVP components, and allow us to improve our testing issues. Finally, in my last works, I have had to migrate from MVP to MVVM and also start new modules directly using MVVM. With MVVM we don’t have contracts, I mean the view doesn't know the ViewModel implementation and the ViewModel updates the UI through observers using Kotlin features like coroutines.

Answer 105

* MVVM is an architecture pattern whose main objective is the separation of concerns. * Views display the UI and inform about user actions. * The ViewModel gets the information from your Data Model, applies the necessary operations and exposes the relevant data to your Views. * The ViewModel exposes backend events to the Views so they can react accordingly. * The Model, also known as the DataModel, retrieves information from your backend and makes it available to your ViewModels

Answer 106

● MVVM facilitates easier parallel development of a UI and the building blocks that power it. ● By handling all data manipulation to ViewModels, unit testing becomes very easy since they don't have any reference to the Views ● MVVM abstracts the View and thus reduces the quantity of business logic required in the code behind it.

Answer 107

● MVVM may be too complex for applications with simple UI. ● While data bindings can be declarative and nice to work with, they can be harder to debug than imperative code where we simply set breakpoints.

Answer 108

https://www.geeksforgeeks.org/difference-between-mvc-mvp-and-mvvm-architecture-pattern-in-android/

Answer 109

MVP stands for “Model-View-Presenter”, is an architectural pattern which is mostly used for building user interfaces. In MVP, the presenter assumes the functionality of the “middle-man”. In MVP, all presentation logic is pushed to the presenter. MVP advocates separating business and persistence logic out of the Activity and Fragment.

Answer 110

Clean architecture is a software design philosophy that separates the elements of a design into ring levels. An important goal of clean architecture is to provide developers with a way to organize code in such a way that it encapsulates the business logic but keeps it separate from the delivery mechanism. The main rule of clean architecture is that code dependencies can only move from the outer levels inward. Code on the inner layers can have no knowledge of functions on the outer layers. Commonly in mobile application development, we find only 5 layers: presentation, use cases (sometimes found as Interactors), domain, data and framework. - Presentation: It is the layer that interacts with the user interface. Presentation layer usually consists of the Android user interface (activities, fragments, views) and presenters or view models, depending on the presentation pattern you choose to use. - Use cases (interactors): These are mainly the actions that the user can trigger. These can be active actions (the user clicks a button) or implicit actions (the App navigates to a screen). You can even remove this layer and include them inside the Domain layer. - Domain: Also known as the business logic. These are the rules of your business and contain all the business models. - Data: In this layer there is an abstract definition of the different data sources, and how they should be used. A repository pattern is usually used here, which, for a given request, is able to decide where to find the information. - Framework: It basically encapsulates the interaction with the framework, so the rest of the code can be agnostic and reusable in case you want to develop the same application for another platform.

Answer 111

The repository pattern is a strategy for abstracting data access.The idea with this pattern is to have a generic abstract way for the app to work with the data layer without being bothered with if the implementation is towards a local database or towards an online API. The repository pattern has two purposes; first it is an abstraction of the data layer and second it is a way of centralizing the handling of the domain objects.

Answer 112

● Create a retrofit instance with the builder ○ pass the base url and pass to retrofit builder ○ Create the okhttp client and pass to retrofit builder ○ Create the converter factory and pass to retrofit builder ● Provide the api passing a retrofit instance for create it ● Create the interface with suspend fun for call to service ● Create the data class to catch the response from network call ● Create the repository interface and repository class implementation , then you extend the class impl from repository interface ● Create mutable live data and live data in the viewmodel ● Create a function in your viewmodel in case of use mvvm To implement ● If you are using a mvvm pattern inject the repository in the viewmodel , if you are using mvp pattern inject in the model ● Use the viewmodel scope for launch the dispatcher.Io for make the network call ● Use the your api and call your suspend function inside the dispatcher io ● Pass the data received in your io dispatcher to your live data ● Call your viewmodel in your function ● Use your viewmodel in your view for observe the live data from your view model

Answer 113

Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs.