Creación de API en Android Studio con Biceptor y Retrofit

Clase 3 de 19 • Curso de Android: Modo Offline con Room y Realm

Clase anteriorSiguiente clase

Resumen

La creación de APIs y la configuración inicial de proyectos Android son habilidades fundamentales para cualquier desarrollador que desee construir aplicaciones móviles robustas y escalables. En esta guía, exploraremos cómo utilizar Beeceptor para crear una API simulada y configurar un proyecto Android desde cero, implementando las dependencias necesarias para trabajar con servicios web de manera eficiente.

¿Cómo crear una API simulada con Beeceptor?

Beeceptor es una herramienta poderosa que nos permite crear APIs simuladas (mock APIs) de manera rápida y sencilla, lo que resulta extremadamente útil durante el desarrollo de aplicaciones que necesitan consumir servicios web.

Para comenzar a utilizar Beeceptor, debemos seguir estos pasos:

  1. Acceder a biceptor.com y registrarnos con nuestra cuenta de Google.
  2. Crear un nuevo proyecto (en este caso "bis order").
  3. Configurar las reglas de simulación (mocking rules) necesarias para nuestra aplicación.

Configuración de reglas en Beeceptor

Para nuestro proyecto "bizorder", necesitamos configurar tres reglas principales:

  1. Get Orders:

    • Path: "/orders"
    • Status code: 200
    • Response body: Un JSON con la información de las órdenes

  2. Pre-órdenes exitosas:

    • Path: "/pre-orden-success"
    • Status code: 200
    • Response body: Un JSON con status "exitoso"

  3. Pre-órdenes con error:

    • Path: "/pre-orden-error"
    • Status code: 400
    • Response body: Un JSON con status "error"

Con estas tres reglas configuradas, ya tenemos nuestra API simulada lista para ser consumida por nuestra aplicación Android.

¿Cómo configurar un proyecto Android desde cero?

Una vez que tenemos nuestra API simulada, es momento de crear nuestro proyecto Android. Para ello, seguiremos estos pasos:

  1. Abrir Android Studio y seleccionar "New Project".
  2. Elegir "Empty Activity" como plantilla.
  3. Nombrar nuestra aplicación "bizOrder".
  4. Configurar el package name (por ejemplo, "com.tudominio.bisorder").
  5. Seleccionar el SDK mínimo (API 24 en este caso, que cubre el 97.4% de los dispositivos).
  6. Finalizar la creación del proyecto.

Configuración de dependencias necesarias

Para nuestro proyecto, necesitamos agregar varias dependencias importantes:

  1. Hilt para la inyección de dependencias:

    • Hilt (versión 2.54)
    • Hilt Navigation Compose (versión 1.2.0)
    • Hilt Android

  2. Retrofit para la conexión con APIs:

    • Retrofit 2 (versión 2.9.0)
    • Retrofit Moshi Converter

  3. Moshi para la deserialización de JSON:

    • Moshi (versión 1.15)
    • Moshi Kotlin

  4. OkHttp Logging Interceptor para visualizar las respuestas de la API en la consola.

Para agregar estas dependencias, debemos modificar los archivos build.gradle:

// En el build.gradle del proyecto
plugins {
    id 'com.android.application' version '8.0.0' apply false
    id 'com.android.library' version '8.0.0' apply false
    id 'org.jetbrains.kotlin.android' version '1.8.10' apply false
    id 'com.google.dagger.hilt.android' apply false
}

// En el build.gradle del módulo app
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
    id 'com.google.dagger.hilt.android'
}

dependencies {
    // Hilt
    implementation "com.google.dagger:hilt-android:2.54"
    kapt "com.google.dagger:hilt-compiler:2.54"
    implementation "androidx.hilt:hilt-navigation-compose:1.2.0"
    
    // Retrofit
    implementation "com.squareup.retrofit2:retrofit:2.9.0"
    implementation "com.squareup.retrofit2:converter-moshi:2.9.0"
    
    // Moshi
    implementation "com.squareup.moshi:moshi:1.15.0"
    implementation "com.squareup.moshi:moshi-kotlin:1.15.0"
    
    // OkHttp Logging Interceptor
    implementation "com.squareup.okhttp3:logging-interceptor:4.9.0"
}

Configuración del manifiesto para acceso a Internet

Un paso crucial es agregar el permiso de Internet en el archivo AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.tudominio.bisorder">
    
    <uses-permission android:name="android.permission.INTERNET" />
    
    <application
        android:name=".BisOrderApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.BisOrder">
        
    application>
manifest>

Creación de la clase Application para Hilt

Finalmente, necesitamos crear una clase Application personalizada para la inyección de dependencias con Hilt:

package com.tudominio.bizorder

import android.app.Application
import dagger.hilt.android.HiltAndroidApp

@HiltAndroidApp
class BizOrderApplication : Application() {
    // Aquí podemos inicializar componentes globales si es necesario
}

Con estos pasos, hemos completado la configuración inicial de nuestro proyecto Android, listo para implementar Clean Architecture y comenzar a consumir nuestra API simulada creada con Beeceptor.

¿Qué sigue después de la configuración inicial?

Una vez completada la configuración inicial, el siguiente paso será organizar nuestro proyecto siguiendo los principios de Clean Architecture, lo que nos permitirá tener un código más mantenible, testeable y escalable.

También deberemos inyectar los módulos de Retrofit con Hilt para poder realizar peticiones a nuestra API de manera eficiente y organizada.

Clean Architecture nos ayudará a separar nuestro código en capas bien definidas:

  • Capa de presentación: UI, ViewModels
  • Capa de dominio: Casos de uso, modelos de dominio
  • Capa de datos: Repositorios, fuentes de datos (API, base de datos local)

Esta estructura nos permitirá mantener un código limpio y fácil de mantener a medida que nuestra aplicación crezca en complejidad.

La configuración inicial es solo el primer paso en el desarrollo de una aplicación Android robusta. Con las herramientas y dependencias que hemos configurado, estamos listos para construir una aplicación que siga las mejores prácticas de desarrollo moderno en Android.

¿Has utilizado Beeceptor antes para crear APIs simuladas? ¿Qué otras herramientas utilizas para el desarrollo de aplicaciones Android? Comparte tu experiencia en los comentarios.