Implemantasi WebSocket App Dengan Scarlet Untuk Aplikasi Android

Dalam aplikasi seluler, lapisan data adalah sumber real untuk apa yang ditampilkan di layar. Namun, ketika WebSocketApp API diintegrasikan ke Tinder, untuk mempertahankannya menjadi memusingkan. Scarlet muncul untuk memudahkan integrasi WebSockets di Android.

WebSockets merupakan salah satu opsi untuk mengimplementasikan lapisan data dalam aplikasi Android. Terutama jika aplikasi tersebut perlu memperbarui data secara real time, seperti chat, game multiplayer online, dan feed real-time.

Hal ini membuat koneksi dua arah antara klien dan server. Mereka dapat mengirim pesan teks dan biner bolak-balik dengan overhead rendah saat koneksi terbuka. Artikel ini akan mengajari Anda cara mengimplementasikan WebSocket dengan cepat di aplikasi Android.

Persiapan Implemantasi WebSocket App

Untuk mengimplementasikan Scarlet, pertama-tama tambahkan ke file app/build.gradle.

dependencies { 
    ... 
    // scarlet 
    implementation 'com.tinder.scarlet:scarlet:0.1.12' 
} 

Dalam contoh yang diberikan oleh Scarlet, RxJava digunakan untuk membantu mengelola aliran data yang dikirim oleh soket web. Terapkan di app/build.gradle.

dependencies { 
     // rx 
     implementation 'io.reactivex.rxjava2:rxjava:2.2.21' 
     implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' 
     implementation 'io.reactivex.rxjava2:rxkotlin:2.4.0' 
} 

Jika Anda penasaran dengan dukungan Coroutine dan Kotlin Flow, lihat di sini

Sekarang bagian penting dari pengaturan kami adalah layanan. Kami dapat menguji WebSocket kami menggunakan websocket-echo (wss://websocket-echo.glitch.me).

Membuat Fungsi Interface

Selanjutnya, buat antarmuka untuk mendefinisikan fungsi yang berkomunikasi dengan WebSocket App.

interface EchoService { 
 
    @Receive 
    fun observeConnection(): Flowable<WebSocket.Event> 
 
    @Send 
    fun sendMessage(param: String) 
} 

Seperti yang Anda lihat di atas, Interfaceservice terlihat sangat mirip dengan Retrofit. Anda dapat menggunakan anotasi @Receive untuk mengamati aliran data dari WebSocket dan menggunakan @Send untuk mengirim atau berlangganan data ke WebSocket.

Setelah layanan diatur, kita dapat melanjutkan dan mengimplementasikan service dalam aktivity kita. Dalam hal ini, saya tidak menggunakan arsitektur apa pun. Hanya mengimplementasikan service dalam Activity.

class MainActivity : AppCompatActivity() { 
    ... 
    private fun setupWebSocketService() { 
        webSocketService = provideWebSocketService( 
            scarlet = provideScarlet( 
                client = provideOkhttp(), 
                lifecycle = provideLifeCycle(), 
                streamAdapterFactory = provideStreamAdapterFactory(), 
            ) 
        ) 
    } 
     
    private fun provideWebSocketService(scarlet: Scarlet) = scarlet.create(EchoService::class.java) 
     
    private fun provideScarlet( 
        client: OkHttpClient, 
        lifecycle: Lifecycle, 
        streamAdapterFactory: StreamAdapter.Factory, 
    ) = 
        Scarlet.Builder() 
            .webSocketFactory(client.newWebSocketFactory(ECHO_URL)) 
            .lifecycle(lifecycle) 
            .addStreamAdapterFactory(streamAdapterFactory) 
            .build() 
             
    private fun provideOkhttp() = 
        OkHttpClient.Builder() 
            .addInterceptor(HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BASIC)) 
            .build() 
             
    private fun provideLifeCycle() = AndroidLifecycle.ofApplicationForeground(application) 
     
    private fun provideStreamAdapterFactory() = RxJava2StreamAdapterFactory() 
    ... 
} 

PengujianWebSocket App

Sekarang kita dapat menguji kode dengan mengirimkan sesuatu ke WebSocket. WebSocket akan mengirim pesan yang sama seperti yang diambil.

class MainActivity : AppCompatActivity() { 
    ... 
   
    private fun sendMessage(message: String) { 
        webSocketService.sendMessage(message) 
        adapter.addItem(Message(message = message, isFromSender = true)) 
    } 
     
    @SuppressLint("CheckResult") 
    private fun observeConnection() { 
        webSocketService.observeConnection() 
            .observeOn(AndroidSchedulers.mainThread()) 
            .subscribe({ response -> 
                Log.d("observeConnection", response.toString()) 
                onReceiveResponseConnection(response) 
            }, { error -> 
                Log.e("observeConnection", error.message.orEmpty()) 
                Snackbar.make(binding.root, error.message.orEmpty(), Snackbar.LENGTH_SHORT).show() 
            }) 
    } 
 
    private fun onReceiveResponseConnection(response: WebSocket.Event) { 
        when (response) { 
            is OnConnectionOpened<*> -> changeToolbarTitle("connection opened") 
            is OnConnectionClosed -> changeToolbarTitle("connection closed") 
            is OnConnectionClosing -> changeToolbarTitle("closing connection..") 
            is OnConnectionFailed -> changeToolbarTitle("connection failed") 
            is OnMessageReceived -> handleOnMessageReceived(response.message) 
        } 
    } 
 
    private fun handleOnMessageReceived(message: MessageScarlet) { 
        adapter.addItem(Message(message.toValue(), false)) 
        binding.etMessage.setText("") 
    } 
 
    private fun MessageScarlet.toValue(): String { 
        return when (this) { 
            is Text -> value 
            is Bytes -> value.toString() 
        } 
    } 
     
    ... 
} 

Kesimpulan

Diatas merupakan artikel Labkom99 yang membahas Implemantasi WebSocket App Dengan Scarlet Di Aplikasi Android. Scarlet adalah perpustakaan hebat yang memberi Anda akses untuk mengimplementasikan WebSockets di aplikasi Android. Anda dapat dengan mudah mengatur Scarlet untuk aplikasi Anda dengan tutorial di atas. Terutama jika Anda sudah terbiasa dengan alat-alat seperti Retrofit.