MiReal.me MiReal.me – Tu blog tecnológico con la más actualizada información
Broker es una biblioteca de publicación y suscripción (también conocida como Pub / Sub, EventBus) para Android y JVM construida con Coroutines.
clase MyActivity : AppCompatActivity (), GlobalBroker . Suscriptor {
anular diversión onCreate ( savedInstanceState : Bundle? ) {
Súper .onCreate (savedInstanceState)
suscribirse < MyEvent > ([ this ) {event - >
// Administrar evento
}
}
}
clase MyViewModel : ViewModel (), GlobalBroker . Editor {
diversión hacer algo () {
publicar ( MyEvent (carga útil))
}
}
Características
- Ayuda a desacoplar su código: los editores están poco vinculados con los suscriptores y ni siquiera necesitan saber acerca de su existencia
- Funciona muy bien con Actividad, Fragmento, Servicio, Vista personalizada, ViewModel. .
- Proporciona una instancia global de forma predeterminada y le permite crear sus propias instancias
- También ofrece funciones de extensión útiles para evitar el código del boletín
- Compatible con el ciclo de vida de Android: regístrese y cancele registro automático a eventos
- Evento mantenido: guardar en caché los últimos eventos publicados
- Seguridad para subprocesos: puede publicar / suscribirse desde cualquier hilo
- Rápido: todo el trabajo se realiza fuera del hilo principal y los eventos se entregan a través de un flujo de coroutini
- Pequeño: ~ 30kb
Uso
Eche un vistazo a la aplicación de muestra para ver ejemplos de trabajo.
Creación de eventos
Los eventos (alias Tema, Mensaje) se pueden representar como un objeto
clase de datos(con carga útil).objeto EventoA datos clase Evento B ( val mensaje : Cadena )
También puede agrupar sus eventos dentro de una clase sellada
sellado clase MyEvent { objeto EventoA : MyEvent () datos clase Evento B ( val mensaje : Cadena ) : MyEvent }
Global Pub / Sub
El intermediario proporciona de forma predeterminada una instancia global con algunas funciones de extensión útiles.
Llame a
GlobalBroker.subscribepara registrarse en un evento y() GlobalBroker.unsubscribe ()para darse de baja de todos los eventos.Para suscribirse, debe pasar como parámetros:
- El suscriptor (generalmente la clase actual pero puede ser un
CadenaIntobjeto…) [19659018] ACoroutineScope(consejo: use el ciclo de vida incorporado y viewModelScope) - ] opcional
CoroutineContextpara ejecutar su lambda (el valor predeterminado esDispatchers .Principal) - Una lambda utilizada para gestionar eventos entrantes
Llame
subscribe ()enonStart ()(para actividad y fragmento) yonAttachedToWindow ()(para visualización personalizada) y llame aunsubscribe ()enonStop ()(para actividad y fragmento) yonDetachedFromWindow ()( para exhibición personalizada).clase MyActivity : [19659005] AppCompatActivity () { ignora diversión onStart () { Súper .onStart () GlobalBroker .subscribe < MyEvent > ( this lifecycleScope) {event - > ] } } ignora diversión onStop () { GlobalBroker .unsubscribe ( this ) Súper .onStop () } }
Para publicar eventos simplemente llame a
GlobalBroker.publish ()pasando el evento como parámetro. Se puede llamar desde cualquier hilo.clase MyViewModel : ViewModel () { diversión hacer algo () { GlobalBroker .publish ( MyEvent ) } }
GlobalBroker.Publisher & GlobalBroker.Subscriber
Puede evitar algún código de caldera implementando las interfaces
GlobalBroker.PublisheryGlobalBroker.Subscriber. Esto también ayuda a identificar el papel de su clase: ¿es un editor o un suscriptor?clase MyActivity : AppCompatActivity (), GlobalBroker . ] Suscriptor { ignora diversión onStart () { Súper .onStart () suscribirse < MyEvent > (lifecycleScope) {event - > // Administrar evento } } ignora diversión onStop () { Cancelar suscripción () Súper .onStop () } } clase MyViewModel : ViewModel (), GlobalBroker . Editor { diversión hacer algo () { publicar ( MyEvent ) } }
Pub / local locale
En algunas situaciones, una instancia global no es una buena opción, por esta razón también puede crear su propia instancia de intermediario.
En el siguiente ejemplo, utilizamos Koin para inyectar una instancia de Broker en el ámbito
MyActivity.val myModule = módulo { alcance < MyActivity > { con alcance { Broker ()} viewModel { MyViewModel (corredor = get ())} } }
Y ahora podemos inyectar una instancia de agente local:
clase MyActivity : AppCompatActivity () { corredor privado val por instancia < Corredor > () ignora diversión onStart () { Súper .onStart () broker.subscribe < MyEvent > ( this lifecycleScope) {event - > // Manage event } } ignora diversión onStop () { broker.unsubscribe ( this ) Súper .onStop () } } clase MyViewModel ( agente : Agente ) : ViewModel () { diversión hacer algo () { broker.publish ( MyEvent ) } }
BrokerPublisher & BrokerSubscriber
La clase Broker implementa dos interfaces:
BrokerPublisheryBrokerSubscriber. Puede usarlo para inyectar solo el comportamiento necesario en su clase.Volvamos al ejemplo anterior. En lugar de proporcionar directamente una instancia del corredor, podemos proporcionar dos inyecciones, una para editores y otra para suscriptores.
val myModule = módulo { alcance < MyActivity > { val agente = Agente () con alcance < BrokerPublisher > {broker} con alcance < BrokerSubscriber > {broker} viewModel { MyViewModel (broker = get < BrokerPublisher > ())} } }
Ahora podemos inyectar solo lo que nuestra clase necesita:
clase MyActivity : AppCompatActivity () { corredor privado val por instancia < BrokerSubscriber > () } clase MyViewModel ( corredor : BrokerPublisher ) : ViewModel ()
] Corredores suscriptores pueden ¡sé consciente del ciclo de vida! Funciona para instancias globales y locales.
En lugar de suscribirse a
onStart ()y darse de baja deonStop ()suscríbase aonCreate ()y pase elRespuesta del ciclo de vidacomo parámetro. Sus eventos ahora se registrarán y cancelarán automáticamente.clase MyActivity : AppCompatActivity (), GlobalBroker . anular diversión onCreate ( savedInstanceState : Bundle? ) { Súper .onCreate (savedInstanceState) Suscribir < MyEvent > (propietario = esto ) {evento - > // Administrar evento } } }
Eventos conservados
Puede guardar el último evento publicado de un tipo determinado. Cada vez que se registre para un evento celebrado, se emitirá de inmediato.
Simplemente usa las banderas
emitRetainedal suscribirte ykeepal publicar:regístrate < MyEvent > ([
this ] emitRetained = true ) {event - > // Administrar evento } publicar ( MyEvent preservar = verdadero )En cualquier momento puede solicitar un evento retenido (devolverá nulo si no hay ninguno):
val lastEvent = getRetained < SampleEvent > () // removeRetained () también devolverá el último evento preservado val lastEvent = removeRetained < SampleEvent > ()
Si la lambda del suscriptor arroja un error, Broker lo detecta y publica el evento
BrokerExceptionEvent. Suscríbase solo si desea manejar excepciones.registrarse < BrokerExceptionEvent > (lifecycleScope) {event - > // Error de administración }
Importar en su proyecto
- Agregue el repositorio JitPack en su raíz build.gradle al final de los repositorios:
allprojects { repositorio { maven {url & # 39; https://jitpack.io & # 39; } } }
- A continuación, agregue las dependencias deseadas a su módulo:
dependencias { // Núcleo Implementación " com.github.adrielcafe.broker:broker-core: $ c urrentVersion " // Soporte de ciclo de vida de Android Implementación " com.github.adrielcafe.broker:broker-lifecycle: $ c urrentVersion " }
Versión actual:
compatibilidad
broker-coreciclo de vida del corredorAndroid ✓ ✓ JVM ✓ .
- El suscriptor (generalmente la clase actual pero puede ser un
