Arquitectura de Software

1

Arquitectura en Android

2

Patrón de diseño vs. Arquitectura de Diseño

3

¿Qué es la Arquitectura de Diseño?

4

SOLID: Single Responsability y Open/Closed Principles

5

SOLID: Liskov substitution, Interface segregation y Dependency Inversion principle

6

Evolución de la Arquitectura en Android

Arquitectura Model View Controller (MVC)

7

¿Qué es la aquitectura Model View Controller (MVC)?

8

MVC en un Proyecto Android: Analizando el código en capas

9

MVC en un Proyecto Android: Llevando el código a sus responsabilidades

Arquitectura Model View Presenter (MVP)

10

¿Qué es la aquitectura Model View Presenter (MVP)?

11

¿Qué es Clean Architecture?

12

Composición en Clases

13

Model View Presenter explicado

14

Capa Model

15

MVP en un Proyecto Android: Presenters y Views

16

MVP en un Proyecto Android: Model

17

Ubicando el código en MVP

Arquitectura Model View ViewModel (MVVM)

18

¿Qué es la arquitectura Model View ViewModel (MVVM)?

19

¿Cómo funciona MVVM Data Binding?

20

MVVM Data Binding estructurando nuestra aplicación y migrando a AndriodX

21

MVVM DataBinding creando un ViewModel

22

Patron Observer en MVVM

23

MVVM Data Binding: integrando ViewModel a View

24

MVVM Data Binding: RecyclerView Adapter

25

MVVM Data Binding: RecyclerView CardView

Android JetPack Arquitectura

26

¿Qué es Android JetPack Arquitectura?

27

¿Cómo funciona la arquitectura de componentes?

28

Arquitectura Componentes Lifecycle ViewModel

29

Arquitectura Componentes Lifecycle Observe

Fin del curso

30

Conclusiones

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Arquitectura de Android

Curso de Arquitectura de Android

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Arquitectura Componentes Lifecycle Observe

29/30
Recursos

Aportes 7

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Este curso fue muy básico y realmente no siguió las recomendaciones oficiales de Google sobre el uso de MVVM.

Para mantener la separación de conceptos, la vista (Activities/ Fragments) no deberían poder actualizar la data de los LiveData, el ViewModel es que se encarga de esto, por esto, sólo se debería exponer LiveData a las vistas y no MutableLiveData
Por ejemplo:

 private val _urlImage = MutableLiveData<String>()
    val urlImage: LiveData<String> = _urlImage

así el ViewModel manipula _urlImage y la vista observa urlImage

Por lo que he visto, las clases 28 y 29 no siguen MVVM ni se enfocan en la arquitectura. Solo muestran a nivel basico como puedes usar LifeCycle y LiveData.

Supongo que en esta clase y la anterior, la maestra Anahí prefirió enfocarse en los componentes de Jetpack y no tanto en la arquitectura. Si queremos mejorar la arquitectura de esta app, podemos hacerlo en solo 2 pasos:

  1. Todo lo relacionado a datos y acciones se queda en el ViewModel, así:
// MainActivityViewModel.kt
// Estas 2 líneas son para encapsular los datos adecuadamente
private val _urlImage = MutableLiveData<String?>()
val urlImage: LiveData<String?>
    get() = _urlImage

fun callUrlImage(): String? {
    _urlImage.value = randomNumbersUrl()
    return _urlImage.value
}

private fun randomNumbersUrl(): String {
    return "https://picsum.photos/${(3..5).random()}00/${(3..5).random()}00"
}
  1. Todo lo relacionado a la vista se queda en el Activity, así:

// MainActivity.kt
val model = ViewModelProvider(this)[MainActivityViewModel::class.java]
model.callUrlImage()
model.urlImage.observe(this, {
    Picasso.get().load(it).into(imagePhoto)
    Picasso.get().load(it).into(imagePhoto2)
})

btnGetUrlImage.setOnClickListener {
    model.callUrlImage()
}

Lo ideal sería que las líneas que ponen la imagen en Picasso también estén en el ViewModel, sin embargo yo prefiero dejarla en el MainActivity, ya que es una línea muy simple y además los ViewModels no deben referenciar ninguna vista.

1
Excelente explicacion de los observables con el ViewModel lifecycle y liveData.
Por medio de estos nuestro viewModel:
LifeCycle sobrevive al ciclo de vida.
LiveData actualizan los datos.

Buen curso súper básico para los quería van aprendiendo

Me parece muy útil este tipo de arquitectura, sin duda toca es practicar macho para dominarla pero esto hará que mis desarrollos tengan una calidad mucho mas aceptable.