Nozioni di base su AWS

Creazione di un'applicazione Android

Creazione di un'applicazione Android semplice utilizzando AWS Amplify

Modulo 2: Inizializzazione di Amplify

In questo modulo installerai e configurerai la CLI di Amplify.

Introduzione

Ora che abbiamo creato un'applicazione Android, vogliamo continuare a sviluppare e aggiungere nuove funzionalità.

Per iniziare a utilizzare AWS Amplify nella tua applicazione, devi installare la riga di comando di Amplify, inizializzare la directory del progetto Amplify, configurare il progetto per l'utilizzo delle librerie Amplify e inizializzare le librerie Amplify al momento del runtime.

Avrai modo di approfondire i seguenti aspetti

  • Inizializzazione di un nuovo progetto Amplify
  • Aggiunta di librerie Amplify al progetto
  • Inizializzazione delle librerie Amplify al momento del runtime

Concetti chiave

CLI di Amplify: la CLI di Amplify consente di creare, gestire e rimuovere i servizi AWS direttamente dal terminale.

Librerie Amplify: le librerie di Amplify consentono di interagire con i servizi AWS da un'applicazione Web o mobile.

 Tempo richiesto per il completamento

10 minuti

 Servizi utilizzati

Implementazione

  • Installazione della CLI di Amplify

    L'interfaccia a riga di comando (CLI) di AWS Amplify dipende da Node.js, fai riferimento alla sezione dei prerequisiti nell'introduzione per installare Node.js

    Per installare l'interfaccia a riga di comando (CLI) di AWS Amplify, apri un terminale e digita il seguente 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
  • Inizializzazione di un back-end Amplify

    Per creare la struttura di base del nostro back-end, è innanzitutto necessario inizializzare la directory del progetto Amplify e creare il back-end del cloud.

    Apri un terminale e passa alla directory del progetto. Ad esempio, se hai creato il progetto nella cartella ~/AndroidStudioProjects/android-getting-started, puoi digitare:

    cd ~/AndroidStudioProjects/android-getting-started  

    Verifica di trovarti nella directory corretta, che dovrebbe avere il seguente aspetto:

    ➜  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

    Inizializza la struttura del progetto e il file di configurazione Amplify. Esegui il seguente 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 ancora non disponi di un profilo, puoi crearne uno utilizzando l'interfaccia a riga di comando (CLI) AWS tramite AWS configure (Configurazione AWS) --profile (Profilo) <nome>.

    Amplify inizializza il progetto nel cloud, questa operazione potrebbe richiedere qualche minuto. Dopo alcuni minuti, dovresti visualizzare un messaggio simile:

    ✔ 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!
  • Aggiunta di librerie Amplify al progetto

    Amplify per Android è distribuito sotto forma di pacchetti Apache Maven. In questa sezione, aggiungeremo i pacchetti e altre direttive obbligatorie alla configurazione della tua build.

    Torna in Android Studio, espandi Gradle Scripts (Script Gradle) e apri build.gradle (Project: Android_Getting_Started). Aggiungi la riga mavenCentral() all'interno del blocco di repository nei blocchi 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()
        }
    }

    In Gradle Scripts (Script Gradle), apri build.gradle (Module:app) e aggiungi la dipendenza principale del framework Amplify nel blocco delle implementazioni.

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

    Se sviluppi in Java o Android SDK 21 target o versioni precedenti, controlla la documentazione per ulteriori modifiche alla configurazione.

    Ora esegui Gradle Sync (Sincronizzazione Gradle).

    AndroidAppTutorial_Modiule2_Image1

    Dopo qualche istante, dovresti visualizzare quanto segue

    BUILD SUCCESSFUL in 1s
  • Inizializzazione di Amplify al momento del runtime

    Creiamo una classe di back-end per raggruppare il codice per l'interazione con il back-end. Utilizzo un singolo modello di progettazione in modo che sia facilmente disponibile in tutta l'applicazione e per assicurare che le librerie Amplify vengano inizializzate solo una volta.

    L'inizializzatore di classe si occupa di inizializzare le librerie Amplify.

    In java/com.example.androidgettingstarted, crea un nuovo file kotlin Backend.kt, aprilo e aggiungi questo codice:

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

    All'avvio dell'applicazione, il singolo oggetto di back-end verrà inizializzato.

    In java/com.example.androidgettingstarted, crea un nuovo file kotlin Application.kt, aprilo e aggiungi questo codice:

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

    Sotto manifests, apri AndroidManifest.xml e aggiungi il nome della classe dell'applicazione all'elemento <applicazione>.

        <!-- 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">
    ...

    Con questo file aperto, aggiungi un paio di autorizzazioni che l'applicazione richiederà nei passaggi successivi di questo 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"/>
  • Verifica della configurazione

    Per verificare che tutto funzioni come previsto, crea ed esegui il progetto. Fai clic sull'icona Run (Esegui) ▶️ nella barra degli strumenti o digita ^ R.

    Per verificare che tutto funzioni come previsto, crea ed esegui il progetto. Fai clic sull'icona Run (Esegui)   ▶️  nella barra degli strumenti o digita ^ R.
    AndroidAppTutorial_Modiule2_Image2

    Non dovrebbero essere restituiti errori.

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

Conclusione

Hai inizializzato il progetto Amplify e sei pronto per iniziare ad aggiungervi delle funzionalità. Nel prossimo modulo, aggiungeremo un intero flusso di autenticazione utente usando poche righe di codice.

Questo modulo è stato utile?

Grazie
Facci sapere cosa ti è piaciuto.
Chiudi
Spiacenti di non esserti stati d'aiuto
C'è qualcosa di obsoleto, ambiguo o approssimativo? Aiutaci a migliorare questo tutorial con il tuo feedback.
Chiudi

Aggiungi autenticazione