# Kit SDK de messagerie client Chat IVS: guide Android
<a name="chat-sdk-android"></a>

Le kit SDK de messagerie client Amazon Interactive Video (IVS) Chat pour Android fournit des interfaces qui vous permettent d'intégrer facilement notre [API de messagerie IVS Chat](https://docs.aws.amazon.com//ivs/latest/chatmsgapireference/welcome.html) sur les plateformes utilisant Android.

Le package `com.amazonaws:ivs-chat-messaging` implémente l’interface décrite dans ce document.

**Dernière version du SDK de messagerie client IVS Chat pour Android :** 1.1.0 ([notes de mise à jour](https://docs.aws.amazon.com//ivs/latest/ChatUserGuide/release-notes.html#jan31-23))

**Documentation de référence : ** pour plus d'informations sur les méthodes les plus importantes disponibles dans le SDK de messagerie client Chat Amazon IVS pour Android, veuillez consulter la documentation de référence à l'adresse : [https://aws.github.io/amazon-ivs-chat-messaging-sdk-android/1.1.0/](https://aws.github.io/amazon-ivs-chat-messaging-sdk-android/1.1.0/)

**Exemple de code :** veuillez consulter le référentiel d'exemples Android sur GitHub : [https://github.com/aws-samples/amazon-ivs-chat-for-android-demo](https://github.com/aws-samples/amazon-ivs-chat-for-android-demo)

**Exigences de la plateforme :** Android 5.0 (API de niveau 21) ou une version ultérieure est nécessaire pour le développement.

# Démarrez avec le SDK de messagerie client Chat Amazon IVS pour Android
<a name="chat-android-getting-started"></a>

Avant de commencer, vous devez être familiarisé avec la [Mise en route avec Chat Amazon IVS](getting-started-chat.md).

## Ajouter le package
<a name="chat-android-add-package"></a>

Ajoutez `com.amazonaws:ivs-chat-messaging` à vos dépendances `build.gradle` :

```
dependencies {
   implementation 'com.amazonaws:ivs-chat-messaging'
}
```

## Ajouter des règles ProGuard
<a name="chat-android-proguard-rules"></a>

Ajoutez les entrées suivantes à votre fichier de règles R8/ProGuard (`proguard-rules.pro`) :

```
-keep public class com.amazonaws.ivs.chat.messaging.** { *; }
-keep public interface com.amazonaws.ivs.chat.messaging.** { *; }
```

## Configuration de votre backend
<a name="chat-android-setup-backend"></a>

Cette intégration nécessite des points de terminaison sur votre serveur qui communiquent avec l'[API Amazon IVS](https://docs.aws.amazon.com//ivs/latest/LowLatencyAPIReference/Welcome.html). Utilisez les [bibliothèques AWS officielles](https://aws.amazon.com/developer/tools/) pour accéder à l'API Amazon IVS depuis votre serveur. Elles sont accessibles dans plusieurs langues depuis les packages publics, par exemple, node.js et Java.

Ensuite, créez un point de terminaison de serveur qui communique avec l'[API Chat Amazon IVS](https://docs.aws.amazon.com//ivs/latest/ChatAPIReference/Welcome.html) et crée un jeton.

## Configurer une connexion au serveur
<a name="chat-android-setup-server"></a>

Créez une méthode qui considère `ChatTokenCallback` comme un paramètre et récupère un jeton de chat depuis votre backend. Transmettez ce jeton à la méthode `onSuccess` du rappel. En cas d'erreur, transmettez l'exception à la méthode `onError` du rappel. Ceci est nécessaire pour instancier la principale entité `ChatRoom` lors de l'étape suivante.

Vous trouverez ci-dessous un exemple de code qui implémente ce qui précède à l'aide d'un appel `Retrofit`.

```
// ...

private fun fetchChatToken(callback: ChatTokenCallback) {
    apiService.createChatToken(userId, roomId).enqueue(object : Callback<ChatToken> {
        override fun onResponse(call: Call<ExampleResponse>, response: Response<ExampleResponse>) {
            val body = response.body()
            val token = ChatToken(
                body.token,
                body.sessionExpirationTime,
                body.tokenExpirationTime
            )
            callback.onSuccess(token)
        }

        override fun onFailure(call: Call<ChatToken>, throwable: Throwable) {
            callback.onError(throwable)
        }
    })
}
// ...
```

# Utilisation de l'SDK de messagerie client Chat Amazon IVS pour Android
<a name="chat-android-using-sdk"></a>

Ce document explique les étapes nécessaires à l'utilisation de l'SDK de messagerie client Chat Amazon IVS pour Android.

## Initialiser une instance de salle de chat
<a name="chat-android-initialize-room"></a>

Créez une instance de la classe `ChatRoom`. Cela nécessite de transmettre `regionOrUrl`, qui correspond généralement à la région AWS dans laquelle votre salle de chat est hébergée, et `tokenProvider` qui est la méthode de récupération de jetons créée à l'étape précédente.

```
val room = ChatRoom(
    regionOrUrl = "us-west-2",
    tokenProvider = ::fetchChatToken
)
```

Ensuite, créez un objet écouteur qui implémentera des gestionnaires pour les événements liés au chat et attribuez-le à la propriété `room.listener` :

```
private val roomListener = object : ChatRoomListener {
    override fun onConnecting(room: ChatRoom) {
      // Called when room is establishing the initial connection or reestablishing connection after socket failure/token expiration/etc
    }

    override fun onConnected(room: ChatRoom) {
        // Called when connection has been established
    }

    override fun onDisconnected(room: ChatRoom, reason: DisconnectReason) {
        // Called when a room has been disconnected
    }

    override fun onMessageReceived(room: ChatRoom, message: ChatMessage) {
        // Called when chat message has been received
    }

    override fun onEventReceived(room: ChatRoom, event: ChatEvent) {
        // Called when chat event has been received
    }

    override fun onDeleteMessage(room: ChatRoom, event: DeleteMessageEvent) {
       // Called when DELETE_MESSAGE event has been received
    }
}

val room = ChatRoom(
    region = "us-west-2",
    tokenProvider = ::fetchChatToken
)

room.listener = roomListener // <- add this line

// ...
```

La dernière étape de l'initialisation de base consiste à se connecter à la salle spécifique en établissant une connexion WebSocket. Pour ce faire, appelez la méthode `connect()` au sein de l'instance de la salle. Nous vous recommandons de procéder selon la méthode du cycle de vie `onResume() ` pour vous assurer qu'elle conserve une connexion si votre application reprend en arrière-plan.

```
room.connect()
```

Le kit SDK tentera d'établir une connexion à une salle de chat codée dans le jeton de chat reçu de votre serveur. En cas d'échec, il tentera de se reconnecter le nombre de fois spécifié dans l'instance de la salle.

## Effectuer des actions dans une salle de chat
<a name="chat-android-room-actions"></a>

La classe `ChatRoom` contient des actions permettant d'envoyer et de supprimer des messages ainsi que de déconnecter d'autres utilisateurs. Ces actions acceptent un paramètre de rappel facultatif qui vous permet de recevoir des notifications de confirmation ou de rejet de demande.

### Envoi d'un message
<a name="chat-android-room-actions-send-message"></a>

Pour cette demande, la fonctionnalité `SEND_MESSAGE` doit être encodée dans votre jeton de chat.

Pour déclencher une demande send-message :

```
val request = SendMessageRequest("Test Echo")
room.sendMessage(request)
```

Pour obtenir une confirmation/un rejet de la demande, fournissez un rappel comme second paramètre :

```
room.sendMessage(request, object : SendMessageCallback {
   override fun onConfirmed(request: SendMessageRequest, response: ChatMessage) {
      // Message was successfully sent to the chat room.
   }
   override fun onRejected(request: SendMessageRequest, error: ChatError) {
      // Send-message request was rejected. Inspect the `error` parameter for details.
   }
})
```

### Supprimer un message
<a name="chat-android-room-actions-delete-message"></a>

Pour cette demande, la fonctionnalité DELETE\$1MESSAGE doit être encodée dans votre jeton de chat.

Pour déclencher une demande delete-message :

```
val request = DeleteMessageRequest(messageId, "Some delete reason")
room.deleteMessage(request)
```

Pour obtenir une confirmation/un rejet de la demande, fournissez un rappel comme second paramètre :

```
room.deleteMessage(request, object : DeleteMessageCallback {
   override fun onConfirmed(request: DeleteMessageRequest, response: DeleteMessageEvent) {
      // Message was successfully deleted from the chat room.
   }
   override fun onRejected(request: DeleteMessageRequest, error: ChatError) {
      // Delete-message request was rejected. Inspect the `error` parameter for details.
   }
})
```

### Déconnecter un autre utilisateur
<a name="chat-android-room-actions-disconnect-user"></a>

Pour cette demande, la fonctionnalité `DISCONNECT_USER` doit être encodée dans votre jeton de chat.

Pour déconnecter un autre utilisateur à des fins de modération :

```
val request = DisconnectUserRequest(userId, "Reason for disconnecting user")
room.disconnectUser(request)
```

Pour obtenir la confirmation/le rejet de la demande, fournissez un rappel comme second paramètre :

```
room.disconnectUser(request, object : DisconnectUserCallback {
   override fun onConfirmed(request: SendMessageRequest, response: ChatMessage) {
      // User was disconnected from the chat room.
   }
   override fun onRejected(request: SendMessageRequest, error: ChatError) {
      // Disconnect-user request was rejected. Inspect the `error` parameter for details.
   }
})
```

## Déconnexion d'une salle de chat
<a name="chat-android-disconnect-room"></a>

Pour fermer votre connexion à la salle de chat, appelez la méthode `disconnect()` sur l'instance de la salle :

```
room.disconnect()
```

Étant donné que la connexion WebSocket cesse de fonctionner peu de temps après que l'application passe en arrière-plan, nous vous recommandons de vous connecter/déconnecter manuellement lors de la transition depuis/vers un état d'arrière-plan. Pour ce faire, associez l'appel `room.connect()` de la méthode du cycle de vie `onResume()`, sur `Activity` ou `Fragment` Android, avec un appel `room.disconnect()` de la méthode du cycle de vie `onPause()`.