Conectar a una API con Retrofit, RxJava 2, y Kotlin

Hoy en día, es bastante común para aplicaciones móviles para el intercambio de datos con servidores remotos, utilizando Interfaces de Programación de Aplicaciones web (API).

Si está comprobando para nuevos correos electrónicos utilizando la API de Gmail, búsqueda de eventos en la zona con la API de Ticketmaster, o aprovechando la historia de Spotify del usuario para recomendar la nueva música, las APIs (generalmente REST APIs) proporcionan acceso a una gran cantidad de información que se puede Utilice en su aplicación.

Comunicación con servidores remotos se ha convertido en una parte tan importante del desarrollo móvil moderno que hay innumerables bibliotecas dedicadas a ayudar a hacer llamadas de red, pero Retrofit es una de las bibliotecas de red más ampliamente utilizadas para Android.

En este artículo, te voy a mostrar cómo recuperar datos de un API remota, mediante la modificación y la Nomics Cryptocurrency & Bitcoin API gratis.

Una vez que han obtenido algunos datos, usted querrá hacer un buen uso! En Android, a menudo se trata de reenviar los datos importante subproceso principal de interfaz de usuario de Android, preparado para mostrar en la interfaz de usuario de su aplicación, o transformar los datos de alguna manera, como el filtrado o combinarlo. Convenientemente, puedes hacerlo todas estas cosas con la biblioteca RxJava, usaremos Retrofit y RxJava lado a lado en nuestro proyecto.

Al final de este artículo, habrá creado una aplicación que recupera datos de un API remoto mediante modificación, convierte los datos en formato Observable de RxJava y luego manipula esos datos con una selección de RxJava y RxAndroid operadores y programadores.

Lo Que Vamos a Construir

No faltan de APIs por ahí, pero para ayudar a mantener las cosas sencillas, utilizaremos la Nomics Cryptocurrency & Bitcoin API libre para recuperar una lista de cryptocurrencies y sus precios de mercado para el comercio registrado pasado. Entonces, usaremos un RecyclerView para visualizar esta información en nuestra aplicación.

Para emitir una solicitud de modificación, tendremos que crear las siguientes:

• Una clase Retrofit. Esto es donde te crea una instancia de adaptación, añadir un convertidor (utilizaremos Gson) y especifique la dirección URL base que su aplicación debe utilizar para todas sus solicitudes HTTP.
• Una clase de datos. Esta clase representa las respuestas para cada una de las llamadas a API de la aplicación.
• Una interfaz API. Esto es donde describes cada solicitud de modificación que desee hacer.

Al final de este tutorial, tendrás un proyecto que se ve algo como esto:

¿Por Qué Debo Usar RxJava para Mis Llamadas API?

RxJava es una implementación de código abierto, compatible con JVM de la biblioteca de ReactiveX que ha diseñado para ayudarle a trabajar con flujos asincrónicas de datos en un estilo de programación reactivo y sin tener que escribir un montón de las devoluciones de llamada.

Hay muchos beneficios de usar RxJava en tus proyectos Android, pero algunos de los más importantes son:

• Código simplificado. RxJava le permite describir lo queremos conseguir, en lugar de escribir una lista de instrucciones para que funcione a través de su aplicación. Este enfoque normalmente genera código más conciso y legible que es más fácil de mantener y menos propensos a errores.
• Consistencia. RxJava puede ser una biblioteca centrada en datos, pero su definición de "datos" es bastante amplio e incluye cosas como variables, cachés, propiedades y aun usuario eventos de entrada como clics y golpes fuertes. Ya que RxJava casi todo trata como datos, proporciona un flujo de trabajo coherente que se puede utilizar a través de la aplicación, en muchos escenarios diferentes.
• Subprocesamiento múltiple fácil. Aplicaciones móviles modernos deben ser capaces de realizar múltiples tareas, pero como un entorno de subprocesos, Android no es exactamente un experimentado nacido natural! Android proporciona varias herramientas integradas para crear subprocesos adicionales, pero ninguna de estas soluciones son particularmente fácil de trabajar con, y rápidamente pueden resultar en código complejo que es susceptible a problemas tales como pérdidas de memoria. Mediante la adición de RxJava a tu proyecto, tienes acceso a los operadores de subscribeOn y observeOn, que hacen mucho más fácil de crear y administrar subprocesos adicionales.
• Transformaciones de datos complejos. RxJava tiene una enorme colección de operadores que puede utilizar para modificar, filtrar, combinar y transformar los datos que se emite por su RxJava Observables. Aplicar un operador a un Observable normalmente devuelve otro Observable, por lo que si no puede encontrar el operador perfecto para su proyecto, entonces usted puede simplemente mantener aplicar operadores a un Observable hasta obtener exactamente los resultados que desea.

Para obtener más información acerca de los beneficios del uso de RxJava en tus proyectos Android, consulta nuestro artículo Iniciando Con 2 RxJava.

Autenticación Con un API Key

Muchas API requieren incluir una clave API única en sus peticiones HTTP. Estas claves permiten a la empresa o individuo detrás de la API de seguimiento de las solicitudes asociadas con el proyecto, que es útil para hacer cumplir las restricciones de uso o si creador de API simplemente quiere cierta penetración en cómo se utiliza la API.

Al consultar la API de Cryptocurrency y Bitcoin nómica, necesitará incorporar una clave API única en su petición, así que vamos a generar esta clave ahora:

• En el explorador web, dirígete a la Página Web de Nomics.
• Encontrar el botón de Obtener Gratis una API Key y darle un clic.
• Compruebe los Términos y Condiciones, y si eres feliz proceder luego complete el formulario.
• Seleccione la Completar Orden. Después de unos instantes, recibirá un correo electrónico con tu clave API única.

Crear Su Aplicación: Agregar Dependencias

Crear una nueva aplicación Android con la configuración de su elección, pero cuando se le solicite, optan por Kotlin incluyen soporte.

A continuación, abra el archivo build.gradle y añadir todas las librerías que usaremos a lo largo de este proyecto. Además de la modificación y RxJava 2.0, necesitaremos lo siguiente:

1. RecyclerView

Después de recuperar nuestros datos, nos va mostrar en una lista, utilizando RecyclerView.

1

   implementation 'com.android.support:recyclerview-v7:26.1.0'

2. Gson Convertidor

Mayoría de las veces, la respuesta del servidor se asigna a un formato de lenguaje neutro, como JSON, su aplicación va a necesitar serializar y deserializar los datos JSON. Fuera de la caja, modificación solamente puede deserializar cuerpos HTTP en tipo de ResponseBody de OkHttp, pero puede soportar otros tipos por la externalización de la conversión a los convertidores independientes.

Se dispone de una amplia gama de convertidores, pero en este tutorial va ser usando Gson, que convierte el JSON en los objetos Java equivalente.

1

   implementation 'com.squareup.retrofit2:converter-gson:2.3.0'

3. Adaptador de RxJava

Para crear métodos de interfaz que son capaces de volver RxJava tipos, necesitaremos utilizar el adaptador Retrofit para RxJava.

1

   implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

4. la Biblioteca de RxAndroid

La biblioteca de RxAndroid proporciona algunos enlaces específicos Android para RxJava, especialmente AndroidSchedulers.mainThread.

En Android, sólo puede actualizar la interfaz de usuario de la aplicación desde el subproceso de interfaz de usuario principal. Si los usuarios van a ver cualquier dato de cryptocurrency, entonces usted necesitará cambiar para el subproceso principal de la interfaz de usuario en algún momento.

Usted puede rápida y fácilmente programa código para ejecutar en el subproceso de interfaz de usuario principal de Android usando el operador de observeOn de RxJava en combinación con el programador de AndroidSchedulers.mainThread de RxAndroid:

1

.observeOn(AndroidSchedulers.mainThread())

Para utilizar RxAndroid en su proyecto, necesitarás la siguiente dependencia de proyecto:

1

   implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

... Pero no RxKotlin

En este punto, usted se estará preguntando por qué nos estamos codificación en Kotlin pero con RxJava, cuando se dispone de una biblioteca es dedicada de RxKotlin.

Kotlin es interoperable con Java 100%, la mayoría de las bibliotecas de Java es compatible con Kotlin y RxJava no es una excepción! Usted podría utilizar RxJava y RxKotlin en su proyecto, pero para ayudar a mantener las cosas simples, se va pegando a RxJava a lo largo de este tutorial. Si estás interesado en aprender más acerca de RxKotlin, entonces usted encontrará mucha información en mi artículo sobre Kotlin Programación Reactiva con RxJava y RxKotlin.

Añadir las Dependencias del Proyecto

Después de agregar todas las dependencias del proyecto, el archivo build.gradle debe verse algo como esto:

1

dependencies {

2

3

   implementation fileTree(dir: 'libs', include: ['*.jar'])

4

   implementation"org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"

5

   implementation 'com.android.support:appcompat-v7:26.1.0'

6

   implementation 'com.android.support:recyclerview-v7:26.1.0'

7

   implementation 'com.android.support.constraint:constraint-layout:1.0.2'

8

9

   implementation 'com.squareup.retrofit2:retrofit:2.3.0'

10

   implementation 'com.squareup.retrofit2:converter-gson:2.3.0'

11

   implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

12

   implementation 'io.reactivex.rxjava2:rxjava:2.1.9'

13

   implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

14

15

   testImplementation 'junit:junit:4.12'

16

   androidTestImplementation 'com.android.support.test:runner:1.0.1'

17

   androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'

18

19

}

Solicitud de Acceso a Internet

Ya que nuestra aplicación se comunica con un servidor remoto, necesita permiso para acceder a Internet. Abrir su projecto de Manifest y agregar lo siguiente:

1

<?xml version="1.0" encoding="utf-8"?>

2

https://schemas.android.com/apk/res/android"

3

   package="com.jessicathornsby.myapplication">

4

5

   <uses-permission android:name="android.permission.INTERNET"/>

Tenga en cuenta que ya android.permission.INTERNET es categorizado como un permiso de seguridad, no necesitamos pedir en tiempo de ejecución.

Definir Sus Extremos HTTP

A continuación, necesitamos crear una interfaz donde Describimos nuestras peticiones HTTP:

• Seleccione Archivo > Nuevo > Archivo Kotlin/Clase desde la barra de herramientas de Android Studio.
• Nombre este archivo GetData.
• Abrir el menú desplegable y seleccione Interfaz.

• Haga clic en Aceptar.

Cada solicitud debe incluir al menos una anotación de HTTP, que indica cómo debe manejarse esta petición. Modificación soporta anotaciones para todos los tipos de solicitud estándar, pero sólo utilizaremos las anotaciones @GET, puesto que estamos recuperando datos del servidor.

También necesitamos describir el punto final, que es la URL estamos recuperando datos de. En nuestra aplicación, esto es https://api.nomics.com/v1/markets/prices, que consiste en una dirección URL base (https://api.nomics.com/v1/) y una dirección URL relativa (precios). Definiremos la URL base en otra parte en nuestro proyecto, por lo que por ahora sólo tiene que preocuparse de la dirección URL relativa.

Si la API en cuestión no requiere una clave de API, declarando luego la base y dirección URL relativa debe ser suficiente, pero desde la Nomics API hace requiere una clave, tenemos que incorporar esta información en nuestra petición.

Este proceso puede variar entre APIs, por lo que siempre debe consultar la documentación de su API para más información. En particular, estar al acecho de cualquier sección marcada Autenticación, ya que es a menudo donde puedes encontrar las instrucciones relativas a las claves de API. La documentación de la API de la nómica es un ejemplo perfecto de esto, ya que tiene una sección dedicada de Autenticación que describe cómo debe incorporar su clave en el siguiente formato:

https://api.nomics.com/v1/prices?key=your-api-key-goes-here

Combina tu API key, las anotaciones @GET y dirección URL relativa nos da lo siguiente:

1

   @GET("prices?key=your-api-key-goes-here")

Yo voy buscar los datos de API mediante la función getData() de Kotlin. Ya que queremos que esta función para emitir RxJava Observables, tenemos que definir nuestro punto final como un tipo válido de RxJava:

1

    fun getData() : Observable<List<RetroCrypto>>

Aquí le damos la interfaz completa:

1

import io.reactivex.Observable

2

import retrofit2.http.GET

3

4

interface GetData {

5

6

//Describe the request type and the relative URL//

7

8

   @GET("prices?key=YOUR-API-KEY-HERE")

9

    fun getData() : Observable<List<RetroCrypto>>

10

11

}

¡Asegúrese de que reemplazar YOUR-API-KEY-HERE con tu propia llave!

Creación de un Modelo con Clase de Datos Kotlin

A continuación, necesitamos crear una clase de datos que representa la respuesta a cada una de nuestras llamadas a la API:

• Seleccione File > New > Kotlin File / Class de la barra de herramientas de Android Studio.
• Nombre de esta clase RetroCrypto y haga clic en Aceptar.
• Abra su nueva clase de RetroCrypto.

Si anteriormente has realizado llamadas modificación usando Java, entonces esta es un área donde Kotlin es mucho más conciso que el equivalente Java, gracias a las clases de datos.

En Kotlin, una clase de datos es una clase que ha diseñado exclusivamente para contener algunos datos. El compilador de Kotlin implementa los métodos hashCode(), equals() y toString() requiere automáticamente, por lo que puede crear una clase de modelo de datos en una sola línea de código.

Abra el nuevo archivo RetroCrypto y añadir lo siguiente:

1

data class RetroCrypto(val currency : String, val price : String)

Construcción de la Instancia de Retrofit

Para enviar peticiones de red, tenemos que utilizar la clase Retrofit.Builder para crear una instancia de adaptación, donde nos llame a nuestro punto final y recuperar la información de cryptocurrency.

1

private fun loadData() {

2

   val requestInterface = Retrofit.Builder()

Una vez que hemos construido nuestro objeto de modificación, tenemos que:

• Establecer el URL base. Antes de llamar el método build() en Retrofit.Builder, necesita por lo menos han definido la dirección URL base.
• Configurar el conversor por defecto, utilizando el método de addConverterFactory(). Una vez que haya configurado el convertidor Gson, podrá traducir la respuesta JSON automáticamente.
• Aplicar el adaptador. Modificación de naves con un adaptador por defecto para ejecutar instancias de Call, pero se pueden aplicar uno o más adaptadores adicionales mediante el suministro de una instancia de dicho adaptador cuando usted está construyendo la instancia de modificación. Para utilizar el RxJava junto con la modificación, tenemos que agregar a RxJava2CallAdapterFactory como el adaptador de llamada, usando .addCallAdapterFactory.

Esto nos da lo siguiente:

1

private fun loadData() {

2

3

//Build a Retrofit object// 

4

5

   val requestInterface = Retrofit.Builder()

6

           .baseUrl(BASE_URL)

7

           .addConverterFactory(GsonConverterFactory.create())

8

           .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

9

10

//Get a usable Retrofit object by calling .build()//

11

12

           .build().create(GetData::class.java)

De forma predeterminada, un Observable emite sus datos en el subproceso donde se declaró la suscripción, que en Android es típicamente el subproceso de interfaz de usuario principal. Sin embargo, para mejores resultados, su aplicación debe sólo realizar trabajos relacionados con la interfaz de usuario en el subproceso de interfaz de usuario, por lo que utilizaremos subscribeOn de RxJava y un programador de acompañamiento para crear un hilo alternativo donde el Observable debe ejecutar:

1

.subscribeOn(Schedulers.io())

A continuación, usaremos el operador de observeOn, además AndroidSchedulers.mainThread programador de RxAndroid para enviar notificaciones de observables al subproceso de interfaz de usuario principal de Android, preparado para mostrar los datos recuperados en la interfaz de usuario de la aplicación.

Para una mirada más detallada a suscribirse a Observables en Kotlin, pásate por mi post de Kotlin Programación Reativa con RxJava y RxKotlin.

En el siguiente fragmento de código, también estoy usando el método handleResponse() para manejar los datos que recibirá, después de una operación exitosa de la red:

1

   myCompositeDisposable?.add(requestInterface.getData()

2

               .observeOn(AndroidSchedulers.mainThread())

3

               .subscribeOn(Schedulers.io())

4

               .subscribe(this::handleResponse))

5

6

   }

El código anterior devuelve una Disposable—si tienes experiencia previa de RxJava 1.0, luego desechables son esencialmente de RxJava 2.0 versión de suscripciones.

Cuando has acabado con una suscripción de desechables, debe desechar para evitar fugas de memoria. Podemos hacer que este proceso de limpieza más fácil mediante la adición de todos nuestros materiales desechables a un CompositeDisposable, que es un contenedor que puede contener múltiples materiales desechables. En el código anterior, estamos inicializando CompositeDisposable de RxJava y luego agregar cada desechables a la CompositeDisposable, mediante el método add().

1

myCompositeDisposable?.add(requestInterface.getData()

Entonces, basta borrar el CompositeDisposable durante el método onDestroy() de nuestro proyecto:

1

   override fun onDestroy() {

2

       super.onDestroy()

3

       myCompositeDisposable?.clear()

4

   }

5

6

}

Aquí está la clase completa:

1

import android.support.v7.app.AppCompatActivity

2

import android.os.Bundle

3

import io.reactivex.disposables.CompositeDisposable

4

import android.support.v7.widget.LinearLayoutManager

5

import android.support.v7.widget.RecyclerView

6

import android.widget.Toast

7

8

import retrofit2.converter.gson.GsonConverterFactory

9

import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory

10

import retrofit2.Retrofit

11

12

import io.reactivex.schedulers.Schedulers

13

import io.reactivex.android.schedulers.AndroidSchedulers

14

import kotlinx.android.synthetic.main.activity_main.*

15

16

class MainActivity : AppCompatActivity(), MyAdapter.Listener {

17

18

   private var myAdapter: MyAdapter? = null

19

   private var myCompositeDisposable: CompositeDisposable? = null

20

   private var myRetroCryptoArrayList: ArrayList<RetroCrypto>? = null

21

   private val BASE_URL = "https://api.nomics.com/v1/"

22

23

   override fun onCreate(savedInstanceState: Bundle?) {

24

       super.onCreate(savedInstanceState)

25

       setContentView(R.layout.activity_main)

26

       myCompositeDisposable = CompositeDisposable()

27

       initRecyclerView()

28

       loadData()

29

30

   }

31

32

//Initialise the RecyclerView//

33

34

   private fun initRecyclerView() {

35

36

//Use a layout manager to position your items to look like a standard ListView//

37

38

       val layoutManager : RecyclerView.LayoutManager = LinearLayoutManager(this)

39

       cryptocurrency_list.layoutManager = layoutManager

40

41

   }

42

43

//Implement loadData//

44

45

   private fun loadData() {

46

47

//Define the Retrofit request//

48

49

       val requestInterface = Retrofit.Builder()

50

51

//Set the API’s base URL//

52

53

               .baseUrl(BASE_URL)

54

55

//Specify the converter factory to use for serialization and deserialization//

56

57

               .addConverterFactory(GsonConverterFactory.create())

58

59

//Add a call adapter factory to support RxJava return types//  

60

61

               .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

62

63

//Build the Retrofit instance//

64

65

               .build().create(GetData::class.java)

66

67

//Add all RxJava disposables to a CompositeDisposable//

68

69

       myCompositeDisposable?.add(requestInterface.getData()

70

71

//Send the Observable’s notifications to the main UI thread//

72

73

               .observeOn(AndroidSchedulers.mainThread())

74

75

//Subscribe to the Observer away from the main UI thread//

76

77

               .subscribeOn(Schedulers.io())

78

               .subscribe(this::handleResponse))

79

80

   }

81

82

   private fun handleResponse(cryptoList: List<RetroCrypto>) {

83

84

       myRetroCryptoArrayList = ArrayList(cryptoList)

85

       myAdapter = MyAdapter(myRetroCryptoArrayList!!, this)

86

87

//Set the adapter//

88

89

       cryptocurrency_list.adapter = myAdapter

90

91

   }

92

93

   override fun onItemClick(retroCrypto: RetroCrypto) {

94

95

//If the user clicks on an item, then display a Toast// 

96

97

       Toast.makeText(this, "You clicked: ${retroCrypto.currency}", Toast.LENGTH_LONG).show()

98

99

   }

100

101

   override fun onDestroy() {

102

       super.onDestroy()

103

104

//Clear all your disposables//

105

106

       myCompositeDisposable?.clear()

107

108

   }

109

110

}

Mostrar los Datos de la API de Cryptocurrency

En este punto, nuestra aplicación puede con éxito recuperar los datos de la API de nómica, por lo que nuestra tarea final es Mostrar datos al usuario, a través de un RecyclerView.

Para implementar un RecyclerView, tenemos los siguientes:

• Un widget de RecyclerView.
• Un diseño XML personalizado que el RecyclerView puede usar para mostrar cada uno de sus artículos.
• Un adaptador, que vincula los datos a su RecyclerView.

Creación de una Lista Desplazable

Vamos a comenzar añadiendo un widget de RecyclerView a nuestro archivo activity_main.xml:

1

<?xml version="1.0" encoding="utf-8"?>

2

http://schemas.android.com/apk/res/android"

3

   xmlns:app="http://schemas.android.com/apk/res-auto"

4

   xmlns:tools="http://schemas.android.com/tools"

5

   android:layout_width="match_parent"

6

   android:layout_height="match_parent"

7

   tools:context="com.jessicathornsby.myapplication.MainActivity">

8

9

   <android.support.v7.widget.RecyclerView

10

       android:id="@+id/cryptocurrency_list"

11

       android:layout_width="match_parent"

12

       android:layout_height="match_parent"

13

       app:layout_constraintTop_toTopOf="parent"

14

       app:layout_constraintBottom_toBottomOf="parent"

15

       app:layout_constraintRight_toRightOf="parent"

16

       app:layout_constraintLeft_toLeftOf="parent" />

17

18

</android.support.constraint.ConstraintLayout>

Ahora que ya tenemos nuestro widget de RecyclerView, tenemos que definir el diseño de cada fila dentro de ese RecyclerView. Voy a crear un diseño simple que consiste en dos TextViews, donde podrá visualizar el nombre y el precio de cada cryptocurrency Obtenido de la API de Nomics:

• Control-clic en carpeta de res/layout del proyecto.
• Seleccione Nuevo > Archivo de recursos de diseño.
• Nombre este archivo row_layout y haga clic en Aceptar.

Abra el archivo row_layout.xml y añadir lo siguiente:

1

<?xml version="1.0" encoding="utf-8"?>

2

3

<android.support.constraint.ConstraintLayout

4

   xmlns:android="http://schemas.android.com/apk/res/android"

5

   xmlns:app="http://schemas.android.com/apk/res-auto"

6

   android:layout_width="match_parent"

7

   android:layout_height="wrap_content"

8

   android:layout_marginBottom="2dp">

9

10

   <TextView

11

       android:id="@+id/text_name"

12

       android:layout_width="match_parent"

13

       android:layout_height="wrap_content"

14

       android:textColor="@android:color/white"

15

       android:textSize="26sp"

16

       android:layout_marginTop="10dp"

17

       android:layout_marginBottom="10dp"

18

       android:layout_marginStart="10dp"

19

       android:layout_marginEnd="10dp"

20

       app:layout_constraintStart_toStartOf="parent"

21

       app:layout_constraintTop_toTopOf="parent" />

22

23

   <TextView

24

       android:id="@+id/text_price"

25

       android:layout_width="match_parent"

26

       android:layout_height="wrap_content"

27

       android:textColor="@android:color/white"

28

       android:textSize="20sp"

29

       android:layout_marginTop="10dp"

30

       android:layout_marginBottom="10dp"

31

       android:layout_marginStart="10dp"

32

       android:layout_marginEnd="10dp"

33

       app:layout_constraintStart_toStartOf="parent"

34

       app:layout_constraintTop_toBottomOf="@+id/text_name" />

35

36

</android.support.constraint.ConstraintLayout>

Nuestro RecyclerView ahora utilizará este esquema para cada elemento de la lista.

Enlace de Datos Con los Adaptadores de Android

El adaptador es el componente que se encarga de atar cada elemento a una View dentro de la RecyclerView.

Para conectar el modelo de datos subyacente a la interfaz de usuario de su aplicación, necesita ampliar RecyclerView.Adapter, y luego implementar lo siguiente:

• onCreateViewHolder(). Esto es donde especificamos la disposición (R.layout.row_layout) que cada elemento de la RecyclerView debe utilizar e inflar ese diseño utilizando LayoutInflater.
• onBindViewHolder(). Llama a RecyclerView para mostrar los datos en la posición especificada.
• getItemCount(). Devuelve el número de elementos presentes en el conjunto de datos.

Cuando se trabaja con Views, a menudo puede simplificar el código mediante el uso de extensiones de Kotlin Android. Estas extensiones le permiten acceder a Views del diseño directamente importándolos como propiedades "sintéticos" en la clase. Por ejemplo, puede importar referencias a todas las vistas en su archivo row_layout, usando los siguientes:

1

import kotlinx.android.synthetic.main.row_layout.view.*

En este punto, se pueden acceder a todos los de Views de row_layout, con solo su ID y sin un findViewById() a la vista! Por ejemplo, puede actualizar el widget de text_name, mediante lo siguiente:

1

           itemView.text_name.text = retroCrypto.currency

En esta clase, también te paso el dato como un ArrayList, junto a un Listener que usaré para manejar eventos de entrada de usuario. Finalmente, para que nuestra aplicación parezca un poco más interesante, a definir un Matriz Array de colores y usarlas como fondo de mis artículos de RecyclerView.

Crear una nueva clase de Kotlin denominada MyAdapter y agregue lo siguiente:

1

import android.graphics.Color

2

import android.view.LayoutInflater

3

import android.view.View

4

import android.view.ViewGroup

5

import android.support.v7.widget.RecyclerView

6

import kotlinx.android.synthetic.main.row_layout.view.*

7

8

//Pass the ArrayList and a listener, and add a variable to hold your data//

9

10

class MyAdapter (private val cryptoList : ArrayList<RetroCrypto>, private val listener : 

11

12

//Extend RecyclerView.Adapter//

13

14

Listener) : RecyclerView.Adapter<MyAdapter.ViewHolder>() {

15

   interface Listener {

16

       fun onItemClick(retroCrypto : RetroCrypto)

17

18

   }

19

20

//Define an array of colours//

21

22

   private val colors : Array<String> = arrayOf("#7E57C2", "#42A5F5", "#26C6DA", "#66BB6A", "#FFEE58", "#FF7043" , "#EC407A" , "#d32f2f")

23

24

//Bind the ViewHolder// 

25

26

   override fun onBindViewHolder(holder: ViewHolder, position: Int) {

27

28

//Pass the position where each item should be displayed//

29

30

       holder.bind(cryptoList[position], listener, colors, position)

31

32

   }

33

34

//Check how many items you have to display//

35

36

   override fun getItemCount(): Int = cryptoList.count()

37

   override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {

38

       val view = LayoutInflater.from(parent.context).inflate(R.layout.row_layout, parent, false)

39

       return ViewHolder(view)

40

41

   }

42

43

//Create a ViewHolder class for your RecyclerView items// 

44

45

   class ViewHolder(view : View) : RecyclerView.ViewHolder(view) {

46

47

//Assign values from the data model, to their corresponding Views//

48

49

       fun bind(retroCrypto: RetroCrypto, listener: Listener, colors : Array<String>, position: Int) {

50

51

//Listen for user input events//

52

53

           itemView.setOnClickListener{ listener.onItemClick(retroCrypto) }

54

           itemView.setBackgroundColor(Color.parseColor(colors[position % 8]))

55

           itemView.text_name.text = retroCrypto.currency

56

           itemView.text_price.text = retroCrypto.price

57

58

       }

59

60

   }

61

62

}

Prueba de Su Retrofit y Aplicación RxJava 2.0

¡Ahora es tiempo de poner la aplicación a prueba! Asegúrese de que tiene una conexión activa a Internet y luego instalar la aplicación en un teléfono inteligente Android o tableta o AVD (Android Virtual dispositivo). Tan pronto como el lanzamiento de su aplicación, modificación recuperar todos los datos disponibles de la API de nómica y mostrará como parte de su RecyclerView.

También puede descargar el proyecto completo desde nuestro repositorio de GitHub.

Conclusión

En este artículo, le mostré cómo recuperar datos de un API con modificación, convertir los datos en formato observables de RxJava 2.0 y luego mostrarlo en un RecyclerView.

Si desea explorar más APIs, entonces encontrarás una lista de API libres, públicas en GitHub, o usted puede aprender más sobre RxJava nuestra serie en la que Comenzó Con 2 RxJava para Android, o al echar un vistazo a nuestra serie de Kotlin Programación Reactiva.