Android Tutorial
Erste Schritte mit Android

Bemerkungen

Versionen

Android Studio einrichten

Android Studio ist die Android-Entwicklungs-IDE, die von Google offiziell unterstützt und empfohlen wird. Android Studio wird mit dem Android SDK Manager geliefert , einem Tool zum Herunterladen der Android SDK Komponenten, die zum Starten der Entwicklung von Apps erforderlich sind.

Installieren von Android Studio- und Android SDK Tools:

1. Laden Sie Android Studio herunter und installieren Sie es.
2. Laden Sie die neuesten SDK Tools und SDK Platform-Tools herunter, indem Sie das Android Studio öffnen und dann den Anweisungen zum Android SDK Tool Updates folgen. Sie sollten die neuesten verfügbaren stabilen Pakete installieren.

Wenn Sie an alten Projekten arbeiten müssen, die mit älteren SDK-Versionen erstellt wurden, müssen Sie möglicherweise auch diese Versionen herunterladen

Seit Android Studio 2.2 ist eine Kopie des neuesten OpenJDK im Lieferumfang der Installation enthalten. Es ist das empfohlene JDK (Java Development Kit) für alle Android Studio-Projekte. Dadurch entfällt die Notwendigkeit, dass das JDK-Paket von Oracle installiert ist. Um das mitgelieferte SDK zu verwenden, gehen Sie wie folgt vor:

1. Öffnen Sie Ihr Projekt in Android Studio und wählen Sie in der Menüleiste Datei> Projektstruktur aus .
2. Aktivieren Sie auf der Seite SDK Location und unter JDK Location das Kontrollkästchen Embedded JDK verwenden .
3. Klicken Sie auf OK .

Konfigurieren Sie Android Studio

Android Studio bietet über das Hilfe- Menü Zugriff auf zwei Konfigurationsdateien:

• studio.vmoptions : Passen Sie die Optionen für die Java Virtual Machine (JVM) von Studio an, z. B. Heapgröße und Cache-Größe. Beachten Sie, dass diese Datei auf Linux-Computern je nach Ihrer Version von Android Studio möglicherweise als studio64.vmoptions bezeichnet wird.
• idea.properties : Anpassen der Android Studio-Eigenschaften, z. B. des Ordnerpfad des Plugins oder der maximal unterstützten Dateigröße.

Thema ändern / hinzufügen

Sie können es nach Belieben ändern. File->Settings->Editor->Colors & Fonts-> und wählen Sie ein Thema aus. Sie können auch neue Themen von http://color-themes.com/ herunterladen. Wenn Sie die .jar.zip Datei heruntergeladen haben, gehen Sie zu File -> Import Settings... und wählen Sie die heruntergeladene Datei.

Apps kompilieren

Erstellen Sie ein neues Projekt oder öffnen Sie ein vorhandenes Projekt in Android Studio und drücken Sie die grüne Wiedergabetaste auf der oberen Symbolleiste, um es auszuführen. Wenn es grau ist, müssen Sie eine Sekunde warten, damit Android Studio einige Dateien ordnungsgemäß indizieren kann, deren Fortschritt in der unteren Statusleiste angezeigt wird.

Wenn Sie ein Projekt von der Shell aus erstellen möchten, stellen Sie sicher, dass Sie über die Datei local.properties verfügen, die automatisch von Android Studio erstellt wird. Wenn Sie das Projekt ohne Android Studio erstellen müssen, benötigen Sie eine Zeile, die mit sdk.dir= gefolgt vom Pfad zu Ihrer SDK-Installation.

Öffnen Sie eine Shell und gehen Sie in das Projektverzeichnis. Geben Sie ./gradlew aR und drücken Sie die Eingabetaste. aR ist eine Abkürzung für assembleRelease , die alle Abhängigkeiten für Sie herunterlädt und die App erstellt. Die endgültige APK-Datei befindet sich in ProjectName/ModuleName/build/outputs/apk und heißt ModuleName-release.apk .

Ein neues Projekt erstellen

Android Studio einrichten

Beginnen Sie mit dem Einrichten von Android Studio und öffnen Sie es. Jetzt können Sie Ihre erste Android-App erstellen!

Hinweis: Dieses Handbuch basiert auf Android Studio 2.2, der Prozess in anderen Versionen ist jedoch im Wesentlichen derselbe.

Konfigurieren Sie Ihr Projekt

Grundlegende Einstellung

Sie können ein neues Projekt auf zwei Arten starten:

• Klicken Start a New Android Studio Project im Begrüßungsbildschirm auf Start a New Android Studio Project .
• Navigieren Sie zu File → New Project wenn Sie bereits ein Projekt geöffnet haben.

Als Nächstes müssen Sie Ihre Bewerbung beschreiben, indem Sie einige Felder ausfüllen:

1. Anwendungsname - Dieser Name wird dem Benutzer angezeigt.

   Beispiel: Hello World . Sie können es später AndroidManifest.xml Datei AndroidManifest.xml ändern.

2. Unternehmensdomäne - Dies ist das Qualifikationsmerkmal für den Paketnamen Ihres Projekts.

   Beispiel: stackoverflow.com .

3. Paketname (aka applicationId ) - Dies ist die vollständig qualifizierten Projektpaketnamen.

   Es sollte Reverse Domain Name Notation (auch Reverse DNS genannt ) folgen: Top Level Domain . Unternehmensdomäne. [ Unternehmenssegment . ] Anwendungsname .

   Beispiel: com.stackoverflow.android.helloworld oder com.stackoverflow.helloworld . Sie können Ihre applicationId jederzeit ändern, indem Sie sie in Ihrer Gradle-Datei überschreiben .

Verwenden Sie nicht das Standardpräfix "com.example", es sei denn, Sie möchten Ihre Bewerbung nicht im Google Play Store einreichen. Der Paketname ist Ihre eindeutige applicationId in Google Play.

4. Projektspeicherort - Dies ist das Verzeichnis, in dem Ihr Projekt gespeichert wird.

Wählen Sie Formfaktoren und API-Ebene aus

Im nächsten Fenster können Sie die von Ihrer App unterstützten Formfaktoren auswählen, z. B. Telefon, Tablet, TV, Wear und Google Glass. Die ausgewählten Formfaktoren werden zu den App-Modulen im Projekt. Für jeden Formfaktor können Sie auch die API-Ebene für diese App auswählen. Um weitere Informationen zu erhalten, klicken Sie auf Hilfe bei der Auswahl

Diagramm der aktuellen Android-Versionen, angezeigt, wenn Sie auf "Hilfe bei der Auswahl" klicken.

Das Android Platform Distribution-Fenster zeigt die Verteilung mobiler Geräte, auf denen jede Android-Version ausgeführt wird (siehe Abbildung 2). Klicken Sie auf eine API-Ebene, um eine Liste der Funktionen anzuzeigen, die in der entsprechenden Android-Version eingeführt wurden. Auf diese Weise können Sie den Mindest-API-Level auswählen, der alle Funktionen enthält, die Ihre Apps benötigen, sodass Sie so viele Geräte wie möglich erreichen können. Klicken Sie dann auf OK .

Wählen Sie nun aus, welche Plattformen und welche Version von Android SDK die Anwendung unterstützt.

Wählen Sie zunächst nur Telefon und Tablet aus .

Das Minimum-SDK ist die Untergrenze für Ihre App. Dies ist eines der Signale, die der Google Play Store verwendet, um festzustellen, auf welchen Geräten eine App installiert werden kann. Die App von Stack Exchange unterstützt beispielsweise Android 4.1 und höher.

Android Studio teilt Ihnen (ungefähr) mit, wie viel Prozent der Geräte mit dem angegebenen Mindest-SDK unterstützt werden.

Niedrigere API-Level zielen auf mehr Geräte ab, verfügen jedoch über weniger verfügbare Funktionen.

Bei der Entscheidung für das Minimum-SDK sollten Sie die Dashboards-Statistiken in Betracht ziehen, die Ihnen Versionsinformationen zu den Geräten geben, die den Google Play Store in der letzten Woche weltweit besucht haben.

Von: Dashboards auf der Android Developer-Website.

Aktivität hinzufügen

Jetzt werden wir eine Standardaktivität für unsere Anwendung auswählen. In Android ist eine Activity ein einzelner Bildschirm, der dem Benutzer angezeigt wird. Eine Anwendung kann mehrere Aktivitäten enthalten und zwischen diesen navigieren. Wählen Sie für dieses Beispiel Empty Activity und klicken Sie auf Weiter.

Wenn Sie möchten, können Sie hier den Namen der Aktivität und des Layouts ändern. Es empfiehlt sich, Activity als Suffix für den Aktivitätsnamen und activity_ als Präfix für den Layoutnamen beizubehalten. Wenn wir diese Standardeinstellungen MainActivity , generiert Android Studio eine Aktivität mit dem Namen MainActivity und eine Layoutdatei mit dem Namen activity_main . Klicken Sie jetzt auf Finish .

Android Studio erstellt und konfiguriert unser Projekt, das je nach System einige Zeit dauern kann.

Inspektion des Projekts

Um zu verstehen, wie Android funktioniert, werfen wir einen Blick auf einige der Dateien, die für uns erstellt wurden.

Im linken Bereich von Android Studio sehen wir die Struktur unserer Android-Anwendung .

Zuerst öffnen AndroidManifest.xml mit einem Doppelklick. Die Android-Manifestdatei beschreibt einige grundlegende Informationen zu einer Android-Anwendung. Es enthält die Erklärung unserer Aktivitäten sowie einige fortgeschrittenere Komponenten.

Wenn eine Anwendung Zugriff auf eine durch eine Berechtigung geschützte Funktion benötigt, muss sie erklären, dass diese Berechtigung mit einem Element <uses-permission> im Manifest erforderlich ist. Wenn die Anwendung auf dem Gerät installiert ist, bestimmt das Installationsprogramm, ob die angeforderte Berechtigung erteilt werden soll, indem die Behörden überprüft werden, die die Zertifikate der Anwendung signiert haben, und in einigen Fällen den Benutzer gefragt. Eine Anwendung kann auch ihre eigenen Komponenten (Aktivitäten, Dienste, Rundfunkempfänger und Inhaltsanbieter) mit Berechtigungen schützen. Es kann alle von Android definierten Berechtigungen verwenden (aufgeführt in android.Manifest.permission) oder von anderen Anwendungen deklariert. Oder es kann sein eigenes definieren.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.stackoverflow.helloworld">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Als nächstes öffnen wir die Datei activity_main.xml die sich in app/src/main/res/layout/ . Diese Datei enthält Deklarationen für die visuellen Komponenten unserer MainActivity. Sie sehen Visual Designer. Auf diese Weise können Sie Elemente per Drag & Drop in das ausgewählte Layout ziehen.

Sie können auch zum XML-Layout-Designer wechseln, indem Sie unten in Android Studio auf "Text" klicken.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.stackexchange.docs.helloworld.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>

In diesem Layout wird ein Widget mit dem Namen " TextView Eigenschaft " android:text " ist auf "Hello World!" TextView . Dies ist ein Textblock, der dem Benutzer beim Ausführen der Anwendung angezeigt wird.

Sie können mehr über Layouts und Attribute lesen.

Lassen Sie uns als Nächstes einen Blick auf MainActivity . Dies ist der Java-Code, der für MainActivity generiert wurde.

public class MainActivity extends AppCompatActivity {

    // The onCreate method is called when an Activity starts
    // This is where we will set up our layout
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // setContentView sets the Activity's layout to a specified XML layout
        // In our case we are using the activity_main layout
        setContentView(R.layout.activity_main);
    }
}

Wie in unserem Android-Manifest definiert, wird MainActivity standardmäßig gestartet, wenn ein Benutzer die HelloWorld App startet.

Öffnen Sie zuletzt die Datei build.gradle in app/ .
Android Studio verwendet das Build-System Gradle zum Kompilieren und Erstellen von Android-Anwendungen und -Bibliotheken.

apply plugin: 'com.android.application'

android {
signingConfigs {
         applicationName {
             keyAlias 'applicationName'
             keyPassword 'password'
             storeFile file('../key/applicationName.jks')
             storePassword 'anotherPassword'
         }
     }
    compileSdkVersion 26
    buildToolsVersion "26.0.0"

    defaultConfig {
        applicationId "com.stackexchange.docs.helloworld"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        signingConfig signingConfigs.applicationName
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:26.0.0'
}

Diese Datei enthält Informationen zum Build und zur App-Version. Sie können damit auch Abhängigkeiten zu externen Bibliotheken hinzufügen. Lassen Sie uns zunächst keine Änderungen vornehmen.

Es ist ratsam, immer die aktuellste Version auszuwählen, die für die Abhängigkeiten verfügbar ist:

• buildToolsVersion : 26.0.0
• com.android.support:appcompat-v7 : 26.0.0 (Juli 2017)
• Feuerbasis : 11.0.4 (August 2017)

compileSdkVersion

compileSdkVersion gibt Gradle an, mit welcher Version des Android SDK Ihre App kompiliert werden kann. Die Verwendung des neuen Android SDK ist eine Voraussetzung für die Verwendung einer der neuen APIs, die auf dieser Ebene hinzugefügt wurden.

Es sollte betont werden, dass das Ändern der compileSdkVersion das Laufzeitverhalten nicht ändert. Während beim Ändern Ihrer compileSdkVersion neue Warnungen / Fehler des Compilers compileSdkVersion , ist Ihre compileSdkVersion nicht in Ihrem APK enthalten: Sie wird nur zur Kompilierzeit verwendet.

Daher wird dringend empfohlen, dass Sie immer mit dem neuesten SDK kompilieren. Sie erhalten alle Vorteile der neuen Kompilierungsprüfungen für vorhandenen Code, vermeiden neu veraltete APIs und sind bereit, neue APIs zu verwenden.

minSdkVersion

Wenn compileSdkVersion die neuesten verfügbaren APIs minSdkVersion ist minSdkVersion die untere Grenze für Ihre App. Die minSdkVersion ist eines der Signale, die der Google Play Store verwendet, um festzustellen, auf welchen Geräten eines Nutzers eine App installiert werden kann.

Es spielt auch eine wichtige Rolle während der Entwicklung: Lint wird standardmäßig für Ihr Projekt ausgeführt und warnt Sie, wenn Sie APIs über Ihrer minSdkVersion . So vermeiden Sie das Laufzeitproblem beim Versuch, eine nicht vorhandene API aufzurufen. Das Überprüfen der Systemversion zur Laufzeit ist eine übliche Technik, wenn APIs nur für neuere Plattformversionen verwendet werden.

targetSdkVersion

targetSdkVersion ist die Hauptmethode, mit der Android Vorwärtskompatibilität bereitstellt, indem Verhaltensänderungen nur targetSdkVersion wenn die targetSdkVersion aktualisiert wird. Auf diese Weise können Sie neue APIs verwenden, bevor Sie die Verhaltensänderungen durcharbeiten. Die Aktualisierung auf das neueste SDK sollte für jede App eine hohe Priorität haben. Das bedeutet nicht, dass Sie jedes neu eingeführte Feature verwenden müssen oder Ihre targetSdkVersion blind targetSdkVersion ohne zu testen.

targetSDKVersion ist die Android-Version, die die Obergrenze für die verfügbaren Tools darstellt. Wenn targetSDKVersion kleiner als 23 ist, muss die App zur Laufzeit keine Berechtigungen für eine Instanz anfordern, selbst wenn die App auf API 23+ ausgeführt wird. TargetSDKVersion verhindert nicht, dass Android-Versionen oberhalb der ausgewählten Android-Version die App ausführen.

Weitere Informationen zum Gradle-Plugin finden Sie hier:

• Ein grundlegendes Beispiel
• Einführung in das Gradle-Plugin für Android und den Wrapper
• Einführung in die Konfiguration des build.gradle und der DSL-Methoden

Anwendung ausführen

Lassen Sie uns jetzt unsere HelloWorld-Anwendung ausführen. Sie können entweder ein virtuelles Android-Gerät ausführen (das Sie mit AVD Manager in Android Studio einrichten können, wie im folgenden Beispiel beschrieben) oder Ihr eigenes Android-Gerät über ein USB-Kabel anschließen.

Ein Android-Gerät einrichten

Um eine Anwendung von Android Studio auf Ihrem Android-Gerät auszuführen, müssen Sie USB Debugging in den Developer Options in den Einstellungen Ihres Geräts aktivieren.

Settings > Developer options > USB debugging

Wenn die Developer Options in den Einstellungen nicht sichtbar sind, navigieren Sie zu About Phone und tippen Sie sieben Mal auf die Build Number . Dadurch können Developer Options in Ihren Einstellungen angezeigt werden.

Settings > About phone > Build number

Möglicherweise müssen Sie auch die build.gradle Konfiguration ändern, um eine Version zu erstellen, die Ihr Gerät enthält.

Ausführen von Android Studio

Klicken Sie in der Symbolleiste oben in Android Studio auf die grüne Schaltfläche Run . Wählen Sie im daraufhin angezeigten Fenster das Gerät aus, auf dem Sie die App ausführen möchten (starten Sie ggf. ein virtuelles Android-Gerät oder lesen Sie Einrichten eines AVD (Android Virtual Device), falls Sie eines einrichten müssen), und klicken Sie auf OK .

Bei Geräten mit Android 4.4 (KitKat) und möglicherweise höher wird ein Popup-Fenster angezeigt, um das USB-Debugging zu autorisieren. Klicken Sie zur Bestätigung auf OK .

Die Anwendung wird nun auf Ihrem Android-Gerät oder Emulator installiert und ausgeführt.

APK-Dateispeicherort

Wenn Sie Ihre Anwendung für die Veröffentlichung vorbereiten, konfigurieren, erstellen und testen Sie eine Release-Version Ihrer Anwendung. Die Konfigurationsaufgaben sind unkompliziert und umfassen grundlegende Aufgaben zur Code-Bereinigung und Code-Änderung, die zur Optimierung Ihrer Anwendung beitragen. Der Build-Prozess ähnelt dem Debug-Build-Prozess und kann mit JDK- und Android-SDK-Tools ausgeführt werden. Die Testaufgaben dienen als letzte Prüfung, um sicherzustellen, dass Ihre Anwendung unter realen Bedingungen wie erwartet funktioniert. Wenn Sie mit der Vorbereitung Ihrer Anwendung für die Veröffentlichung fertig sind, haben Sie eine signierte APK-Datei, die Sie direkt an die Benutzer verteilen oder über einen Anwendungsmarktplatz wie Google Play verteilen können.

Android Studio

Da in den obigen Beispielen Gradle verwendet wird, lautet der Speicherort der generierten APK-Datei: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Wenn Sie vor dem Wechsel zu Studio IntelliJ verwenden und Ihr IntelliJ-Projekt direkt importieren, hat sich nichts geändert. Die Position der Ausgabe ist unter:

out/production/...

Hinweis: Dies wird manchmal um 1,0 veraltet

Finsternis

Wenn Sie ein Android Eclipse-Projekt direkt importieren, tun Sie dies nicht! Sobald Sie Abhängigkeiten in Ihrem Projekt haben (Jars oder Library Projects), funktioniert dies nicht und Ihr Projekt wird nicht richtig eingerichtet. Wenn Sie keine Abhängigkeiten haben, befindet sich der apk an derselben Position wie in Eclipse:

bin/...

Android-Programmierung ohne IDE

Dies ist ein minimalistisches Hello World-Beispiel , das nur die grundlegendsten Android-Tools verwendet.

Anforderungen und Annahmen

• Oracle JDK 1.7 oder höher
• Android SDK-Tools (nur die Befehlszeilen-Tools )

Dieses Beispiel setzt Linux voraus. Möglicherweise müssen Sie die Syntax für Ihre eigene Plattform anpassen.

Einrichten des Android SDK

Nach dem Auspacken der SDK-Version:

1. Installieren Sie zusätzliche Pakete mit dem SDK-Manager. Verwenden Sie kein android update sdk --no-ui wie in der mitgelieferten Readme.txt-Anweisung beschrieben. Es werden etwa 30 GB nicht benötigte Dateien heruntergeladen. Verwenden Sie stattdessen den interaktiven SDK-Manager android sdk , um das empfohlene Minimum an Paketen zu erhalten.

2. Hängen Sie die folgenden JDK- und SDK-Verzeichnisse an Ihren Ausführungspfad PATH. Dies ist optional, aber die nachfolgenden Anweisungen gehen davon aus.

   • JDK / bin
   • SDK / Plattform-Tools
   • SDK / Tools
   • SDK / Build-Tools / LATEST (wie in Schritt 1 installiert)

3. Erstellen Sie ein virtuelles Android-Gerät. Verwenden Sie den interaktiven AVD Manager ( android avd AVD). Möglicherweise müssen Sie ein wenig nachgeben und nach Rat suchen. Die Anweisungen vor Ort sind nicht immer hilfreich.

   (Sie können auch Ihr eigenes Gerät verwenden)

4. Führen Sie das Gerät aus:

   emulator -avd DEVICE
   

5. Wenn der Gerätebildschirm gesperrt zu sein scheint, streichen Sie, um ihn zu entsperren.

   Lassen Sie es laufen, während Sie die App codieren.

App kodieren

6. Wechseln Sie in ein leeres Arbeitsverzeichnis.

7. Machen Sie die Quelldatei:

   mkdir --parents src/dom/domain
   touch src/dom/domain/SayingHello.java
   

   Inhalt:

   package dom.domain;
   import android.widget.TextView;
   
   public final class SayingHello extends android.app.Activity
   {
       protected @Override void onCreate( final android.os.Bundle activityState )
       {
           super.onCreate( activityState );
           final TextView textV = new TextView( SayingHello.this );
           textV.setText( "Hello world" );
           setContentView( textV );
       }
   }
   

8. Fügen Sie ein Manifest hinzu:

   touch AndroidManifest.xml
   

   Inhalt:

   <?xml version='1.0'?>
   <manifest xmlns:a='http://schemas.android.com/apk/res/android'
    package='dom.domain' a:versionCode='0' a:versionName='0'>
       <application a:label='Saying hello'>
           <activity a:name='dom.domain.SayingHello'>
                <intent-filter>
                   <category a:name='android.intent.category.LAUNCHER'/>
                   <action a:name='android.intent.action.MAIN'/>
                   </intent-filter>
               </activity>
           </application>
       </manifest>
   

9. Erstellen Sie ein Unterverzeichnis für die deklarierten Ressourcen:

   mkdir res
   

   Lass es für jetzt leer.

Code erstellen

10. Generieren Sie die Quelle für die Ressourcendeklarationen. Ersetzen Sie hier den korrekten Pfad zu Ihrem SDK und die zu installierende API (z. B. "android-23"):

    aapt package -f \
      -I SDK/platforms/android-API/android.jar \
      -J src -m \
      -M AndroidManifest.xml -S res -v
    

    Ressourcendeklarationen (weiter unten beschrieben) sind eigentlich optional. In der Zwischenzeit macht der obige Anruf nichts, wenn res / noch leer ist.

11. Kompilieren Sie den Quellcode in Java-Bytecode (.java → .class):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
    

12. Übersetzen Sie den Bytecode von Java auf Android (.class → .dex):

    Zuerst mit Jill (.class → .jayce):

    java -jar SDK/build-tools/LATEST/jill.jar \
      --output classes.jayce src
    

    Dann Jack (.jayce → .dex):

    java -jar SDK/build-tools/LATEST/jack.jar \
      --import classes.jayce --output-dex .
    

    Android-Bytecode wurde früher als "ausführbarer Dalvik-Code" und daher als "Dex" bezeichnet.

    Sie können die Schritte 11 und 12 durch einen einzigen Anruf bei Jack ersetzen, wenn Sie möchten. Es kann direkt aus Java-Quellen kompiliert werden (.java → .dex). Das Kompilieren mit javac bietet jedoch Vorteile. Es ist ein bekanntes, besser dokumentiertes und umfassender anwendbares Werkzeug.

13. Packen Sie die Ressourcendateien einschließlich des Manifests zusammen:

    aapt package -f \
      -F app.apkPart \
      -I SDK/platforms/android-API/android.jar \
      -M AndroidManifest.xml -S res -v
    

    Dies führt zu einer teilweisen APK-Datei (Android-Anwendungspaket).

14. ApkBuilder Sie den vollständigen APK mit dem ApkBuilder Tool:

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain \
      app.apkUnalign \
      -d -f classes.dex -v -z app.apkPart
    

    Es warnt: "DIESES WERKZEUG IST ABGESCHRIEBEN. Weitere Informationen finden Sie unter --help." Wenn --help mit einer ArrayIndexOutOfBoundsException , übergeben Sie stattdessen keine Argumente:

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain
    

    Es erklärt, dass die CLI ( ApkBuilderMain ) zugunsten des direkten Aufrufs der Java-API ( ApkBuilder ) ApkBuilder . (Wenn Sie wissen, wie Sie dies über die Befehlszeile tun, aktualisieren Sie bitte dieses Beispiel.)

15. Optimieren Sie die Datenanpassung der APK ( empfohlene Vorgehensweise ):

    zipalign -f -v 4 app.apkUnalign app.apk
    

Installieren und ausführen

16. Installieren Sie die App auf dem Android-Gerät:

    adb install -r app.apk
    

17. Starten Sie die App:

    adb shell am start -n dom.domain/.SayingHello
    

    Es sollte laufen und Hallo sagen.

Das ist alles. Das ist es, was man braucht, um mit den grundlegenden Android-Tools Hallo zu sagen.

Ressource deklarieren

Dieser Abschnitt ist optional. Für eine einfache "Hallo Welt" -App sind keine Ressourcendeklarationen erforderlich. Wenn sie für Ihre App auch nicht erforderlich sind, können Sie den Build etwas rationalisieren, indem Sie Schritt 10 auslassen und den Verweis auf das Verzeichnis res / aus Schritt 13 entfernen.

Ansonsten finden Sie hier ein kurzes Beispiel, wie Sie eine Ressource deklarieren und darauf verweisen können.

18. Fügen Sie eine Ressourcendatei hinzu:

    mkdir res/values
    touch res/values/values.xml
    

    Inhalt:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
    

19. Verweisen Sie auf die Ressource aus dem XML-Manifest. Dies ist ein deklarativer Referenzstil:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
    

20. Verweisen Sie auf dieselbe Ressource aus der Java-Quelle. Dies ist ein zwingender Hinweis:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
    

21. Testen Sie die obigen Änderungen, indem Sie die App neu erstellen, erneut installieren und erneut ausführen (Schritte 10-17).

    Es sollte neu starten und sagen: "Diese App heißt Hallo sagen".

Deinstallation der App

adb uninstall dom.domain

Siehe auch

• ursprüngliche Frage - Die ursprüngliche Frage, die zu diesem Beispiel geführt hat
• Arbeitsbeispiel - Ein funktionierendes Build-Skript, das die obigen Befehle verwendet

Anwendungsgrundlagen

Android Apps sind in Java geschrieben. Die Android SDK-Tools kompilieren die Code-, Daten- und Ressourcendateien in einem APK (Android-Paket). Im Allgemeinen enthält eine APK-Datei den gesamten Inhalt der App.

Jede App wird auf einer eigenen virtuellen Maschine (VM) ausgeführt, sodass die App getrennt von anderen Apps ausgeführt werden kann. Das Android-System arbeitet mit dem Prinzip des geringsten Privilegs. Jede App hat nur Zugriff auf die Komponenten, die sie für ihre Arbeit benötigt, und nicht mehr. Es gibt jedoch Möglichkeiten für eine App, Daten mit anderen Apps gemeinsam zu nutzen, z. B. durch die gemeinsame Nutzung der Linux-Benutzer-ID zwischen Apps, oder Apps können die Berechtigung zum Zugriff auf Gerätedaten wie SD-Karte, Kontakte usw. anfordern.

App-Komponenten

App-Komponenten sind die Bausteine ​​einer Android-App. Jede Komponente spielt eine bestimmte Rolle in einer Android-App, die einem bestimmten Zweck dient und unterschiedliche Lebenszyklen hat (der Fluss, wie und wann die Komponente erstellt und zerstört wird). Hier sind die vier Arten von App-Komponenten:

1. Aktivitäten: Eine Aktivität repräsentiert einen einzelnen Bildschirm mit einer Benutzeroberfläche (UI). Eine Android-App kann mehrere Aktivitäten haben. (Eine E-Mail-App kann beispielsweise eine Aktivität enthalten, um alle E-Mails aufzulisten, eine andere, um den Inhalt jeder E-Mail anzuzeigen, und eine andere, um neue E-Mail zu erstellen.) Alle Aktivitäten in einer App arbeiten zusammen, um ein User eXperience (UX) zu erstellen.
2. Dienste: Ein Dienst wird im Hintergrund ausgeführt, um lange andauernde Vorgänge auszuführen oder um Arbeit für Remote-Prozesse auszuführen. Ein Dienst stellt keine Benutzeroberfläche bereit, er wird nur im Hintergrund mit der Eingabe des Benutzers ausgeführt. (Ein Dienst kann beispielsweise Musik im Hintergrund abspielen, während sich der Benutzer in einer anderen App befindet, oder er kann Daten aus dem Internet herunterladen, ohne die Interaktion des Benutzers mit dem Android-Gerät zu blockieren.)
3. Inhaltsanbieter: Ein Inhaltsanbieter verwaltet freigegebene Anwendungsdaten. Es gibt vier Möglichkeiten, Daten in einer App zu speichern: Sie können Daten in eine Datei schreiben und im Dateisystem speichern, in eine SQLite-Datenbank einfügen oder aktualisieren, im Web bereitstellen oder an einem anderen dauerhaften Speicherort speichern, auf den die App zugreifen kann . Über Content Provider können andere Apps die Daten abfragen oder sogar ändern. (Ein Android-System stellt beispielsweise einen Inhaltsanbieter bereit, der die Kontaktinformationen des Benutzers verwaltet, sodass jede Anwendung, die über eine Berechtigung verfügt, die Kontakte abfragen kann.) Inhaltsanbieter können auch zum Speichern der für die Anwendung privaten Daten verwendet werden, um die Datenintegrität zu verbessern.
4. Rundfunkempfänger: Ein Rundfunkempfänger reagiert auf systemweite Rundsendungen von Ansagen (z. B. eine Sendung, die besagt, dass der Bildschirm ausgeschaltet ist, der Akku schwach ist usw.) oder von Apps (z. B., um andere Apps mitzuteilen, dass einige Daten vorhanden sind auf das Gerät heruntergeladen werden und steht ihnen zur Verfügung). Broadcast-Empfänger haben keine Benutzeroberflächen, aber sie können eine Benachrichtigung in der Statusleiste anzeigen, um den Benutzer zu warnen. Normalerweise werden Rundfunkempfänger als Gateway zu anderen Komponenten der App verwendet, die hauptsächlich aus Aktivitäten und Diensten bestehen.

Ein einzigartiger Aspekt des Android-Systems ist, dass jede App eine Komponente einer anderen App starten kann (z. B. wenn Sie einen Anruf tätigen, SMS senden, eine Webseite öffnen oder ein Foto anzeigen möchten, gibt es eine App, die dies bereits tut, und Ihre App kann dies.) nutzen Sie es, anstatt eine neue Aktivität für dieselbe Aufgabe zu entwickeln).

Wenn das System eine Komponente startet, startet es den Prozess für diese App (wenn sie noch nicht ausgeführt wird, dh auf einem Android-System kann zu jeder Zeit nur ein Vordergrundprozess pro App ausgeführt werden) und instanziiert die für diese Komponente erforderlichen Klassen. Somit läuft die Komponente auf dem Prozess der App, zu der sie gehört. Im Gegensatz zu Apps auf anderen Systemen verfügen Android-Apps daher nicht über einen einzigen Einstiegspunkt (es gibt keine main() -Methode).

Da das System jede App in einem separaten Prozess ausführt, kann eine App die Komponenten einer anderen App nicht direkt aktivieren. Dies kann jedoch das Android-System tun. Um eine andere App-Komponente zu starten, muss eine App eine Nachricht an das System senden, die die Absicht angibt, diese Komponente zu starten. Anschließend startet das System diese Komponente.

Kontext

Instanzen der Klasse android.content.Context stellen die Verbindung zum Android-System android.content.Context , das die Anwendung ausführt. Die Kontextinstanz ist erforderlich, um Zugriff auf die Ressourcen des Projekts und die globalen Informationen zur Umgebung der App zu erhalten.

Lassen Sie uns ein leicht verdauliches Beispiel haben: Stellen Sie sich vor, Sie sind in einem Hotel und möchten etwas essen. Sie rufen den Zimmerservice an und bitten sie, Ihnen Dinge zu bringen oder Dinge für Sie aufzuräumen. Stellen Sie sich dieses Hotel nun als eine Android-App vor, sich selbst als eine Aktivität, und der Zimmerservice-Mitarbeiter ist dann Ihr Kontext, der Ihnen Zugriff auf die Hotelressourcen wie Zimmerservice, Lebensmittel usw. bietet.

Noch ein anderes Beispiel: Sie sitzen in einem Restaurant auf einem Tisch, jeder Tisch hat einen Begleiter. Wenn Sie Lebensmittel bestellen möchten, bitten Sie den Begleiter, dies zu tun. Der Betreuer gibt dann Ihre Bestellung auf und Ihre Lebensmittel werden auf Ihrem Tisch serviert. Auch in diesem Beispiel handelt es sich bei dem Restaurant um eine Android-App, die Tische oder die Kunden sind App-Komponenten, die Lebensmittel sind Ihre App-Ressourcen und die Telefonzentrale ist Ihr Kontext, sodass Sie auf Ressourcen wie Lebensmittel zugreifen können.

Die Aktivierung einer der oben genannten Komponenten erfordert die Instanz des Kontexts. Nicht nur das oben Genannte, sondern fast jede Systemressource: Erstellen der Benutzeroberfläche mithilfe von Ansichten (wird später erläutert), Erstellen von Instanzen von Systemdiensten, Starten neuer Aktivitäten oder Dienste - alles erfordert Kontext.

Eine ausführlichere Beschreibung wird hier geschrieben.

Einrichten einer AVD (Android Virtual Device)

TL; DR Damit können wir echte Geräte simulieren und unsere Apps ohne echtes Gerät testen.

Laut der Android-Entwicklerdokumentation

Mit einer Definition für ein virtuelles Android-Gerät (AVD) können Sie die Merkmale eines Android-Telefons, Tablets, Android Wear oder Android TV-Geräts definieren, die Sie im Android-Emulator simulieren möchten. Mit dem AVD Manager können Sie AVDs problemlos erstellen und verwalten.

Führen Sie die folgenden Schritte aus, um eine AVD einzurichten:

1. Klicken Sie auf diese Schaltfläche, um den AVD Manager aufzurufen:

2. Sie sollten einen Dialog wie diesen sehen:

3. Klicken + Create Virtual Device... nun auf die Schaltfläche + Create Virtual Device... Dies öffnet den Konfigurationsdialog für virtuelle Geräte:

4. Wählen Sie ein beliebiges Gerät aus und klicken Sie auf Next :

5. Hier müssen Sie eine Android-Version für Ihren Emulator auswählen. Möglicherweise müssen Sie es auch zuerst herunterladen, indem Sie auf Download klicken. Nachdem Sie eine Version ausgewählt haben, klicken Sie auf Next .

6. Geben Sie hier einen Namen für Ihren Emulator ein, die anfängliche Ausrichtung und ob Sie einen Rahmen darum anzeigen möchten. Nachdem Sie alle ausgewählt haben, klicken Sie auf Finish .

7. Jetzt haben Sie eine neue AVD zum Starten Ihrer Apps bereit.