Introducción a AWS

Crear una aplicación Android

Crear una aplicación Android sencilla con AWS Amplify

Módulo 2: inicializar Amplify

En este módulo, instalará y configurará la CLI de Amplify.

Introducción

Ahora que hemos creado una aplicación Android, queremos continuar con el desarrollo y agregar nuevas funciones.

Para comenzar a usar AWS Amplify en su aplicación, debe instalar la línea de comandos de Amplify, inicializar el directorio del proyecto de Amplify, configurar su proyecto para usar las bibliotecas de Amplify e inicializar las bibliotecas de Amplify en el tiempo de ejecución.

Lo que aprenderá

  • Inicializar un nuevo proyecto de Amplify
  • Agregar bibliotecas de Amplify a su proyecto
  • Inicializar bibliotecas de Amplify en el tiempo de ejecución

Conceptos clave

CLI de Amplify: la CLI de Amplify le permite crear, administrar y retirar servicios de AWS directamente de su terminal.

Bibliotecas de Amplify: las bibliotecas de Amplify le permiten interactuar con los servicios de AWS desde una aplicación web o móvil.

 Tiempo de realización

10 minutos

 Servicios utilizados

Implementación

  • Instalar la CLI de Amplify

    La CLI de AWS Amplify depende de Node.js. Consulte la sección de requisitos previos en la introducción para instalar Node.js.

    Para instalar la CLI de AWS Amplify, abra una terminal y escriba el siguiente comando:

    ## Install Amplify CLI
    npm install -g @aws-amplify/cli
    
    ## Verify installation and version
    amplify --version
    # Scanning for plugins...
    # Plugin scan successful
    # 4.29.4
  • Inicializar un backend de Amplify

    Para crear la estructura básica de nuestro backend, primero debemos inicializar el directorio del proyecto de Amplify y crear nuestro backend en la nube.

    Abra una terminal y cambie al directorio de su proyecto. Por ejemplo, si creó su proyecto en la carpeta ~/AndroidStudioProjects/android-getting-started, puede escribir:

    cd ~/AndroidStudioProjects/android-getting-started  

    Verifique que esté en el directorio correcto; debería verse así:

    ➜  android-getting-started git:(main) ✗ ls -al
    total 32
    drwxr-xr-x  14 stormacq  admin   448 Oct  6 14:06 .
    drwxr-xr-x  16 stormacq  admin   512 Oct  6 11:28 ..
    -rw-r--r--   1 stormacq  admin   208 Oct  6 14:04 .gitignore
    drwxr-xr-x   6 stormacq  admin   192 Oct  6 14:04 .gradle
    drwxr-xr-x  13 stormacq  admin   416 Oct  6 15:19 .idea
    drwxr-xr-x   8 stormacq  admin   256 Oct  6 14:06 app
    drwxr-xr-x   3 stormacq  admin    96 Oct  6 14:06 build
    -rw-r--r--   1 stormacq  admin   642 Oct  6 14:04 build.gradle
    drwxr-xr-x   3 stormacq  admin    96 Oct  6 14:04 gradle
    -rw-r--r--   1 stormacq  admin  1162 Oct  6 14:04 gradle.properties
    -rwxr--r--   1 stormacq  admin  5296 Oct  6 14:04 gradlew
    -rw-r--r--   1 stormacq  admin  2260 Oct  6 14:04 gradlew.bat
    -rw-r--r--   1 stormacq  admin   437 Oct  6 14:04 local.properties
    -rw-r--r--   1 stormacq  admin    59 Oct  6 14:04 settings.gradle

    Inicialice la estructura del proyecto y el archivo de configuración de Amplify. Ejecute el siguiente comando:

    amplify init
    
    ? Enter a name for your project (androidgettingstarted): accept the default, press enter
    ? Enter a name for the environment (dev): accept the default, press enter
    ? Choose your default editor: use the arrow key to select your favorite text editor an press enter
    ? Choose the type of app that you're building: android is already selected, press enter
    ? Where is your Res directory: accept the default, press enter
    ? Do you want to use an AWS profile?, Y, press enter
    ? Please choose the profile you want to use: use the arrow keys to select your profile and press enter.

    Puede crear un perfil mediante la CLI de AWS con aws configure --profile <name> si aún no tiene uno.

    Amplify inicializa su proyecto en la nube; puede tardar unos minutos. Luego de unos minutos, debería ver el siguiente mensaje:

    ✔ Successfully created initial AWS cloud resources for deployments.
    ✔ Initialized provider successfully.
    Initialized your environment successfully.
    
    Your project has been successfully initialized and connected to the cloud!
  • Agregar bibliotecas de Amplify a su proyecto

    Amplify para Android se distribuye como paquetes Apache Maven. En esta sección, agregará los paquetes y otras directivas requeridas a su configuración de compilación.

    En Android Studio, expanda Gradle Scripts (Scripts de Gradle) y abra build.gradle (Project: Android_Getting_Started). Agregue la línea mavenCentral() dentro del bloque de repositorios en los bloques buildscript y allprojects.

    buildscript {
        ext.kotlin_version = "1.4.10"
        repositories {
            google()
            jcenter()
    
            // Add this line into `repositories` in `buildscript`
            mavenCentral()
        }
        dependencies {
            classpath "com.android.tools.build:gradle:4.0.1"
            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    
            // NOTE: Do not place your application dependencies here; they belong
            // in the individual module build.gradle files
        }
    }
    
    allprojects {
        repositories {
            google()
            jcenter()
    
            // Add this line into `repositories` in `buildscript`
            mavenCentral()
        }
    }

    En Gradle Scripts (Scripts de Gradle), abra build.gradle (Module:app) y agregue la dependencia principal del marco de Amplify en el bloque de implementaciones.

    dependencies {
        implementation fileTree(dir: "libs", include: ["*.jar"])
        implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
        implementation 'androidx.core:core-ktx:1.3.2'
        implementation 'androidx.appcompat:appcompat:1.2.0'
        implementation 'com.google.android.material:material:1.2.1'
        implementation 'androidx.constraintlayout:constraintlayout:2.0.1'
        implementation 'androidx.navigation:navigation-fragment-ktx:2.3.0'
        implementation 'androidx.navigation:navigation-ui-ktx:2.3.0'
        testImplementation 'junit:junit:4.13'
        androidTestImplementation 'androidx.test.ext:junit:1.1.2'
        androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    
        // Amplify core dependency
        implementation 'com.amplifyframework:core:1.4.0'
    }

    Si desarrolla en Java o tiene como objetivo Android SDK 21 (o una versión anterior), consulte la documentación para conocer los cambios de configuración adicionales.

    Ahora, ejecute Gradle Sync (Sincronización de Gradle).

    AndroidAppTutorial_Modiule2_Image1

    Luego de un momento, debería ver lo siguiente:

    BUILD SUCCESSFUL in 1s
  • Inicializar Amplify en el tiempo de ejecución

    Vamos a crear una clase Backend a fin de agrupar el código para interactuar con nuestro backend. Se utiliza un patrón de diseño singleton para que esté disponible fácilmente a través de la aplicación y garantizar que las bibliotecas de Amplify se inicialicen solo una vez.

    El inicializador de clases se encarga de inicializar las bibliotecas de Amplify.

    En java/com.example.androidgettingstarted, cree un nuevo archivo kotlin Backend.kt, ábralo y agregue este código:

    package com.example.androidgettingstarted
    
    import android.content.Context
    import android.util.Log
    import com.amplifyframework.AmplifyException
    import com.amplifyframework.core.Amplify
    
    object Backend {
    
        private const val TAG = "Backend"
    
        fun initialize(applicationContext: Context) : Backend {
            try {
                Amplify.configure(applicationContext)
                Log.i(TAG, "Initialized Amplify")
            } catch (e: AmplifyException) {
                Log.e(TAG, "Could not initialize Amplify", e)
            }
            return this
        }
    }

    Inicializaremos nuestro objeto backend singleton cuando se inicie la aplicación.

    En java/com.example.androidgettingstarted, cree un nuevo archivo kotlin Application.kt, ábralo y agregue este código:

    package com.example.androidgettingstarted
    
    import android.app.Application
    
    class AndroidGettingStartedApplication : Application() {
    
        override fun onCreate() {
            super.onCreate()
    
            // initialize Amplify when application is starting
            Backend.initialize(applicationContext)
        }
    }

    En manifiestos, abra AndroidManifest.xml y agregue el nombre de la clase de aplicación al elemento <application>.

        <!-- add the android:name attribute to the application node  -->
        <application
            android:name="AndroidGettingStartedApplication"
            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.GettingStartedAndroid">
    ...

    Mientras tenga este archivo abierto, agregue un par de permisos que la aplicación requerirá en pasos posteriores de este tutorial.

        <!-- add these nodes between manifest and application  -->
        <uses-permission android:name="android.permission.INTERNET"/>
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
  • Verificar su configuración

    Para verificar que todo funcione como se espera, cree y ejecute el proyecto. Haga clic en el icono Run (Ejecutar) ▶️️ en la barra de herramientas o escriba ^ R.

    Para verificar que todo funcione como se espera, cree y ejecute el proyecto. Haga clic en el  ícono  Run (Ejecutar) ▶️  en la barra de herramientas o escriba ^ R.
    AndroidAppTutorial_Modiule2_Image2

    No debería haber ningún error.

    BUILD SUCCESSFUL in 6s
    23 actionable tasks: 8 executed, 15 up-to-date

Conclusión

Ha iniciado el proyecto Amplify y ahora está listo para comenzar a agregar funciones. En el siguiente módulo, agregaremos todo un flujo de autenticación de usuarios con solo algunas líneas de código.

¿Este módulo le resultó útil?

Gracias
Indíquenos lo que le gustó.
Cerrar
Lamentamos haberlo decepcionado
¿Hay información desactualizada, confusa o inexacta? Ayúdenos a mejorar este tutorial con sus comentarios.
Cerrar

Agregar autenticación