courier android

Sobre mensajería

Courier es una biblioteca de Kotlin para crear conexiones de larga duración utilizando el protocolo MQTT.

Long Running Connection es una conexión persistente establecida entre el cliente y el servidor para la comunicación bidireccional instantánea. Se mantiene una conexión de larga duración para la máxima duración posible con la ayuda de los paquetes Keep Alive. Esto ayuda a ahorrar batería y datos en dispositivos móviles.

MQTT es un protocolo extremadamente liviano que funciona en el modelo de mensajería de publicación/suscripción. Está diseñado para conexiones con ubicaciones remotas donde se requiere una "huella de código pequeño" o el ancho de banda de la red es limitado.

El protocolo generalmente se ejecuta a través de TCP/IP; Sin embargo, cualquier protocolo de red que proporcione conexiones bidireccionales ordenadas, sin pérdidas puede admitir MQTT.

MQTT tiene 3 niveles de QoS incorporados para la entrega de mensajes confiables:

• QoS 0 (como máximo una vez) : el mensaje se envía solo una vez y el cliente y el corredor no toman pasos adicionales para reconocer la entrega (fuego y olvidar).

• QoS 1 (al menos una vez) : el remitente vuelve al mensaje varias veces hasta que se recibe el reconocimiento (entrega reconocida).

• Qos 2 (exactamente una vez) : el remitente y el receptor participan en un apretón de manos de dos niveles para garantizar que solo se reciba una copia del mensaje (entrega asegurada).

Documentación detallada

Encuentre la documentación detallada aquí: https://gojek.github.io/courier-doid/

Ejemplo de mensajería final-https://gojek.github.io/courier/docs/introduction

Características

• API limpia

• Adaptive Keep Alive

• Adaptadores de mensajes y transmisión

• Tienda de suscripción

• Reconectar y volver a conectar automáticamente

• Persistencia de la base de datos

• Manejo de backpressure

• Remitente de ping de alarma, temporizador y trabajador

• Mqtt chuck

Se pueden encontrar más detalles sobre las características en Courier Library aquí

Empezando

Aplicación de muestra

Aquí se agrega una solicitud de demostración que hace que Courier Connection con un corredor público HIVEMQ.

Descargar

Todos los artefactos de Courier Library están disponibles a través de Maven Central.

repositories {
    mavenCentral()
}

dependencies {
    implementation " com.gojek.courier:courier:x.y.z "

    implementation " com.gojek.courier:courier-message-adapter-gson:x.y.z "
    implementation " com.gojek.courier:courier-stream-adapter-rxjava2:x.y.z "
}

Uso

Declare una interfaz de servicio para acciones como enviar, recibir, suscribirse, cancelar la suscripción:

 interface MessageService {
	@Receive(topic = " topic/{id}/receive " )
	fun receive (@Path( " id " ) identifier : String ): Observable < Message >

	@Send(topic = " topic/{id}/send " , qos = QoS . TWO )
	fun send (@Path( " id " ) identifier : String , @Data message : Message )

	@Subscribe(topic = " topic/{id}/receive " , qos = QoS . ONE )
 	fun subscribe (@Path( " id " ) identifier : String ): Observable < Message >

	@Unsubscribe(topics = [ " topic/{id}/receive " ])
 	fun unsubscribe (@Path( " id " ) identifier : String )
}

Use Courier para crear una implementación:

 val mqttClient = MqttClientFactory .create(
    context = context,
    mqttConfiguration = MqttV3Configuration (
        authenticator = authenticator
    )
)

val courierConfiguration = Courier . Configuration (
    client = mqttClient,
    streamAdapterFactories = listOf ( RxJava2StreamAdapterFactory ()),
    messageAdapterFactories = listOf ( GsonMessageAdapter . Factory ())
)

val courier = Courier (courierConfiguration)

val messageService = courier.create< MessageService >()

Suscribir/cancelar la suscripción utilizando la interfaz de servicio

messageService.subscribe( " user-id " ).subscribe { message ->
    print (message)
}
messageService.unsubscribe( " user-id " )

Enviar/recibir usando la interfaz de servicio

messageService.send( " user-id " , message)
messageService.receive( " user-id " ) { message ->
    print (message)
}

Conectarse usando mqttclient

 val connectOptions = MqttConnectOptions (
    serverUris = listOf ( ServerUri ( SERVER_URI , SERVER_PORT )),
    clientId = clientId,
    username = username,
    keepAlive = KeepAlive (
        timeSeconds = keepAliveSeconds
    ),
    isCleanSession = cleanSessionFlag,
    password = password
)

mqttClient.connect(connectOptions)

Desconectar usando MQTTClient

mqttClient.disconnect()

Opciones de conexión no estándar

UserProperties en MQTTConnectionOptions

Esta opción le permite enviar propiedades de usuario en el paquete de conexión para MQTT v3.1.1.

 val connectOptions = MqttConnectOptions (
    serverUris = listOf ( ServerUri ( SERVER_URI , SERVER_PORT )),
    clientId = clientId,
    .. .
    userPropertiesMap = mapOf (
                " key1 " to " value1 " ,
                " key2 " to " value2 "
    )
)

mqttClient.connect(connectOptions)

️ ** Esta es una opción no estándar. En lo que respecta a la especificación MQTT, el soporte de propiedades de usuarios se agrega en MQTT V5. Entonces, para apoyar esto en MQTT v3.1.1, Broker también debe tener apoyo para esto.

Pautas de contribución

Lea nuestra Guía de contribución para conocer nuestro proceso de desarrollo, cómo proponer las correcciones de errores y las mejoras, y cómo construir y probar sus cambios en Courier Android Library.

Licencia

Todos los módulos de mensajería, excepto Paho, tienen licencia MIT. Paho tiene licencia eclipse.