Book
  • Introduction
  • Welcome !!
  • Chapter 1: The mobile ecosystem
    • Fragmentation is the devil
    • There is more than one type of mobile app
    • ... more than one type of app
    • ... one type of app
    • Under pressure (ee da de da de) !!
    • Further reading!!
  • Chapter 2: Let's start with design thinking
    • A taste of design thinking
    • The five steps
    • Design for everybody
    • Accessibility in mobile apps
  • Chapter 3: Give me a context and I will give you an app
    • Users
    • Personas? Users ? What is the difference?
    • Please, help me to model the context
    • The context canvas
  • Chapter 4: Powerful models
    • Data architecture is the foundation of analytics
    • From data to information and knowledge
    • Information/Knowledge in our mobile ecosystem
    • Questions to ask yourselves when building and classifying questions
    • The visualization-data map
    • On the scene: describing how personas interact with your app
  • Chapter 5: A GUI is better than two thousand words
    • 'Good to Go:' Let's explore the Design Systems
    • Designing GUI Mocks
    • No prototype... no deal
  • Chapter 6: About mobile operating systems ... and other deamons
    • The Android OS ... son of LINUX
    • iOS son of Darwin? or is it iOS son of UNIX?
    • Kernels
  • Chapter 7: Yes, software architecture matters !!
    • Self-test time
    • About design and design constraints
    • Architects' mojo: styles and patterns
    • What you need is a tactic !!
    • Self-test time 2 (for real)
    • Further reading
  • Chapter 8: Finally... coding
    • MVC, MVVM, MV*, MV...What?
    • Programming models: the Android side
    • Hello Jetpack, my new friend... An Android Jetpack Introduction
    • Programming models: the iOS side
    • Controllers and more controllers
    • Flutter son of... simplicity
    • Programming models: Flutter?
    • Flutter: State matters... Let´s start simple
    • Flutter: State matters... Complex stuff ahead
    • Micro-optimizations
  • Chapter 9: Data pipeline
    • Generalities data pipelines
    • Data storage types
    • Types of data pipelines
  • Chapter 10: Error Retrieving Chapter 10
    • Eventual Connectivity on Mobile Apps
    • How to handle it on Android
  • Chapter 11: The jewel in the crown: Performance
    • As fast as a nail
    • Memory bloats
    • Energy leaks
    • Final thoughts
  • Chapter 12. Become a performance bugs exterminator
    • Weak or strong?
    • Micro-optimizations
    • The single thread game !!
    • Using multi-threading like a boss !!
    • Caching
    • Avoiding memory bloats
    • Further readings
Powered by GitBook
On this page
  • UI
  • Behaviour
  • Foundation
  • Architecture
  1. Chapter 8: Finally... coding

Hello Jetpack, my new friend... An Android Jetpack Introduction

PreviousProgramming models: the Android sideNextProgramming models: the iOS side

Last updated 1 year ago

(By Santiago Cortés-Fernández)


As defined on the Android Developers website,

Jetpack is a collection of Android software components to make it easier for you to develop great Android apps. These components help you follow best practices, free you from writing boilerplate code, and simplify complex tasks, so you can focus on the code you care about .

In other words, Android Jetpack is a collection of software components that were realesed in 2018 as a way to facilitate the development of Android applications. For example, as it was said in the previous section, Android apps can now be easily implemented using the MVVM architectural pattern thanks to the Jetpack components. In addition to this, Jetpack also counts with some other package libraries that aim to help developers to reduce boilerplate code, accelerate the development of apps, take advantage of Kotlin language, amonst some other very interesting functionalities.

Furthermore, as the image below depicts it, there are four current components that constitute Android Jetpack for developing high quality applications, with their own specific purpose and features.

Android Jetpack Components: Achitecture, UI, Foundation and Behaviour

UI

The UI components provide widgets and helpers that aim to improve the interactions that users have with Android applications. Among these components, some of the most interesting ones, which can be very useful to facilitate the development of the project and contribute significantly to the users experience, are:

Behaviour

The Behaviour components are oriented to help developers with the integrations of standard Android services. Some of this components are:

Foundation

The Foundation components provide cross-cutting functionalities such as:

Architecture

The Architecture components are used by developer to design robust, testeable and maintainable applications. Amongst all the elements that compose this Android Jetpack component, it contains all the necessary elements to implement a fully lifecycle-aware application with the MVVM architectual pattern.


: Used (as you imagined) for moving widgets and to create transitions between screens.

: Represents a behaviour or portion of the user interface, used for dynamic and flexible UI designs (and to reduce boilerplate layouts and code).

: Are used for creating and designing the structure of the user interface.

: Used for designing layout themes and to apply custom colors to the elements of the app.

: Components created to help develop apps for Wear.

: Providing a notification API that also works with Wear.

: Needed to request permission to access sensitive data from users (contacts, camera, multimedia, etc.).

: Used to create interactive settings for the user to choose (some of) the overall functionality and behaviour of an application.

: Backwards compatible APIs for media playback and routing.

*: Are support libraries which help applications developed in newer versions to work with older versions.

: As the name says it, this components give developers a set of testing tools to verify an aplication's correctedness, funcionality, etc.

: A set of Kotlin extensions to help with a consice and pleasant app development using the Kotlin language

Check our describing the main architecture components to start developing an Android application with the help of Android Jetpack.

Check the following to learn more about Android Jetpack!

To have a better understanding of how Jetpack libraries are developed, tested, packageed, versioned and released (It could be quite helpful) check this to learn about AndroidX

Check the Android Architecture Components to learn more about how to implement MVVM in Android.

Animation and Transition
Fragments
Layouts
Palette
Wear OS by Google
Notifications
Permissions
Preferences
Media & Playback
AppCompat
Testing
Kotlin Support
guide
link
link
guide
(Android Developers)