Android Eclipse: Entwicklung mit dem Android SDK

2022-10-29

In diesem Tutorial lernen Sie, wie Sie mit der Entwicklung für Android beginnen, nämlich mit der Entwicklung von mobilen Anwendungen auf der Android Eclipse Plattform + SDK. Heute gibt es viele Ansätze für die Entwicklung und Erstellung mobiler Anwendungen für Android. Hochentwickelte Hardware-Geräte, Tablets und verschiedene Software-Plattformen (Symbian OS, iOS, WebOS, Windows Phone 7...) bieten einen endlosen Raum für Entwickler.

Die Liste der Anwendungen, mit denen man mit der Entwicklung von mobilen Anwendungen für Android beginnen kann, ist also lang. Welche Plattform soll ich wählen? Welche Programmiersprache soll ich lernen? Welche Anwendungen sind für die Projektplanung zu wählen? In diesem Leitfaden erfahren Sie, wie Sie mit der Entwicklung mobiler Anwendungen für die Android-Plattform, das offene mobile Betriebssystem von Google, beginnen.

Warum Android?

Android ist eine offene Plattform, die auf dem Linux-Kernel basiert. Es ist auf Tausenden von Geräten verschiedenster Hersteller installiert. Android bietet Anwendungen für jede Art von Hardware, die auf den heutigen mobilen Geräten vorstellbar ist - digitale Kompasse, Videokameras, GPS, Sensoren und mehr.

Mit kostenlosen Android-Entwicklungstools können Sie schnell mit der Erstellung von kostenlosen oder fast kostenlosen Anwendungen beginnen. Wenn Sie bereit sind, Ihre App der Welt zu zeigen, können Sie sie über Android Market veröffentlichen. Die Veröffentlichung im Android Market erfordert eine einmalige Registrierungsgebühr (zum Zeitpunkt der Erstellung dieses Artikels 25 US-Dollar). Im Gegensatz zum App Store von Apple (der sehr strenge Anforderungen an die Kodierung stellt) kann Ihre App nach einer kurzen Überprüfung heruntergeladen und gekauft werden - sofern sie nicht gegen die Regeln und Gesetze verstößt.

Ein paar weitere Unterschiede des Android SDK bieten Ihnen als Entwickler Vorteile:

• Das Android SDK ist für Windows, Mac und Linux verfügbar, so dass Sie nicht für neue Hardware bezahlen müssen, um Anwendungen zu schreiben.
• SDK integriert Java. Wenn Sie mit der Programmiersprache Java vertraut sind, haben Sie bereits die Hälfte des Weges hinter sich.
• Mit der Verteilung über den Android Market ist die App für Hunderttausende von Nutzern gleichzeitig verfügbar. Sie sind nicht auf den offiziellen Markt beschränkt, da es Alternativen gibt. Sie können die App zum Beispiel in Ihrem Blog veröffentlichen. Gerüchten zufolge bereitet Amazon einen eigenen Android-App-Shop vor.
• Neben der technischen SDK-Dokumentation werden auch neue Ressourcen für Android-Entwickler erstellt. Die Plattform erfreut sich zunehmender Beliebtheit bei Anwendern und Entwicklern.

Lassen Sie uns aufhören zu reden und mit der Entwicklung von Android-Anwendungen beginnen!

Installation von Eclipse und dem Android SDK

Die empfohlene Umgebung für die Entwicklung von Android-Anwendungen ist Eclipse mit dem installierten Android Development Toolkit (ADT) Plugin. Ich werde es weiter beschreiben.

• Laden Sie das Android SDK für Ihre Plattform (Windows, Mac OS X oder Linux) herunter.
• Laden Sie die heruntergeladenen Dateien an einen beliebigen Speicherort auf Ihrer Festplatte herunter (unter Linux halte ich mich an den Pfad /opt/local/).
• Wenn Eclipse bereits installiert ist, laden Sie das Paket Eclipse IDE for Java Developers herunter und installieren es. Für die Programmierung empfiehlt Google Eclipse 3.5 (Galileo).
• Starten Sie Eclipse und wählen Sie Hilfe->Neue Software installieren.
• Klicken Sie im Fenster Verfügbare Software auf Hinzufügen.
• Geben Sie Android Development Tools in das Feld Name und //dl-ssl.google.com/android/eclipse/ in das Feld Standort ein.
• Drücken Sie OK und markieren Sie Developer Tools in der Liste der verfügbaren Software. Dadurch werden die Android-Entwicklungstools und das DDMS, das Debugging-Tool für Android, installiert.
• Klicken Sie auf Weiter und Fertigstellen, um das Plugin zu installieren. Nach der Installation müssen Sie Eclipse einmal neu starten.
• Nach dem Neustart von Eclipse wählen Sie Window->Preferences und Sie sollten Android in der Kategorienliste sehen.
• Nun müssen Sie Eclipse mitteilen, wo sich das Android SDK befindet. Klicken Sie auf Android und dann auf Durchsuchen, um den Speicherort der entpackten SDK-Dateien auszuwählen. Zum Beispiel /opt/local/android-sdk.

  

• Klicken Sie auf OK, damit Eclipse sich den SDK-Speicherort merkt.

Organisieren Sie Ihre Android-Plattform während der Entwicklung

Bevor Sie mit dem Schreiben von Android-Anwendungen beginnen, sollten Sie das SDK für die Android-Plattform herunterladen. Jede Plattform hat ihre eigene Version des Android-SDK, die auf den Geräten der Nutzer installiert wird. Für Android 1.5 und höher gibt es zwei Plattformen: Das Android Open Source Project und Google.

Android Open Source Project ist eine Open-Source-Plattform, enthält aber keine Google-Erweiterungen wie Google Maps. Wenn Sie die Google API nicht verwenden möchten, steht die Google Maps-Funktionalität für Ihre App nicht zur Verfügung. Wenn Sie keinen besonderen Grund dafür haben, empfehle ich Ihnen, das Targeting auf einer der Google-Plattformen einzurichten, da Sie dann die Google-eigenen Erweiterungen verwenden können.

• Wählen Sie Window->Android SDK und AVD Manager.
• Klicken Sie in der linken Spalte auf Verfügbare Pakete und überprüfen Sie das Repository, um die verfügbaren Android-Plattformen anzuzeigen.
• Sie können Plattformen zum Herunterladen aus der Liste auswählen oder alle Kontrollkästchen aktiviert lassen, um alle verfügbaren Plattformen herunterzuladen. Wenn Sie fertig sind, klicken Sie auf "Install Selected" und folgen Sie den Installationsanweisungen.

Nachdem alles erfolgreich heruntergeladen wurde, können Sie mit der Entwicklung für Android beginnen.

Neues Android-Projekt erstellen

Der Eclipse-Assistent für neue Projekte hilft Ihnen bei der Erstellung Ihrer Android-Anwendung, indem er Dateien und Code generiert, die direkt auf der Box ausgeführt werden können. Dies ist ein schneller Weg, um die Funktionsfähigkeit zu gewährleisten und ein guter Ausgangspunkt, um mit der Entwicklung zu beginnen:

• Wählen Sie Datei->Neu->Projekt...
• Wählen Sie Android-Projekt
• Im Dialog Neues Projekt geben Sie die folgenden Einstellungen ein:

  Project Name: BrewClock Build Target: Google Inc. 1.6 (Api Level 4) Application Name: BrewClock Package Name: com.example.brewclock Create Activity: BrewClockActivity Min SDK Version: 4

  

Nachdem Sie auf Fertig stellen drücken, erstellt Eclipse ein neues Android-Projekt, das bereit ist, unter Android ausgeführt und entwickelt zu werden. Erinnern Sie sich daran, dass Sie Eclipse angewiesen haben, eine Activity namens BrewClockActivity zu erzeugen? Dies ist der Code, den Android tatsächlich zum Starten der App verwendet. Der generierte Code wird als einfache Nachricht im Sinne von 'Hello World' angezeigt.

Pakete

Der Paketname ist der Bezeichner für Ihre Anwendung. Wenn es an der Zeit ist, das Ergebnis im Android Market zu veröffentlichen, wird dieser Bezeichner verwendet, um Aktualisierungen der App zu verfolgen, daher ist es wichtig, dass dieser Bezeichner eindeutig ist. Obwohl wir hier den Namen com.example.brewclock verwenden, ist es für die eigentliche App besser, etwas wie com.yourcompanyname.yourapplication zu wählen.

SDK-Versionen

Die Min SDK Version (der Name sagt alles) ist die früheste Version von Android, auf der die App laufen wird. Mit jeder neuen Version von Android werden im SDK verschiedene Methoden hinzugefügt und geändert. Wenn Sie die SDK-Version auswählen, weiß Android (und der Android Market), dass Ihre App nur auf Geräten mit der angegebenen Android-Plattformversion und höher laufen wird.

Starten Sie Ihre App

Lassen Sie uns versuchen, unsere App in Eclipse auszuführen. Da dies die erste Ausführung ist, wird Eclipse Sie fragen, mit welchem Projekttyp Sie arbeiten:

• Wählen Sie Run->Run oder drücken Sie Strg+F11.
• Wählen Sie Android Application und drücken Sie OK.

Eclipse wird versuchen, die Anwendung auf Ihrem Android-Gerät zu starten. Zu diesem Zeitpunkt haben Sie jedoch noch kein Android-Gerät, so dass Sie Ihr Projekt nicht starten können und aufgefordert werden, ein neues virtuelles Android-Gerät (AVD) zu erstellen.

Virtuelle Android-Geräte

Android Virtual Device (AVD) emuliert eine Android-Umgebung, sei es ein Mobiltelefon oder ein Tablet. Sie können beliebig viele AVDs mit verschiedenen Android-Plattformversionen erstellen. Für jedes AVD können Sie verschiedene Geräteparameter konfigurieren, z. B. physische Tastatur, GP-Unterstützung, Kameraauflösung usw.

Bevor Sie die Anwendung ausführen, müssen Sie Ihr erstes AVD mit dem Plattform-SDK (Google API, 1.6) erstellen.

Lassen Sie uns dies jetzt tun:

• Wenn Sie noch nicht versucht haben, die Anwendung auszuführen, drücken Sie Ausführen (oder Strg+F11)
• Wenn eine Warnung erscheint, drücken Sie Ja, um die AVD zu erstellen.
• Klicken Sie im Dialog Android SDK und AVD Manager auf Neu.
• Setzen Sie die folgenden Parameter für die AVD:

  Name: Android_1.6 Target: Google APIs (Google Inc.) - API Level 4 SD Card Size: 16 MiB Skin Built In: Default (HVGA)

• Klicken Sie auf AVD erstellen.
• Schließen Sie den Dialog Android SDK und AVD Manager.

Code ausführen

Versuchen Sie, die Anwendung erneut auszuführen (Strg+F11). Eclipse wird nun Ihr Projekt erstellen und eine neue AVD starten. Denken Sie daran, dass AVD die Android-Umgebung vollständig emuliert und Sie nicht einmal den eher langsamen Boot-Prozess wie bei einem echten Gerät beobachten müssen. Aus diesem Grund ist es am besten, das Fenster offen zu halten, während Sie den ganzen Tag programmieren.

Wenn der Android-Emulator startet, installiert Eclipse automatisch Ihre Anwendung und führt sie aus:

Erstellung Ihrer ersten Android-Anwendung

Das Testen des generierten Codes ist gut, aber Sie wollen mit der Erstellung der echten Anwendung beginnen. Dazu werden wir von einem einfachen Entwicklungsprozess zur Erstellung einer Anwendung übergehen, die auf einem Android-Gerät eingesetzt werden kann.

Die meisten Entwickler (mich eingeschlossen) stellen sich immer eine gute Tasse Tee oder Kaffee bereit . Im nächsten Abschnitt dieses Artikels werden Sie einen Anwendungszähler erstellen, um zu verfolgen, wie viele Tassen Tee (Bier) ein Benutzer geleert hat, und Sie können einen Timer einstellen, um jede Tasse zu brauen.

Den vollständigen Code für dieses Tutorial können Sie auf GitHub herunterladen.

Android-Entwicklung: Gestaltung der Benutzeroberfläche

Einer der ersten Schritte bei der Erstellung einer Anwendung ist die Gestaltung der Benutzeroberfläche. Hier ist eine kleine Skizze unserer Anwendung:

Hochladen

Der Benutzer kann die Kochzeit in Minuten mit den + und - Tasten einstellen. Wenn er auf Start drückt, beginnt der Countdown für die angegebene Anzahl von Minuten. Bricht der Benutzer das Simmern ab, indem er die Taste erneut drückt, wird die Zeit verlängert, wenn der Timer den Wert 0 erreicht.

Unter der Oberfläche

Die Android UI oder Shell, die in der XML-Dokumentation beschrieben wird, befindet sich im Ordner res/layouts. Der bereits von Eclipse generierte Template-Code wird in res/layouts/main.xml deklariert und funktioniert, wie Sie vielleicht bemerkt haben, bereits im Emulator.

Eclipse verfügt über ein eigenes Layout-Design-Tool, mit dem Sie eine Oberfläche per Drag & Drop auf dem Bildschirm erstellen können. Manchmal ist es jedoch einfacher, die Schnittstelle in XML zu schreiben und das grafische Layout zur Vorschau der Ergebnisse zu verwenden.

Lassen Sie uns dies nun tun, indem wir die main.xml entsprechend der obigen Skizze ändern:

• Öffnen Sie res/layouts/main.xml in Eclipse durch Doppelklick aus dem Package Explorer.
• Klicken Sie auf die Registerkarte main.xml am unteren Bildschirmrand, um in den XML-Modus zu wechseln.

Nun ändern Sie den Inhalt von main.xml wie folgt:

# /res/layouts/main.xml             

Wie Sie sehen, gibt es viele Dateien in Android-XML, aber dies ermöglicht Ihnen, fast jedes Element auf dem Bildschirm zu steuern.

Eines der wichtigsten Elemente in der Android-Oberfläche sind Layout-Container, wie das in diesem Beispiel verwendete LinearLayout. Diese Elemente sind für den Benutzer nicht sichtbar, sondern dienen als Container für andere Elemente wie Buttons und TextViews.

Es gibt mehrere Layout-Typen, von denen jeder zum Aufbau verschiedener Layout-Typen verwendet wird. Wie LinearLayout und AbsoluteLayout ermöglicht TableLayout die Verwendung einer rasterbasierten Schnittstelle. Mehr dazu erfahren Sie im Abschnitt über das allgemeine Objektlayout in der API-Dokumentation.

Binden Sie Ihr Layout an den Code

Nach dem Speichern Ihres Layouts versuchen Sie, die Anwendung in einem Emulator auszuführen, indem Sie Strg + F11 drücken oder in Eclipse auf das Symbol Ausführen klicken. Anstelle der "Hello World"-Meldung sehen Sie nun, dass Android die Anwendungsschnittstelle anzeigt.

Wenn Sie eine Taste drücken, leuchtet diese wie erwartet auf, tut aber ansonsten nichts. Fahren wir mit dem Schreiben von Code fort, der der Layout-Schnittstelle folgt:

# /src/com/example/brewclock/BrewClockActivity.java ... import android.widget.Button; import android.widget.TextView; public class BrewClockActivity extends Activity { /** Properties **/ protected Button brewAddTime; protected Button brewDecreaseTime; protected Button startBrew; protected TextView brewCountLabel; protected TextView brewTimeLabel; ... }

Als nächstes ändern wir den onCreate-Aufruf. Dieser Aufruf erfolgt, sobald eine Anwendung auf Android gestartet wird. In dem von Eclipse generierten Code wird mit onCreate eine Aktivitätsansicht auf R.layout.main erstellt. Dies ist die Codezeile, die Android anweist, das Layout eines XML-Dokuments zu dekodieren und es dem Benutzer anzuzeigen.

Resource Object

In Android ist R ein spezielles Objekt, das automatisch erstellt wird, um den Zugriff auf die Ressourcen Ihres Projekts (Layouts, Zeilen, Menüs, Icons...) innerhalb des Codes zu ermöglichen. Jeder Ressource wird eine eigene ID zugewiesen. In der Layoutdatei (siehe oben) sind dies die @+id-Attribute des XML. Wir werden sie verwenden, um Buttons und TextViews in unserem Layout zu binden:

# /src/com/example/brewclock/BrewClockActivity.java ... public class BrewClockActivity extends Activity { ... public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Connect interface elements to properties brewAddTime = (Button) findViewById(R.id.brew_time_up); brewDecreaseTime = (Button) findViewById(R.id.brew_time_down); startBrew = (Button) findViewById(R.id.brew_start); brewCountLabel = (TextView) findViewById(R.id.brew_count_label); brewTimeLabel = (TextView) findViewById(R.id.brew_time); } }

"Listening" events

Wir müssen das Abhören von Buttons implementieren, um festzustellen, ob sie angeklickt werden. Vielleicht kennen Sie Callback-Listener oder Callbacks von anderen Plattformen wie Javascript/JQuery oder Rails.

Android bietet einen ähnlichen Mechanismus, indem es eine Listener-Schnittstelle wie OnClickListener bereitstellt, die Methoden definiert, die ausgelöst werden, wenn ein Ereignis eintritt. Die Schnittstelle OnClickListener benachrichtigt Ihre Anwendung, wenn der Benutzer auf den Bildschirm oder eine bestimmte Schaltfläche klickt. Außerdem müssen wir jeder Schaltfläche den ClickListener mitteilen:

# /src/com/example/brewclock/BrewClockActivity.java ... // Be sure not to import // `android.content.dialoginterface.OnClickListener`. import android.view.View.OnClickListener; public class BrewClockActivity extends Activity implements OnClickListener { ... public void onCreate(Bundle savedInstanceState) { ... // Setup ClickListeners brewAddTime.setOnClickListener(this); brewDecreaseTime.setOnClickListener(this); startBrew.setOnClickListener(this); } ... public void onClick(View v) { // TODO: Add code to handle button taps } }

Weiter werden wir Code hinzufügen, der jeden unserer Schaltflächenklicks behandelt. Wir fügen auch vier neue Aktivitätseigenschaften hinzu, die es dem Benutzer ermöglichen, die Brauzeit einzustellen und zu verfolgen: wie viele Brühen gemacht wurden und ob ein Timer läuft.

# /src/com/example/brewclock/BrewClockActivity.java ... public class BrewClockActivity extends Activity implements OnClickListener { ... protected int brewTime = 3; protected CountDownTimer brewCountDownTimer; protected int brewCount = 0; protected boolean isBrewing = false; ... public void onClick(View v) { if(v == brewAddTime) setBrewTime(brewTime + 1); else if(v == brewDecreaseTime) setBrewTime(brewTime -1); else if(v == startBrew) { if(isBrewing) stopBrew(); else startBrew(); } } }

Beachten Sie, dass wir die von Android bereitgestellte CountDownTimer-Klasse verwenden. Auf diese Weise ist es einfach, einen einfachen Zähler zu erstellen und laufen zu lassen und in regelmäßigen Abständen benachrichtigt zu werden, während der Countdown läuft. Sie werden dies in der startBrew-Methode verwenden, lesen Sie dazu weiter unten.

Die folgenden Methoden modellieren das Verhalten des Schiebereglers für die Kochzeit, den Start und das Ende des Brühvorgangs und den Zähler. Wir initialisieren auch die Eigenschaften brewTime und brewCount in onCreate.

Es wäre eine gute Praxis, diesen Code in eine separate Modellklasse zu verschieben, aber der Einfachheit halber fügen wir den Code zu BrewClockActivity hinzu:

# /src/com/example/brewclock/BrewClockActivity.java ... public class BrewClockActivity extends Activity implements OnClickListener { ... public void onCreate(Bundle savedInstanceState) { ... // Set the initial brew values setBrewCount(0); setBrewTime(3); } /** * Set an absolute value for the number of minutes to brew. * Has no effect if a brew is currently running. * @param minutes The number of minutes to brew. */ public void setBrewTime(int minutes) { if(isBrewing) return; brewTime = minutes; if(brewTime < 1) brewTime = 1; brewTimeLabel.setText(String.valueOf(brewTime) + "m"); } /** * Set the number of brews that have been made, and update * the interface. * @param count The new number of brews */ public void setBrewCount(int count) { brewCount = count; brewCountLabel.setText(String.valueOf(brewCount)); } /** * Start the brew timer */ public void startBrew() { // Create a new CountDownTimer to track the brew time brewCountDownTimer = new CountDownTimer(brewTime * 60 * 1000, 1000) { @Override public void onTick(long millisUntilFinished) { brewTimeLabel.setText(String.valueOf(millisUntilFinished / 1000) + "s"); } @Override public void onFinish() { isBrewing = false; setBrewCount(brewCount + 1); brewTimeLabel.setText("Brew Up!"); startBrew.setText("Start"); } }; brewCountDownTimer.start(); startBrew.setText("Stop"); isBrewing = true; } /** * Stop the brew timer */ public void stopBrew() { if(brewCountDownTimer != null) brewCountDownTimer.cancel(); isBrewing = false; startBrew.setText("Start"); } ... }

Nur Teile dieses Codes, die spezifisch für Android sind, erstellen Label-Mappings mithilfe der setText-Methode. In startBrew erstellen und starten wir CountDownTimer, um einen sekundengenauen Countdown zu starten, wenn das Brauen/Kochen vorbei ist. Beachten Sie, dass wir CountDownTimer-Listener ( onTick und onFinish) definieren. Der onTick wird alle 1000 Millisekunden (1 Sekunde) aufgerufen, während der onFinish-Aufruf erfolgt, wenn der Timer Null erreicht.

Komplexität in der Android-Programmierung vermeiden

Um diesen Leitfaden für die Android-Entwicklung einfach zu halten, habe ich absichtlich Bezeichnungen direkt im Code angebracht (z.B. "Brew Up!", "Start", "Stop"). Dies ist eigentlich keine gute Praxis, da es schwierig ist, diese Zeichenketten in großen Projekten zu finden und zu ändern.

Android bietet eine gute Möglichkeit, Ihre Textzeichenketten getrennt vom R-Objektcode zu speichern. R erlaubt es, alle Strings einer Anwendung in einer XML-Datei (res/values/strings.xml) zu definieren, auf die im Code über einen Link zugegriffen werden kann. Zum Beispiel:

# /res/values/strings.xml Brew Up! ... # /res/com/example/brewclock/BrewClockActivity.java ... brewLabel.setText(R.string.brew_up_label); ...

Wenn Sie nun Brew Up! etwas anderes ändern wollen, müssen Sie es einmal in der Datei strings.xml ändern. Wenn Ihre Anwendung Dutzende von Codedateien enthält, ist es sehr sinnvoll, sie an einem Ort zusammenzufassen!

Prüfen Sie BrewClock

Wir haben den Code fertig geschrieben, jetzt ist es an der Zeit, die Anwendung zu "testen". Drücken Sie "Ausführen" oder Strg + F11, um BrewClock im Emulator zu starten. Wenn alles gut geht, wird die Einrichtungsoberfläche angezeigt und Sie können Ihren Tee aufbrühen! Versuchen Sie, verschiedene Brühzeiten einzustellen und drücken Sie Start, um den Countdown zu starten.

Fortsetzen

In dieser kurzen Einführung in die Android-Entwicklung haben Sie das Android SDK und das Eclipse Android Development Tools (ADT) Plugin heruntergeladen und installiert. Sie haben einen Emulator oder eine virtuelle Anwendung eingerichtet, um Ihre Anwendungen zu testen. Sie haben auch eine funktionierende Android-App erstellt, die eine Reihe von Schlüsselkonzepten , hervorhebt, die Sie bei der Entwicklung zukünftiger Android-Apps verwenden werden.

Wir hoffen, dass dies Ihren Appetit auf die Entwicklung mobiler Apps und das Experimentieren in diesem spannenden Bereich geweckt hat. Android bietet eine großartige Möglichkeit, Anwendungen für eine Reihe aktueller und zukünftiger mobiler Geräte zu schreiben. Wenn Sie bereits eine funktionierende Anwendung für die Plattform geschrieben haben, vergessen Sie nicht, uns dies in den Kommentaren mitzuteilen!