Shape Shape point chapter-list Group Group Group Shape Copy 12 Shape Shape Copy 3 Shape Shape dropdown editor editor Combined Shape grid Shape Copy 4 Shape Copy 7 Shape language language Shape megaphone paperback Shape platform noun_419259-2 copy play-icon BS-Question-Rounded-Circle quotes noun_610406 stacked-books-1 stacked-books-2 Group Group Group Group Group
Sale

Advanced Android App Architecture

$49.99 $59.99 4.5/5 4 reviews · Write a Review
  • Platform Android 9
  • Language Kotlin 1.3
  • Editor AS 3.2

In Advanced Android App Architectures, you'll find a diverse and hands-on approach to architecting your apps on Android. Android development can be fun; however, scaling an app can have its fair share of problems.

In this book, you'll learn why a conversation on architecture is the first important step to taking your app to the next level!

Developer Guide

Intermediate

For Intermediate Developers

In Advanced Android App Architectures, you'll find a diverse and hands-on approach to architecting your apps on Android. Android development can be fun; however, scaling an app can have its fair share of problems.

In this book, you'll learn why a conversation on architecture is the first important step to taking your app to the next level!

This book will introduce you to a number of architectures, including Model View Controller, Model View Presenter, Model View Intent, Model-View-ViewModel and VIPER. You'll learn theory, explore samples that you will refactor and learn the fundamentals of testing.

We also recommend

Table of Contents

Section I: Building a Foundation

1.

Introduction - New

This chapter explains what this book is about and its intended audience. By reading this chapter, you’ll gain a better understanding of why apps need good architecture. You’ll also get an introduction to the sample app that you’ll be building throughout this book.

2.

Model View Controller Theory - New

The sample project starts off written in the Model View Controller pattern, with the Android Activity serving as both the View and the Controller. In this chapter, you’ll learn the history of the MVC pattern as applied to Android, and you’ll learn why this UI architecture pattern fails to meet two primary standards for good code: separation of concerns and unit testability.

3.

Testing Model View Controller - New

Here, you’ll get a quick review on writing unit tests with JUnit, and you’ll learn why the MVC pattern results in poor unit testability of code.

4.

Android Architecture Components - New

In this chapter, you’ll get an overview of the Android Architecture Components and go into detail on the libraries used in the sample project at various points in the book: Room, ViewModel, LiveData and Data Binding.

5.

Dependency Injection - New

An important concept in writing testable code is using dependency injection to inject mock objects into code. Here, you’ll learn the theory behind dependency injection and create a practical sample project using Dagger 2, a popular dependency injection framework for both Java and Android.

6.

RxJava - New

In this chapter, you’ll get an overview of RxJava and go into detail on how the library is used in the sample project at various points in the book.

Section II: Fundamental UI Architectures

7.

Model View Presenter Theory

The first architecture pattern you’ll learn is Model View Presenter. Here, you’ll learn the theory behind pulling presentation logic out of the Android Activity and why it results in a significant improvement over the MVC pattern in terms of separation of concerns and testability of code.

8.

MVP Sample - New

With theory in tow, you’ll then refactor WeWatch to the MVP pattern step-by-step.

9.

Testing MVP - New

Now that you’ve refactored the app to MVP, you can write unit tests on the logic that previously was untestable when it was in the MVC pattern.

10.

MVVM Theory - New

The next architecture pattern you’ll learn is Model View ViewModel, a pattern which centers on exposing a stream of events to Views. Architecting your app this way helps you write loosely coupled and easily testable code.

11.

MVVM Sample with Data Binding

In this chapter, you’ll refactor WeWatch to the MVVM pattern using the Data Binding library from Android Architecture Components.

12.

MVVM Sample with AAC - New

In this chapter, you’ll again refactor WeWatch to the MVVM pattern, this time using a combination of the ViewModel and LiveData libraries from Android Architecture Components.

13.

Testing MVVM - New

Having completed the refactoring of the app to MVVM, you’ll write unit tests on the ViewModel to ensure it behaves as expected.

Section III: VIPER and MVI

14.

VIPER Theory - New

Here, you’ll learn all of the theory behind each of the layers of the VIPER architecture pattern: View, Interactor, Presenter, Entity and Router.

15.

VIPER Sample - New

Now that you know how VIPER works, you’ll apply your new knowledge by rewriting WeWatch using this new pattern. You’ll also learn how to use Cicerone to create your Routers to navigate through the Views of your app.

16.

Testing VIPER - New

In this chapter, you’ll learn how to test your VIPER implementation by creating unit tests for each of your Presenters and using Mockito to mock your Views and Interactors.

17.

Model View Intent Theory - New

MVI is a special architecture pattern that relies on reactive programming to react to user actions and render your Views. You’ll learn how to create Intents, Views and Models that represent a state of your app.

18.

Model View Intent Sample - New

Here, you’ll rewrite WeWatch using the MVI pattern and the popular RxJava framework for your Observable callbacks.

19.

Debugging MVI - New

In this chapter, you’ll learn how to debug your MVI implementation using RxJava operators — such as onNext() — to see which was the last Intent emitted and the last View rendered.

Meet the team

Average Rating

4.5 /5

Leave a review for this product

4 reviews

Advanced Android App Architecture

In Advanced Android App Architectures, you'll find a diverse and hands-on approach to architecting your apps on Android. Android development can be fun; however, scaling an app can have its fair share of problems.

In this book, you'll learn why a conversation on architecture is the first important step to taking your app to the next level!

Top