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

  

  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.

  

  No debería haber ningún error.
  

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