courier android

À propos de Courier

Courier est une bibliothèque Kotlin pour créer des connexions longues à l'aide du protocole MQTT.

La connexion à longue course est une connexion persistante établie entre le client et le serveur pour une communication bidirectionnelle instantanée. Une longue connexion en cours d'exécution est maintenue pour une durée maximale possible à l'aide de paquets de maintien vivant. Cela aide à enregistrer la batterie et les données sur les appareils mobiles.

MQTT est un protocole extrêmement léger qui fonctionne sur le modèle de messagerie publié / souscrit. Il est conçu pour les connexions avec des emplacements distants où une "petite empreinte de code" est requise ou la bande passante réseau est limitée.

Le protocole se déroule généralement sur TCP / IP; Cependant, tout protocole de réseau qui fournit des connexions ordonnées, sans perte et bidirectionnelles peut prendre en charge MQTT.

MQTT a 3 niveaux de QoS intégrés pour la livraison de messages fiables:

• QoS 0 (au plus une fois) - Le message n'est envoyé qu'une seule fois et le client et le courtier ne prennent aucune mesure supplémentaire pour reconnaître la livraison (incendier et oublier).

• QoS 1 (au moins une fois) - Le message est réécrit par l'expéditeur plusieurs fois jusqu'à ce que l'accusé de réception soit reçu (livraison reconnue).

• QoS 2 (Exactement une fois) - L'expéditeur et le récepteur s'engagent dans une poignée de main à deux niveaux pour garantir qu'une seule copie du message est reçue (livraison assurée).

Documentation détaillée

Trouvez la documentation détaillée ici - https://gojek.github.io/courier-android/

Exemple de messagerie de fin à fin - https://gojek.github.io/courier/docs/introduction

Caractéristiques

• API propre

• Adaptive Keep Alive

• Adaptateurs de message et de flux

• Magasin d'abonnement

• Reconnecter automatiquement et remanier

• Persistance de la base de données

• Manipulation de contre-pression

• ALARME, TIMER ET ENTÉRIEUR DE WORKER

• MQTT Chuck

Plus de détails sur les fonctionnalités de la bibliothèque de Courier peuvent être trouvés ici

Commencer

Exemple d'application

Une demande de démonstration est ajoutée ici qui établit un lien de messagerie avec un courtier public Hivemq.

Télécharger

Tous les artefacts de la bibliothèque de Courier sont disponibles via 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 "
}

Usage

Déclarez une interface de service pour des actions comme envoyer, recevoir, vous abonner, désabonner:

 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 )
}

Utilisez Courier pour créer une implémentation:

 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 >()

Abonnez-vous / se désinscrire à l'aide de l'interface de service

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

Envoyer / recevoir à l'aide de l'interface de service

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

Connectez-vous à l'aide de MQTTCIENT

 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)

Déconnecter à l'aide de MQTTCIENT

mqttClient.disconnect()

Options de connexion non standard

UserProperties dans MQTTConnectionOptions

Cette option vous permet d'envoyer des propos de l'utilisateur dans le paquet de connexion pour 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)

️ ** Il s'agit d'une option non standard. En ce qui concerne la spécification MQTT, la prise en charge des propercons utilisateur est ajoutée dans MQTT V5. Donc, pour soutenir cela dans MQTT v3.1.1, le courtier doit également avoir un support pour cela.

Lignes directrices de contribution

Lisez notre guide de contribution pour en savoir plus sur notre processus de développement, comment proposer des bugfix et des améliorations, et comment créer et tester vos modifications à la bibliothèque Android Courier.

Licence

Tous les modules de messagerie à l'exception de Paho sont sous licence MIT. Paho est sous licence Eclipse.