Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# SDK Pesan Klien Obrolan IVS: Panduan Android
<a name="chat-sdk-android"></a>

SDK Android Perpesanan Klien Obrolan Amazon Interactive Video (IVS) menyediakan antarmuka agar Anda dapat dengan mudah menggabungkan [API Perpesanan Obrolan IVS](https://docs.aws.amazon.com//ivs/latest/chatmsgapireference/welcome.html) kita di platform yang menggunakan Android.

Paket `com.amazonaws:ivs-chat-messaging` mengimplementasikan antarmuka yang dijelaskan dalam dokumen ini.

**SDK Android Perpesanan Klien Obrolan IVS versi terbaru:** 1.1.0 ([Catatan Rilis](https://docs.aws.amazon.com//ivs/latest/ChatUserGuide/release-notes.html#jan31-23))

**Dokumentasi referensi:** [Untuk informasi tentang metode terpenting yang tersedia di Amazon IVS Chat Client Messaging Android SDK, lihat dokumentasi referensi di: https://aws.github.io/ -sdk-android/1.1.0/ amazon-ivs-chat-messaging](https://aws.github.io/amazon-ivs-chat-messaging-sdk-android/1.1.0/)

**Contoh kode:** [Lihat contoh repositori Android di GitHub: -android-demo https://github.com/aws-samples/ amazon-ivs-chat-for](https://github.com/aws-samples/amazon-ivs-chat-for-android-demo)

**Persyaratan platform:** Android 5.0 (API tingkat 21) atau lebih tinggi diperlukan untuk pengembangan.

# Memulai dengan IVS Chat Client Messaging Android SDK
<a name="chat-android-getting-started"></a>

Sebelum memulai, Anda harus memahami cara [Memulai Obrolan Amazon IVS](getting-started-chat.md).

## Menambahkan Paket
<a name="chat-android-add-package"></a>

Tambahkan `com.amazonaws:ivs-chat-messaging` ke dependensi `build.gradle` Anda:

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

## Tambahkan Aturan Proguard
<a name="chat-android-proguard-rules"></a>

Tambahkan entri berikut ke file aturan R8/Proguard Anda (`proguard-rules.pro`):

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

## Siapkan Backend Anda
<a name="chat-android-setup-backend"></a>

Integrasi ini memerlukan titik akhir di server Anda yang akan berbicara dengan [API Amazon IVS](https://docs.aws.amazon.com//ivs/latest/LowLatencyAPIReference/Welcome.html). Gunakan [pustaka AWS resmi](https://aws.amazon.com/developer/tools/) untuk akses ke API Amazon IVS dari server Anda. Pustaka ini dapat diakses dalam beberapa bahasa dari paket publik; misalnya, node.js dan Java.

Selanjutnya, buat titik akhir server yang berbicara dengan [API Obrolan Amazon IVS](https://docs.aws.amazon.com//ivs/latest/ChatAPIReference/Welcome.html) dan membuat token.

## Menyiapkan Koneksi Server
<a name="chat-android-setup-server"></a>

Buat metode yang menggunakan `ChatTokenCallback` sebagai param dan mengambil token obrolan dari backend Anda. Teruskan token tersebut ke metode `onSuccess` panggilan balik. Jika terjadi kesalahan, teruskan pengecualian ke metode `onError` dari panggilan balik. Hal ini diperlukan untuk instantiasi entitas `ChatRoom` utama di langkah berikutnya.

Di bawah ini Anda dapat menemukan contoh kode yang mengimplementasikan hal-hal di atas dengan menggunakan panggilan `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)
        }
    })
}
// ...
```

# Menggunakan IVS Chat Client Messaging Android SDK
<a name="chat-android-using-sdk"></a>

Dokumen ini akan membawa Anda melalui langkah-langkah yang terlibat dalam menggunakan Amazon IVS chat client messaging Android SDK.

## Menginisialisasi Instans Ruang Obrolan
<a name="chat-android-initialize-room"></a>

Buat instans dari kelas `ChatRoom`. Langkah ini mengharuskan penyediaan `regionOrUrl`, yang biasanya merupakan wilayah AWS tempat ruang obrolan Anda di-host, dan `tokenProvider` yang merupakan metode pengambilan token yang dibuat pada langkah sebelumnya.

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

Selanjutnya, buat objek pendengar yang akan mengimplementasikan handler untuk peristiwa yang terkait obrolan, dan tetapkan objek tersebut ke properti `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

// ...
```

Langkah terakhir dari inisialisasi dasar adalah menghubungkan ke ruangan tertentu dengan membuat WebSocket koneksi. Untuk melakukan hal tersebut, panggil metode `connect()` dalam instans ruang. Sebaiknya lakukan langkah tersebut dalam metode siklus hidup `onResume() ` untuk memastikannya tetap terhubung jika aplikasi Anda dilanjutkan dari latar belakang.

```
room.connect()
```

SDK akan mencoba membuat koneksi ke suatu ruang obrolan yang dienkode dalam token obrolan yang diterima dari server Anda. Jika gagal, SDK akan mencoba menghubungkan kembali sebanyak yang ditentukan dalam instans ruang.

## Melakukan Tindakan di Ruang Obrolan
<a name="chat-android-room-actions"></a>

Kelas `ChatRoom` memiliki tindakan untuk mengirim dan menghapus pesan serta memutus koneksi pengguna lain. Tindakan ini menerima parameter panggilan balik opsional yang memungkinkan Anda untuk mendapatkan konfirmasi permintaan atau notifikasi penolakan.

### Mengirim Pesan
<a name="chat-android-room-actions-send-message"></a>

Untuk permintaan ini, Anda harus memiliki kemampuan `SEND_MESSAGE` yang dienkode dalam token obrolan Anda.

Untuk memicu permintaan kirim-pesan:

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

Untuk mendapatkan confirmation/rejection permintaan, berikan callback sebagai parameter kedua:

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

### Menghapus Pesan
<a name="chat-android-room-actions-delete-message"></a>

Untuk permintaan ini, Anda harus memiliki kemampuan DELETE\$1MESSAGE yang dienkode dalam token obrolan.

Untuk memicu permintaan hapus-pesan:

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

Untuk mendapatkan confirmation/rejection permintaan, berikan callback sebagai parameter kedua:

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

### Memutus Koneksi Pengguna Lain
<a name="chat-android-room-actions-disconnect-user"></a>

Untuk permintaan ini, Anda harus memiliki kemampuan `DISCONNECT_USER` yang dienkode dalam token obrolan Anda.

Guna memutus koneksi pengguna lain untuk tujuan moderasi:

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

Untuk mendapatkan confirmation/rejection permintaan, berikan callback sebagai parameter kedua:

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

## Memutus Koneksi dari Ruang Obrolan
<a name="chat-android-disconnect-room"></a>

Untuk menutup koneksi Anda ke ruang obrolan, panggil metode `disconnect()` pada instans ruang:

```
room.disconnect()
```

Karena WebSocket koneksi akan berhenti bekerja setelah waktu yang singkat ketika aplikasi dalam keadaan latar belakang, kami menyarankan Anda secara manual connect/disconnect saat mentransisikan from/to status latar belakang. Untuk melakukannya, pasangkan panggilan `room.connect()` dalam metode siklus hidup `onResume()`, di `Activity` atau `Fragment` Android, dengan panggilan `room.disconnect()` dalam metode siklus hidup `onPause()`.