Gain insights into MVVM architecture in Android with Kotlin. Learn about networking with Retrofit, local storage with Room, and pagination. Discover how to build scalable, maintainable apps.

Mastering MVVM architecture with Kotlin-01.png

tarball.tar.gz

postman

The course focuses on the MVVM (Model-View-ViewModel) architecture in Android development using Kotlin. The MVVM is widely recommended due to its robustness, scalability, and ease of maintenance. It is a valuable skill to have for building high-performance Android applications.

Firstly, you will learn the basics of MVVM architecture and its advantages over other approaches to Android development. Then, you'll start from scratch and create layouts for a news application. Next, you'll use the Retrofit and OkHttp networking libraries and get to familiarize yourself with APIs. You'll get hands-on experience in storing data locally via the Room library. Finally, you'll be introduced to both the repository and ViewModel patterns, as well as how to work with the Paging library and deliver data to our fragments.

By the time you’re done with the course, you’ll be able to use MVVM in your Android projects, interact with APIs, store data locally, and implement pagination.

Mastering MVVM Architecture in Android Development using Kotlin

# Introduction to exceptions
Every program, new or old, has an exception handling mechanism in place because exceptions will always occur. The problem is not the exceptions themselves, but how they’re handled so that we avoid crashes and unexpected events happening on the user’s end. Poor exception handling results in bad user experience.

Exception handling can control errors in the program and avoid abnormal program termination by throwing messages about the exception. This essentially means that the entire program won’t have to be terminated, and that the exception will be caught using try/catch methods.


## What is an exception?

An **exception** is a problem that usually occurs at compile-time or runtime and presents a condition that a program can recover from, like a system crash or a null pointer exception.
Exceptions are divided into two types: checked and unchecked.

**Checked exceptions** are logical exceptions that indicate that something is wrong with our code but that the program can recover from it. For example, if an error occurs when calling an API, we can catch it with a try/catch block at compile-time.

**Unchecked exceptions** (also known as **runtime exceptions**) usually indicate that something’s wrong with the program and that the program is unrecoverable. An example is the `NullPointerException`, which is brought about by trying to access an object or variable that doesn’t exist.


# Exception handling

**Exception handling** is the process of responding to an occurrence that might break our program’s normal flow due to an exception occurring during compile-time.

They’re represented by the `Exception` Java class, which is a superclass of all exceptions in both Java and Kotlin.

Kotlin doesn’t have checked exceptions, only unchecked exceptions. Java has both types of exceptions, which can be caught at runtime. All these exception classes inherit from the `Throwable` class.

To handle errors, we can use try/catch methods to avoid program crashes and unnecessary breaks.


Learn how to handle errors and exceptions in Android.

Introduction

MVVM Architecture

Layouts

Layout Design Assessment

API

Android Web Services Assessment

Utility Classes

Repository Pattern

ViewModel Pattern

Android Business Logic Assessment

Views

Conclusion

Appendix

Exceptions and Code Handling

Introduction to exceptions

What is an exception?