Conceitos básicos da AWS

Criar uma aplicação Android

Criar uma aplicação Android simples usando o AWS Amplify

Módulo 2: Inicializar o Amplify

Neste módulo, você instalará e configurará a CLI do Amplify.

Introdução

Agora que criamos uma aplicação Android, queremos continuar o desenvolvimento e adicionar novos recursos.

Para começar a usar o AWS Amplify em sua aplicação, é preciso instalar a linha de comando do Amplify, inicializar o diretório do projeto do Amplify, configurar seu projeto para usar as bibliotecas do Amplify e inicializar as bibliotecas do Amplify em tempo de execução.

O que você aprenderá

  • Inicializar um novo projeto do Amplify
  • Adicionar bibliotecas do Amplify ao seu projeto
  • Inicializar bibliotecas do Amplify em tempo de execução

Conceitos principais

CLI do Amplify – a CLI do Amplify permite criar, gerenciar e remover serviços da AWS diretamente no seu terminal.

Bibliotecas do Amplify – as bibliotecas do Amplify permitem interagir com os serviços da AWS de uma aplicação móvel ou Web.

 Tempo para a conclusão

10 minutos

 Serviços usados

Implementação

  • Instalar a CLI do Amplify

    A CLI do AWS Amplify depende do Node.js, consulte a seção de pré-requisitos na introdução para instalar o Node.js

    Para instalar a CLI do AWS Amplify, abra um terminal e digite o seguinte 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 um back-end do Amplify

    Para criar a estrutura básica de nosso back-end, primeiro precisamos inicializar o diretório do projeto do Amplify e criar nosso back-end na nuvem.

    Abra um terminal e mude para o diretório do seu projeto. Por exemplo, se você criou seu projeto na pasta ~/AndroidStudioProjects/android-getting-started, pode digitar:

    cd ~/AndroidStudioProjects/android-getting-started  

    Verifique se você está no diretório correto, que deve ser parecido com este:

    ➜  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

    Inicialize o arquivo de configuração e a estrutura do projeto do Amplify. Execute o seguinte 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.

    Se você ainda não tiver um perfil, poderá criar um com a CLI do AWS usando aws configure --profile <name>.

    O Amplify inicializa seu projeto na nuvem, e isso pode levar alguns minutos. Após alguns minutos, você deve ver uma mensagem como a seguinte:

    ✔ 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!
  • Adicionar bibliotecas do Amplify ao seu projeto

    O Amplify para Android é distribuído como pacotes do Apache Maven. Nesta seção, você adicionará os pacotes e outras diretivas necessárias para a configuração de compilação.

    De volta ao Android Studio, expanda Gradle Scripts e abra build.gradle (Project: Android_Getting_Started). Adicione a linha mavenCentral() dentro do bloco de repositórios nos blocos buildscript e 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()
        }
    }

    Em Gradle Scripts, abra build.gradle (Module:app) e adicione a dependência principal da estrutura de trabalho do Amplify no bloco de implementações.

    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'
    }

    Caso você desenvolva em Java ou tenha como objetivo o Android SDK 21 ou anterior, verifique a documentação para ver mais alterações de configuração.

    Agora, execute o Gradle Sync.

    AndroidAppTutorial_Modiule2_Image1

    Após algum tempo, você deverá ver

    BUILD SUCCESSFUL in 1s
  • Inicializar o Amplify em tempo de execução

    Vamos criar uma classe Backend para agrupar o código e interagir com nosso back-end. Eu uso um padrão de projeto singleton para disponibilizá-lo facilmente por meio da aplicação e garantir que as bibliotecas do Amplify sejam inicializadas apenas uma vez.

    O inicializador de classe se encarrega de inicializar as bibliotecas do Amplify.

    Em java/com.example.androidgettingstarted, crie um novo arquivo kotlin Backend.kt, abra-o e adicione 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
        }
    }

    Inicializamos nosso objeto Backend singleton quando a aplicação é iniciada.

    Em java/com.example.androidgettingstarted, crie um novo arquivo kotlin Application.kt, abra-o e adicione 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)
        }
    }

    Em manifests (manifestos), abra AndroidManifest.xml e adicione o nome da classe da aplicação ao 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">
    ...

    Enquanto você estiver com esse arquivo aberto, adicione algumas permissões que a aplicação exigirá nas etapas posteriores deste 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 a sua configuração

    Para verificar se tudo funciona conforme o esperado, compile e execute o projeto. Clique no ícone Run (Executar) ▶️ na barra de ferramentas ou digite ^ R.

    Para verificar se tudo funciona conforme esperado, compile e execute o projeto. Clique no ícone  Run (Executar) ▶️  na barra de ferramentas ou digite  ^ R.
    AndroidAppTutorial_Modiule2_Image2

    Não deve aparecer nenhum erro.

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

Conclusão

Você inicializou o projeto do Amplify e agora pode começar a adicionar recursos! No próximo módulo, adicionaremos um fluxo de autenticação de usuário inteiro com apenas algumas linhas de código.

Este módulo foi útil?

Agradecemos a sua atenção
Gostaríamos de saber do que você gostou.
Fechar
Desculpe por ter desapontado
Encontrou algo desatualizado, confuso ou incorreto? Envie seus comentários para nos ajudar a melhorar este tutorial.
Fechar

Adicionar autenticação