Erste Schritte mit AWS

Erstellen einer Android-Anwendung

Erstellen einer einfachen Android-Anwendung mit AWS Amplify

Modul 2: Amplify starten

In diesem Modul werden Sie die Amplify CLI installieren und konfigurieren.

Einführung

Nachdem wir nun eine Android-Anwendung erstellt haben, wollen wir die Entwicklung fortsetzen und neue Funktionen hinzufügen.

Um mit der Verwendung von AWS Amplify in Ihrer Anwendung zu beginnen, müssen Sie die Amplify-Befehlszeile installieren, das Amplify-Projektverzeichnis initialisieren, Ihr Projekt für die Verwendung der Amplify-Bibliotheken konfigurieren und die Amplify-Bibliotheken zur Laufzeit initialisieren.

Lerninhalte

  • Initialisierung eines neuen Amplify-Projekts
  • Amplify-Bibliotheken zu Ihrem Projekt hinzufügen
  • Initialisieren von Amplify-Bibliotheken zur Laufzeit

Wichtige Konzepte

Amplify CLI – Mit der Amplify CLI können Sie AWS-Services direkt von Ihrem Terminal aus erstellen, verwalten und entfernen.

Amplify-Bibliotheken – Die Amplify-Bibliotheken ermöglichen Ihnen die Interaktion mit AWS-Services über eine Web- oder mobile Anwendung.

 Veranschlagte Zeit

10 Minuten

 Verwendete Services

Implementierung

  • Installieren der Amplify CLI

    AWS Amplify CLI hängt von Node.js ab, siehe Abschnitt "Voraussetzungen" in der Einführung zur Installation von Node.js

    Um AWS Amplify CLI zu installieren, öffnen Sie ein Terminal und geben Sie den folgenden Befehl ein:

    ## Install Amplify CLI
    npm install -g @aws-amplify/cli
    
    ## Verify installation and version
    amplify --version
    # Scanning for plugins...
    # Plugin scan successful
    # 4.29.4
  • Initialisieren eines Amplify Backends

    Um die Grundstruktur unseres Backends zu erstellen, müssen wir zunächst das Amplify Backend initialisieren und unser Cloud Backend erstellen.

    Öffnen Sie ein Terminal und wechseln Sie in das Verzeichnis Ihres Projekts. Wenn Sie Ihr Projekt beispielsweise im Ordner ~/AndroidStudioProjects/android-getting-started erstellt haben, können Sie eingeben:

    cd ~/AndroidStudioProjects/android-getting-started  

    Vergewissern Sie sich, dass Sie sich im richtigen Verzeichnis befinden, es sollte wie folgt aussehen:

    ➜  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

    Initialisieren Sie die Projektstruktur und Konfigurationsdatei von Amplify. Führen Sie den folgenden Befehl aus:

    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.

    Sie können ein Profil mit AWS CLI unter Verwendung von aws configure --profile <name> erstellen, falls Sie noch kein Profil haben.

    Amplify initiiert Ihr Projekt in der Cloud, es kann einige Minuten dauern. Nach ein paar Minuten sollten Sie eine Nachricht sehen, wie:

    ✔ 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!
  • Amplify-Bibliotheken zu Ihrem Projekt hinzufügen

    Amplify für Android wird als Apache Maven-Pakete verteilt. In diesem Abschnitt werden Sie die Pakete und andere erforderliche Direktiven zu Ihrer Build-Konfiguration hinzufügen.

    Zurück zu Android Studio, erweitern Sie Gradle Scripts und öffnen Sie build.gradle (Projekt: Android_Getting_Started). Fügen Sie die Zeile mavenCentral() innerhalb des Repositories-Blocks in den Buildscript- und Allprojects-Blöcken hinzu.

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

    Öffnen Sie unter Gradle Scripts build.gradle (Modul:Anwendung) und fügen Sie im Implementierungsblock die Kernabhängigkeit des Amplify-Frameworks hinzu.

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

    Sollten Sie Apps in Java entwickeln oder auf Android SDK 21 oder früher zielen, überprüfen Sie bitte die Dokumentation auf zusätzliche Konfigurationsänderungen.

    Führen Sie jetzt Gradle Sync aus.

    AndroidAppTutorial_Modiule2_Image1

    Nach einer Weile sollten Sie Folgendes sehen:

    BUILD SUCCESSFUL in 1s
  • Starten Sie Amplify zur Laufzeit

    Lassen Sie uns eine Backend-Klasse erstellen, um den Code für die Interaktion mit unserem Backend zu gruppieren. Ich verwende ein Singleton-Designmuster, um es durch die Anwendung leicht verfügbar zu machen und um sicherzustellen, dass die Amplify-Bibliotheken nur einmal initialisiert werden.

    Der Klasseninitialisierer kümmert sich um die Initialisierung der Amplify-Bibliotheken.

    Erstellen Sie unter java/com.example.androidgettingstarted eine neue Kotlin-Datei Backend.kt, öffnen Sie sie und fügen Sie diesen Code hinzu:

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

    Wir initialisieren unser Singleton-Backend-Objekt, wenn die Anwendung gestartet wird.

    Erstellen Sie unter java/com.example.androidgettingstarted eine neue Kotlin-Datei Application.kt, öffnen Sie sie und fügen Sie diesen Code hinzu:

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

    Öffnen Sie unter Manifeste die Datei AndroidManifest.xml und fügen Sie den Namen der Anwendungsklasse zum Element <application> hinzu.

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

    Während Sie diese Datei geöffnet haben, fügen Sie ein paar Berechtigungen hinzu, die die Anwendung in späteren Schritten dieses Tutorials benötigt:

        <!-- 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"/>
  • Überprüfen Sie Ihr Setup

    Um zu überprüfen, ob alles wie erwartet funktioniert, bauen und betreiben Sie das Projekt. Klicken Sie auf das Symbol Ausführen ▶️ in der Symbolleiste oder geben Sie ^ R ein.

    Um zu überprüfen, ob alles wie erwartet funktioniert, erstellen und führen Sie das Projekt aus. Klicken Sie auf das Symbol  Ausführen   ▶️  in der Symbolleiste oder geben Sie  ^ R ein.
    AndroidAppTutorial_Modiule2_Image2

    Es sollte kein Fehler vorliegen.

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

Fazit

Sie haben das Amplify-Projekt initialisiert und sind nun bereit, mit dem Hinzufügen von Funktionen zu beginnen! Im nächsten Modul fügen wir einen kompletten Benutzerauthentifizierungsfluss mit nur wenigen Codezeilen hinzu.

War das Modul hilfreich?

Vielen Dank
Bitte teilen Sie uns mit, was Ihnen gefallen hat.
Schließen
Es tut uns Leid Sie zu enttäuschen
Ist etwas veraltet, verwirrend oder ungenau? Bitte helfen Sie uns, dieses Tutorial zu verbessern, indem Sie Feedback geben.
Schließen

Authentifizierung hinzufügen