Android Application Architecture

Android Application Architecture

English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 3h 55m | 740 MB

Build scalable Android applications with effective UI Layer, reactive & clean architectures

Android OS has the largest installation base of any operating system in the world. In this course we will learn the skills it takes to build robust, maintainable Android applications. We will focus on architecture and design concepts that make decision making easy, allowing us to focus on developing features while not getting bogged down in broken code or too much up-front planning. We’ll learn that, with the right understanding and preparation, the process of Android application development can be as rewarding as using and sharing the applications we develop.

This course provides the foundational constructs, processes, and tools that are needed to write stable, full–featured, and maintainable Android applications. We cover architectural concepts for the UI layer, which is often the easiest part of the application to lose control of, and explore the overall application architecture.

You will start by building a UI for a personal project management application, organized into an MVP architecture. You will then leverage Google’s LiveData and ViewModel to handle Activity lifecycle concerns while also implementing RxJava to make the UI layer completely reactive. Next, you will explore Bob Martin’s Clean Architecture and learn how to begin thinking about the application in terms of layers of functionality: from the business domain, through use cases, and finally to the strap-on user interface. Lastly, you will integrate your app with a RESTful API to back up your data in the cloud.

This course follows a step by step approach that makes you familiar with various tools to build Android applications from basics.

What You Will Learn

  • Understand UI architecture and review some of the more commonly used Android approaches.
  • Dive into Model-View-Presenter UI architecture and see how to effectively apply it inside Activities and Fragments.
  • Build out a simple dependency management system for our application,
  • Learn a little about Dagger 2 while gaining insight into inversion of control and dependency injection.
  • Grasp reactive programming and see how to apply a reactive approach throughout an application.
  • Break Reactive down into consumable concepts, then see those concepts in action in our application using RxJava and Android Room.
  • Gain a strong understanding of application architecture then learn how to implement Clean Architecture.
  • Leverage external APIs while protecting your code base from those API’s structures or changes.
Table of Contents

UI Architecture
1 The Course Overview
2 MVC Architecture
3 MVVM
4 MVP
5 Testing at the UI Layer

Creating an Application UI
6 Creating a VisualList of Projects
7 Extracting a Model from Our UI Needs
8 Android Architectural Components – ViewModel and LiveData
9 Inversion of Control and Dependency Injection
10 Moving the View-Controlling Logic into a Presenter
11 Testing Our Presenter

Reactive Design
12 Inflows, Outflows, and Marbles
13 Single,Maybe, Completable, Observable
14 Mutations – Map and Flat Map
15 Intersections
16 Subjects
17 Error Handling

Applying Reactive Design to Our Application
18 Making Our Project List Reactive
19 Making Our Project List ViewModel and LiveData Reactive
20 Improve the Rx design to make it more sophisticated
21 RxJava Testing

Implementing a Clean Architecture
22 Thinking in Clean Architecture
23 Business Model, Interactors, and Presentation Layer
24 Building Our Business Layer
25 Building Out Our CRUD with Google’s Room Library
26 Creating Interactors for Our Projects List and Testing Them

Integrating with a Third-Party API
27 REST API Design
28 Creating a Simple REST API
29 Parsing Our REST API with Retrofit