Arquitetando seu app Android com Jetpack

Arquitetando seu app
Android com Jetpack
Nelson Glauber
@nglauber

Porque devemos nos
preocupar com arquitetura?
‣ Frameworks forçam o desenvolvedor a seguir o próprio
framework e não os princípios da engenharia de
software.
‣ Sua arquitetura deve deixar claro o propósito do sistema,
não os frameworks utilizados.
‣ A lógica de negócio deve estar claramente separada e
independente de framework.

Arquitetura
‣ Regra Principal: não há regras. Mas existem princípios que
devem ser seguidos. Lembra do S.O.L.I.D.?
‣ Promove a organização e o desacoplamento do código.
‣ Deve facilitar a manutenção e a adição de novas
funcionalidades.
‣ Uma arquitetura deve ser testável!
‣ Ela incrementa a complexidade? Sim! Vale à pena? Com
certeza! 😎 Mas deve ser de conhecimento de toda à equipe.
Single Responsibility Principle
Open-Closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle

MVP
View
IView
Presenter Model
User interaction Request
DataUI Logic
implements
IPresenter
implements

MVVM
View ViewModel Model
Observes
User interaction
Data
Request

ordem das letras MVVM e MVP não faz sentido

https://fernandocejas.com/2014/09/03/architecting-android-the-clean-way/

https://github.com/nglauber/books_jetpack/

UI (app)
Presentation
Domain
Remote Local
Data

‣ Módulo Kotlin
‣ Normalmente contém classes de
dados e interfaces.
‣ Decisão importante aqui: esse
app será reativo? 🤔
Data

Coroutines Flow
https://bit.ly/2KwSkDs

interface BooksRepository {
fun loadBooks(): Flow<List<Book>>
fun loadBook(bookId: String): Flow<Book>
suspend fun saveBook(book: Book)
suspend fun remove(book: Book)
}

Local
‣ Módulo Android
‣ Faz a implementação do
repositório local
‣ Book do módulo data é diferente
do Book deste módulo

Room
‣ ORM (Object-Relational Mapping) para
SQLite.
‣ Suporta live updates por meio de
LiveData, RXJava (Observable/Flowable)
e Coroutines (suspend/ﬂow)
Local

@Entity
@TypeConverters(MediaTypeConverter::class)
data class Book(
@PrimaryKey
var id: String,
var title: String = "",
var author: String = "",
var coverUrl: String = "",
var pages: Int = 0,
var year: Int = 0,
@Embedded(prefix = "publisher_")
var publisher: Publisher,
var available: Boolean = false,
var mediaType: MediaType = MediaType.PAPER,
var rating: Float = 0f
)

@Dao
interface BookDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun save(book: Book)
@Delete
suspend fun delete(vararg book: Book)
@Query("SELECT * FROM Book WHERE title LIKE :title ORDER BY title")
fun bookByTitle(title: String = "%"): Flow<List<Book>>
@Query("SELECT * FROM Book WHERE id = :id")
fun bookById(id: String): Flow<Book>
}

@Database(entities = [Book::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
abstract fun bookDao(): BookDao
companion object {
private var instance: AppDatabase? = null
fun getDatabase(context: Context): AppDatabase {
if (instance == null) {
instance = Room.databaseBuilder(
context.applicationContext,
AppDatabase::class.java,
"booksDb")
.build()
}
return instance as AppDatabase
}
}
}

class RoomRepository(
db: AppDatabase,
private val fileHelper: FileHelper
) : BooksRepository {
private val bookDao = db.bookDao()
override suspend fun saveBook(book: Book) {
if (book.id.isBlank()) {
book.id = UUID.randomUUID().toString()
}
return if (fileHelper.saveCover(book)) {
bookDao.save(BookConverter.fromData(book))
} else {
throw RuntimeException("Error saving book's cover.")
}
} 
...

class RoomRepository(
db: AppDatabase,
private val fileHelper: FileHelper
) : BooksRepository {
private val bookDao = db.bookDao()
override fun loadBooks(): Flow<List<Book>> {
return bookDao.bookByTitle()
.map { books ->
books.map { book ->
BookConverter.toData(book)
}
}
}
...

‣ Módulo Kotlin
‣ Implementação da lógica de
maneira abstrata
Domain

open class ListBooksUseCase(
private val repository: BooksRepository
) {
fun execute(): Flow<List<Book>> {
return repository.loadBooks()
}
}

open class SaveBookUseCase(
private val repository: BooksRepository
) {
suspend fun execute(params: Book) {
return if (bookIsValid(params)) {
repository.saveBook(params)
} else {
throw IllegalArgumentException("Book is not valid")
}
}
private fun bookIsValid(book: Book): Boolean {
return (
book.title.isNotBlank() &&
book.author.isNotBlank() &&
book.pages > 0 &&
book.year > 1900 &&
book.year <= Calendar.getInstance().get(Calendar.YEAR)
)
}
}

Data Binding
• Torna fácil a conexão entre a
View e o Presenter/ViewModel.
• Permite extender arquivos de
layout com micro-expressões.
• Muito útil em telas onde há input
de dados.
Presentation

@Parcelize
class Book : BaseObservable(), Parcelable {
@Bindable
var id: String = ""
set(value) {
field = value
notifyPropertyChanged(BR.id)
}
@Bindable
var title: String = ""
set(value) {
field = value
notifyPropertyChanged(BR.title)
}
// demais atributos
}

<layout ...>
<data> ...
<import type="dominando.android.presentation.binding.MediaType" />
<variable name="book" type="dominando.android.presentation.binding.Book" />
<variable name="presenter" type="dominando.android.livros.BookFragment" />
</data>
<androidx.constraintlayout.widget.ConstraintLayout ...>
<ImageView android:src=“@{book.coverUrl}" ...
android:onClick="@{presenter::clickTakePhoto}"/>
<EditText android:text="@={book.title}" ... />
<EditText android:text="@={book.author}" ... />
<EditText android:text="@={book.pages}" ... />
<EditText android:text="@={book.year}" ... />
<Spinner ...>
<CheckBox android:checked="@={book.available}" ... />
<RadioGroup ...>
<RadioButton ...
android:checked="@{book.mediaTypeValue == MediaType.EBOOK}" ... />
<RadioButton ...
android:checked="@{book.mediaTypeValue == MediaType.PAPER}" ... />
</RadioGroup>
<RatingBar android:rating="@={book.rating}" ... />
<Button android:onClick="@{presenter::clickSaveBook}" .../>
</androidx.constraintlayout.widget.ConstraintLayout>
</layout>
res/layout/fragment_book_form.xml

class BookFormFragment : BaseFragment() {
private lateinit var binding: FragmentBookFormBinding
override fun onCreateView ... {
binding = DataBindingUtil.inflate(
inflater,
R.layout.fragment_book_form,
container,
false
)
return binding.root
}
override fun onViewCreated ... {
binding.book = viewModel.book
binding.presenter = this
}
...

LiveData
• LiveData stores observable data
(Observable) and notify the observers
(Observer) when the data changes
allowing the UI to be updated.
• LiveData is lifecycle-aware, which means
that it only notify the observers if the
Activity/Fragment are either in STARTED
or RESUMED state.
Presentation

class BookDetailsViewModel(private val useCase: ViewBookDetailsUseCase) : ViewModel() {
private val state: MutableLiveData<ViewState<BookBinding>> = MutableLiveData()
fun getState(): LiveData<ViewState<BookBinding>> = state
fun loadBook(id: String) {
...
viewModelScope.launch {
state.postValue(ViewState(ViewState.Status.LOADING))
try {
useCase.execute(id).collect { book ->
if (book != null) {
val bookBinding = BookConverter.fromData(book)
state.postValue(ViewState(ViewState.Status.SUCCESS, bookBinding))
} else {
state.postValue(
ViewState(ViewState.Status.ERROR, RuntimeException("Book not found"))
)
}
}
} catch (e: Exception) {
state.postValue(ViewState(ViewState.Status.ERROR, error = e))
}
}
}

class BookDetailsFragment : BaseFragment() {
private val viewModel: BookDetailsViewModel by viewModels {
BookVmFactory(requireActivity().application)
}
…
private fun init() {
viewModel.getState().observe(viewLifecycleOwner, Observer { viewState ->
when (viewState.status) {
ViewState.Status.SUCCESS -> binding.book = viewState.data
ViewState.Status.LOADING -> {} /* TODO */
ViewState.Status.ERROR -> {}/* TODO */
}
})
val book = arguments?.getParcelable<Book>("book")
book?.let {
viewModel.loadBook(book.id)
}
}

Presentation
open class LiveEvent<out T>(private val content: T) {
var hasBeenConsumed = false
private set
fun consumeEvent(): T? {
return if (hasBeenConsumed) {
null
} else {
hasBeenConsumed = true
content
}
}
fun peekContent(): T = content
}

class BookFormViewModel(
private val useCase: SaveBookUseCase
) : ViewModel(), LifecycleObserver {
private val state: MutableLiveData<LiveEvent<ViewState<Unit>>> = MutableLiveData()
fun getState(): LiveData<LiveEvent<ViewState<Unit>>> = state
fun saveBook(book: BookBinding) {
state.postValue(LiveEvent(ViewState(ViewState.Status.LOADING)))
try {
withContext(Dispatchers.IO) {
useCase.execute(BookConverter.toData(book))
}
state.postValue(LiveEvent(ViewState(ViewState.Status.SUCCESS)))
state.postValue(LiveEvent(ViewState(ViewState.Status.ERROR, error = e)))
}
}
}

class BookFormFragment : BaseFragment() {
...
viewModel.getState().observe(this, Observer { event ->
event?.peekContent()?.let { state ->
when (state.status) {
ViewState.Status.LOADING -> {...}
ViewState.Status.SUCCESS -> {...}
ViewState.Status.ERROR -> {
...
event.consumeEvent()
}
}
}
})
}

Lifecycle
‣ Lifecycle is an object which deﬁnes a life cycle.
‣ LifecycleOwner is the interface to be implemented by
objects with a life cycle
‣ Activity and Fragment implements LifecycleOwner
and has Lifecycle.
‣ LifecycleObserver is the interface to be implemented
by who wants to observe a LifecycleOwner.

class BookListViewModel(
private val loadBooksUseCase: ListBooksUseCase, ...
) : ViewModel(), LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun loadBooks() {
if (state.value == null) {
state.postValue(ViewState(ViewState.Status.LOADING))
try {
loadBooksUseCase.execute()
.collect { books ->
val booksBinding = books.map { book ->
BookConverter.fromData(book)
}
state.postValue(
ViewState(ViewState.Status.SUCCESS, booksBinding)
)
}
state.postValue(ViewState(ViewState.Status.ERROR, error = e))
}
}
}
}

class BookListFragment : BaseFragment() {
private val viewModel: BookListViewModel
...
lifecycle.addObserver(viewModel)
}
...

UI (app)
Navigation API
• Introduz o conceito de “Single Activity”.
• Centraliza a lógica de navegação da
aplicação.
• Permite a conexão direta com
componentes de UI, tais como: ActionBar,
Button, Menu, BottomNav, …
• Simpliﬁca a passagem e atribuição de
parâmetros (sem mais método
newInstance).

<androidx.constraintlayout.widget.ConstraintLayout ...>
<fragment
android:id="@+id/navHost"
android:name="androidx.navigation.fragment.NavHostFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:navGraph="@navigation/nav_graph"
app:defaultNavHost="true" />
</androidx.constraintlayout.widget.ConstraintLayout>

class BookActivity : AppCompatActivity() {
private val navController: NavController by lazy {
Navigation.findNavController(this, R.id.navHost)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_book)
NavigationUI.setupActionBarWithNavController(this, navController)
}
override fun onSupportNavigateUp(): Boolean {
return navController.navigateUp()
}
}

// BookListFragment
val args = Bundle().apply {
putParcelable("book", book)
}
navController.navigate(R.id.action_list_to_details, args)
// BookDetailsFragment
val book = arguments?.getParcelable<Book>("book")
binding.book = book

#
#
🧐 #
#
#
#
🧐 #
🧐 #

Bonus Topics
• Organização do projeto: por pacote ou por feature?
• Injeção de Dependência: Dagger x Koin
• Testes (JUnit, Espresso, MockK, Hamcrest, …)
• Lint & KtLint
• Git Hooks

github.com/googlesamples/android-architecture

• Você não precisa usar tudo isso na
sua aplicação
• Na verdade, você não precisa usar
nenhum!
• O importante é saber QUANDO USAR
is QUANDO NÃO USAR 😉
• É essencial conhecer esses tópicos,
seus prós e contras e usá-los
adequadamente 💡

References
• Clean Architecture 
https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-
architecture.html
• Android Architecture Components 
https://developer.android.com/topic/libraries/architecture/
• LiveData beyond the ViewModel 
https://medium.com/androiddevelopers/livedata-beyond-the-viewmodel-
reactive-patterns-using-transformations-and-mediatorlivedata-fda520ba00b7
• Android Architecture (Five Agency) 
https://ﬁve.agency/android-architecture-part-1-every-new-beginning-is-hard/
• Joe Birch (@hitherejoe) Course at Caster.io 
https://caster.io/courses/android-clean-architecture

Obrigado!
Nelson Glauber
@nglauber

Arquitetando seu app Android com Jetpack

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Arquitetando seu app Android com Jetpack

Semelhante a Arquitetando seu app Android com Jetpack (20)

Mais de Nelson Glauber Leal

Mais de Nelson Glauber Leal (20)

Último

Último (6)

Arquitetando seu app Android com Jetpack