Android: Unterschied zwischen den Versionen
Zeile 343: | Zeile 343: | ||
==== WebView ==== | ==== WebView ==== | ||
Darin lässt sich eine (lokale) Webseite direkt anzeigen. Kann man auch für Hilfeseiten verwenden. | Darin lässt sich eine (lokale) Webseite direkt anzeigen. Kann man auch für Hilfeseiten verwenden. | ||
== Verweise == | |||
Damit man aus dem Java-Code auf die einzelnen Elemente der Oberfläche zugreifen kann, braucht es eine eindeutige ID, welche man jedem Element vergeben muss, das man im Code ansprechen möchte. Dazu dient die ID bei den Eigenschaften in der <code>Layout-Datei</code>. | |||
<pre> | |||
<TextView | |||
android:id="@+id/TextStartDateTime" | |||
</pre> | |||
Das + vor der ID ist notwendig, damit Android weiss, dass die Ressource vor dem Zugriff evtl. noch erstellt werden muss. | |||
== Ressourcen == | == Ressourcen == |
Version vom 18. November 2020, 02:08 Uhr
Einführung
- Fast alle Java-Klassen stehen zur Verfügung plus Verschlüsselung, HTTP, JSON, XML Bibliotheken
- Für die Programmierung steht in neueren Versionen Kotlin zur Verfügung.
- Keine main()-Funktion - stattdessen: lose gekoppelte Komponenten, eine oder mehrere davon als Einstiegspunkt definierbar
- Wichtigste Komponente: "Activity" - entspricht einem sichtbaren Fenster auf dem Screen (Ähnlich wie Tabs eines Browsers). Man kann etwa ein Programm mit Screen 1 (Hauptseite) aufrufen oder direkt Screen 2 (Unterseite). Der Aufruf geschieht über die App-Icons.
Entwicklungsumgebung
Zum konkreten Einrichten siehe das Buch Android Apps programmieren). Kapitel 2.1.1 Installation.
Neues Projekt
Mit dem Assistenten wird ein neues Projekt erstellt. Im Android-Buch hat es eine bebilderte Anleitung im Kapitel 3.1.1 ab Seite 62. Je nach Version kann es hier sein, dass gewisse Optionen anders heissen oder Felder neu hinzukommen oder verschwinden. Entsprechend muss man halt schauen, was es braucht oder im Internet nachschauen.
Wähle "File" → "New" → "New Project..."; im "New Project"-Dialog wähle "A new Android Project" aus dem "Android" Order.
Füll den "New Android Project"-Dialog wie folgt aus:
- Project/Application name: "Hello Workshop"
- Company domain: Beliebige domain, die man entweder besitzt oder die es nicht gibt. testprojekt.test.tt, zeit.dict.ch. Ergibt umgekehrt den package name (tt.test.testprojekt, ch.dict.zeit).
- Verwende die "default location" oder lege eine andere Location fest
- Je nach Kenntnissen und Bedürfnissen kann man auch c++ und/oder Kotlin einbinden
- Build target: API21 oder was notwendig wählen. Wenn man bestimmte Funktionen braucht, muss man halt unter "Help me choose" schauen, welche Version welches Feature eingeführt hat (Bluetooth usw.). Aktuelle Daten der Verwendung der Geräte unter: https://developer.android.com/about/dashboards
- Auswahl der gewünschten Vorlage (No Activity, Basic, usw.)
- Activity Name: "HelloWorkshopActivity" -> entspricht der Java-Klasse der Haupt-Activity und wird ohne Vorgabe entsprechend MainActivity genannt. Klassen, welche Fenster steuern, sollten als Konvention auf "Activity" enden, doch dies ist natürlich nur eine Konvention. Damit man weiss, was die Klasse tut, sollte man sie entsprechend der Projektvorgaben nennen.
- Layout Name: "activity_hello_workshop" -> Layouts sollten klein geschrieben werden und mit dem "_" aufgeteilt werden. Layouts für Activities sollten entsprechend mit "activity_" beginnen.
Klicke auf den "Finish"-Button und warte, bis das Projekt erstellt wurde.
Emulator
Gerät einrichten
Falls kein Andoid-Gerät vorhanden ist, oder das gewünschte Gerät fehlt.
Klicke auf das "Android SDK and AVD manager"-Icon in der Icon-Leiste. Klicke auf "New" Im "Create new AVD"-Dialog, gib folgendes ein:
- Name: "G1"
- Target: "Android 1.6 - API Level 4"
- SD Card Size: "1024" MiB
- Skin: Built-in: "Default (HVGA)"
Dann klicke auf "Create AVD" (kann eine Weile - bis zu einigen Minuten - dauern)
Bei der Geräteauswahl kann man auch Geräte mit Playstore anwählen, doch dann kann man bei diesen Geräten keinen Root-Zugriff machen. Man erkennt diese Möglichkeit bei der Auswahl, wenn es ein Icon in der betreffenden Spalte hat.
App auf Gerät testen
Beim Start auf das Play-Icon wird das verknüpfte Gerät gestartet und die App ausgeführt.
Hier kann es sein, dass ein Gerät gestartet wird, doch die App startet nicht und auf der Konsole kommt die Meldung: "Installation did not succeed. The application could not be installed." In diesem Fall wird zwar im AVD-Manager das korrekte Geräte angezeigt, doch unten rechts im Studio beim Design ist ein anderes Gerät angewählt. Dadurch ergibt sich keine Übereinstimmung vom Layout und vom Gerät und somit kann die App nicht starten. In diesem Fall muss das Gerät beim Designer umgestellt werden, auf das vom AVD-Manager und nach einem Neustart der App wird dies auch angezeigt, wenn es nicht noch weitere Fehler gibt.
Verwendete Dateien
Um die verwendeten Dateien zu sehen, muss man den Navigator einblenden, der auf der linken Seite zusammengeklappt werden kann. Anschliessend muss man dann oberhalb der Ansicht unterhalb vom Projektnamen die Art der Darstellung wählen. Falls man mehrere Projekte offen hat, zum gewünschten Projekt navigieren.
Bei der Ansicht Android wird das Projekt "logisch" aufgelistet und entsprechend Dateien, die zusammengehören, wie etwa die Ressourcen zusammen aufgeführt.
Will man hingegen die wirkliche Datenstruktur sehen, so wechselt man auf Project Files, welches den Baum auflistet.
Die Projekte werden standardmässig unter folgendem Pfad gespeichert:
C:\Users\<Benutzername>\AndroidStudioProjects\<Projektname>
Die folgende Tabelle gibt den Stand von Nov. 2020 mit Android Studio 4.1 wieder. Die Entwicklung ist dynamisch und daher kann es gut sein, dass Dateien immer noch verschoben werden und auch Verzeichnisse anders aufgebaut werden. Entsprechend muss man manche Dateien halt suchen, wenn sie nicht am entsprechenden Ort gefunden werden können oder man schaut im Studio, wohin referenziert wird.
Da im Projekt sehr viele Dateien involviert sind, werden "interne" Verzeichnisse und Dateien wie etwa die diversen Build- und Testverzeichnisse nicht aufgeführt. Auch Verzeichnisse, welche nur für die Versionsverwaltung oder fürs Kompilieren verwendet werden, werden nicht aufgelistet.
Datei/Ordner | Beschreibung |
---|---|
/app | Ordner in dem sich das aktuelle Modul befindet. Bei grösseren Projekten können mehrere Module definiert werden. |
/app/src | Source-Ordner aller Klassen des Moduls |
/app/src/main/AndroidManifest.xml | Linked alle wichtigen Dateien des Projekts. Dort werden auch die Berechtigungen fürs Projekt angemeldet (Datei- und Internetzugriff usw.). Dazu muss man dort Services anmelden oder wenn man ContentProvider für externe Apps bereitstellt. |
/app/src/main/java/<domain>/<projektname>/MainActivity.java | Klasse der Haupt-Activity. Verweist mit setContentView(R.layout.main); auf das Layout, welches in der main.xml definiert wurde. |
/app/src/main/res | Layout- Sprach- und Bilddateien. |
/app/src/main/res/drawable | Bilddateien. Diese werden in den entsprechenden Unterordnern auflösungsabhängig gespeichert, damit die App auch bei unterschiedlichen Geräten in etwa gleich ausschaut. |
/app/src/main/res/layout | Layouts. Da das Layout beim drehen meist etwas anders angezeigt wird, gibt es auch den Ordner layout-land, in dem das "landscape" Layout abgelegt wird. |
/app/src/main/res/layout/activity_main.xml | Das Layout wird als XML-Datei erstellt. Die Ressourcen werden dort entsprechend auf die Text-Ressource-Dateien verwiesen, damit man die App nur einmal kompilieren muss und trotzdem verschiedene Sprachen anbieten kann. Wird erstellt aus dem Namen, den man beim generieren des Projekts für das Layout wählt. Ohne Anpassung wird er aus dem Projektnamen gebildet. |
/app/src/main/res/menu | Falls man ein Menü in der Action-Bar anbieten will, werden die Ressourcen dafür hier angelegt. Standardmässig wird das Manü aber nicht angelegt. |
/app/src/main/res/mipmap* | Icons. Diese werden in den entsprechenden Unterordnern auflösungsabhängig gespeichert, damit diese auch bei unterschiedlichen Geräten in etwa gleich ausschauen. (xxxhdpi = 192 x 192 Pixel – 640 dpi / xxhdpi = 144 x 144 Pixel – 480 dpi / xhdpi = 96 x 96 Pixel – 320 dpi / hdpi = 72 x 72 Pixel – 240 dpi / mdpi = 48 x 48 Pixel – 160 dpi / ldpi = 36 x 36 Pixel – 120 dpi) |
/app/src/main/res/values(-xx) | Text-Ressource-Dateien. Diese Dateien enthalten Wertepaare für verschiedene Anwendungen wie Farben oder Strings, welche man dann in verschiedene Sprachen überstzene kann und die dann das entsprechende Länderkürzel angehängt bekommen. |
/assets | Ordner für Binär-Dateien (alles, was Android nicht selbst verwaltet). Wird standardmässig nicht angelegt. |
/gradle | Wird für die Versionsverwaltung eingesetzt. |
AndroidManifest.xml
Legt diverse Werte zum Aussehen und Verhalten des Programms fest. https://developer.android.com/guide/topics/manifest/manifest-intro
Folgende Einträge sind für die Unterstützung von unterschiedlichen Geräte möglich. Evtl. bei neueren Versionen nicht mehr notwendig.
<supports-screens android:anyDensity="true" android:largeScreens="true" android:smallScreens="true" />
- anyDensity für hohe Auflösungen
- largeScreens bei grossen Displays
- smallScreens für kleine Displays
Für Berechtigungen werden Einträge in folgender Weise hinzugefügt:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.INTERNET" />
Wenn man Eclipse verwendet, kann man aus den Warnungen ableiten, wenn man etwas falsch definiert. Dazu kann man entweder die Datei direkt bearbeiten oder dies über den Tab umstellen und manches direkt grafisch anpassen.
Ein Beispiel ist im Android-Buch auf Seite 39 (Kap. 2.2.2 App-Bausteine) aufgeführt.
MainActivity.java
Enthält, wie unter Programmierung gezeigt, das Hauptprogramm. Der Name wird entsprechend bei Projekteröffnung festgelegt. Hier werden unter anderem die Elemente definiert.
private Button hiButton; private Button helloButton;
strings.xml
Legt die Werte für die Strings fest. Hier wurden zwei Srings "hello" und "app_name" definiert, welche nun in anderen Dateien verwendet werden können (Layout oder Programm). Siehe dazu den Abschnitt Texte.
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">Hello World, HelloWorkshopActivity!</string> <string name="app_name">Hello Workshop</string> </resources>
Android-App kompilieren (Gradle)
Im Gegensatz zu einem "normalen" Programm, müssen bei einer Android-App viele verschiedene Tools zusammenarbeiten, um am Schluss eine lauffähige App bereitstellen zu können. Gradle ist ein Build Management Tool für Java, das diese Aufgaben bündelt.
- Herunterladen von externen Abhängigkeiten (externe Bibliotheken)
- Kompilieren der Java-Dateien in DEX
- Kompilieren der Ressourcen (Bilder, Icons, usw.)
- Verpacken als APK-Datei (DEX + Ressourcen)
- Signieren der APK-Datei
- Optimieren der App auf Speicherverbrauch
Gradle benutzt eine auf Groovy aufbauende DSL (Domain Specific Language). Wenn man weiss wie und es braucht, so kann man den Build-Prozess entsprechend anpassen. Siehe dazu den Link: https://developer.android.com/studio/build
Für die Einbindung der externen Bibliotheken wird das Maven-Repository eingebunden.
Programmierung
Zuerst ein Beispiel, welches unten erklärt wird:
class MyActivity extends Activity { onCreate { View view = ... // erstellt den sichtbaren Teil setContentView(view); ... } // end Eventhandler onCreate onClick { ... Intent intent = ... // Zugriff auf externes Programm startActivity (intent); } // end Eventhandler onClick } // end class MyActivity
Activity
- definiert eine "View", zur Anzeige auf dem Screen. Entspricht einem Fenster.
- behandelt "Events" (z. B. Klick auf einen Button)
- benutzt "Intents", um andere Activities zu starten
Fragment
Wurden mit Android 3.1 eingeführt und sind selbständige Teilbereiche einer Activity. Können entsprechend auf verschiedenen Activities wiederverwendet oder in einer Activity mehrfach eingesetzt werden.
View
- eine "View" ist der sichtbare Teil der Activity
- definiert in einer XML-Layout-Datei (oder im Code)
Events / Programmablauf
- werden ausgelöst, wenn etwas geschieht (z. B ein Button geklickt wird)
- ruft eine Listener-Methode auf, sofern ein Listener definiert ist
Ein Beispiel mit mehreren Events für einen Programmablauf sieht man hier: http://www.androidpit.de/de/android/wiki/view/Datei:Beginners_Workshop_Activity_LC.png
Um Datenverlust oder den Verlust des Zustands einer Activity zu vermeiden, müssen die Daten/der Zustand der Activity gesichert werden, wenn diese pausiert (nicht mehr im Vordergrund, aber noch sichtbar) oder gestoppt (nicht mehr sichtbar) wird.
onClick()
- Aufruf beim Drücken auf einen Button
EditText nameField = (EditText) findViewById(R.id.name_field); String name = nameField.getText().toString(); if (name.length() == 0) { new AlertDialog.Builder(this) .setMessage(R.string.error_name_missing) .setNeutralButton(R.string.error_ok, null) .show(); return; } // end if
onCreate()
- wird einmalig beim Programmstart aufgerufen
- muss die View und die Elemente darin definieren
- springt anschliessend weiter nach onStart()
- definiert die Listener-Aufrufe
hiButton = (Button)findViewById(R.id.hi_button); hiButton.setOnClickListener(this); helloButton = (Button)findViewById(R.id.hello_button); helloButton.setOnClickListener(this);
onDestroy()
- Wird nur aufgerufen, wenn das Programm explizit beendet wird
onPause()
- Geht weiter nach onResume, wenn es wieder in den Vordergrund geholt wird oder nach onStop, wenn es gar nicht mehr sichtbar ist
- Da das Programm bei Speichermangel in diesem Zustand "abgeschossen" werden kann, müssen spätestens hier die Benutzerdaten gesichert werden
onRestart()
- Falls das Programm gestoppt wurde, doch noch nicht wegen Speichermangels aus dem RAM entfernt wurde und nun wieder in den Vordergrund kommt, wird diese Methode aufgerufen
- Springt anschliessend direkt nach onStart()
onResume()
- Wird jedes Mal aufgerufen, wenn die App nach einer Pause (wieder) in den Vordergrund kommt
onStart()
- Springt weiter nach onResume()
onStop()
- Wird aufgerufen, wenn das Programm nicht mehr sichtbar ist
- Je nach weiterer Folge, geht der Programmlauf weiter mit onDestroy oder onRestart.
Intent
- startet eine andere Activity ("öffnet ein neues Fenster")
- kann Daten an die zu startende Activity übergeben
- kann Activities aus anderen Apps starten!
Layouts und Elemente
Siehe im Androidbuch Kapitel 2.2.3 ab Seite 42. Wie oberhalb erwähnt, wird in /res/layout/<NameMainActivity>.xml das Layout der Hauptdatei festgelegt. Das heisst, hier werden die Elemente festgelegt. Layouts werden extra in XML-Dateien erstellt, damit man eine exakte Trennung zum Code erhält, auch wenn man natürlich das Layout auch im Java-Code erstellen kann. Alle sichtbaren Elemente leiten sich von der Basisklasse View ab, wobei die Elemente in zwei Gruppen aufgeteilt werden:
- ViewGroup
- View
Wobei jede ViewGroup Views und weitere ViewGroups enthalten kann.
ViewGroups (Layouts)
Siehe im Androidbuch ab Seite 75 Kapitel 3.3 Layout-Erstellung. Folgende ViewGroups werden standardmässig unterstützt:
- LinearLayout: Die enthaltenen Views werden unter- ober nebeneinander aufgelistet. Je nachdem, wie man die Eigenschaft orientation gesetzt hat. Die enthaltenen Views kann man mit %-Angaben aufteilen.
- RelativeLayout: Ordnet die Views im Verhältnis zu sich selbst oder anderen Elementen an. Dies kann sein: rechts von View 2, oberhalb von View 3, zentriert im Container, unterhalb vom oberen Rand, usw.
- TableLayout: Ordnet die Views als Zeilen und Spalten an. Die Breite der Spalten wird durch die Breite des Inhalts bestimmt.
- GridLayout: Ähnlich wie TableLayout, doch braucht keinen Container. Dazu können die Zellen gewichtet aufgeteilt werden (prozentual). Für Abstände kann man auf die Eigenschaft Space zurückgreifen. Views können über mehrere Zeilen/Spalten "aufgespannt" werden. Dies ermöglicht komplexe Layouts, ohne dass man dafür mehrere Layouts verschachteln müsste.
- ConstraintLayout: Verwandt mit RelativeLayout, doch flexibler. Die Elemente stehen zwar in Beziehung, doch diese Kopplung ist loser und ermöglicht präzise Positionierungen. Die Beziehungen werden durch "Spannfedern" dargestellt.
- ListView: Wird normalerweise nur verwendet, um Daten etwa aus einer Datenbank automatisch abzufüllen und als Liste darzustellen.
- GridView: Hier werden die Daten wie bei einer ListView abgefüllt, doch etwa wie die Bilderansicht im Explorer in einem Gitter dargestellt.
vertikale und horizontale Layouts
Layouts können auch geschachtelt werden. Das Hauptlayout ist meist vertikal.
Vertikales Layout mit einem Titel:
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> </LinearLayout>
Der Inhalt des Strings wird in der /res/layout/strings.xml definiert
Horizontales Layout mit zwei Knöpfen.
<LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="wrap_content" > <Button android:id="@+id/hi_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/hi_button" /> <Button android:id="@+id/hello_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/hello_button" /> </LinearLayout>
Views (Elemente)
Die Elemente werden wie erwähnt in den Layouts platziert und vom Benutzer verwendet, während die ViewGroup im Hintergrund "nur" den Platz aufteilt. Die Elemente werden am einfachsten in der "Designer-Ansicht" auf der Activity verteilt, da man so nicht alles im XML-Code erstellen muss, sondern nur noch die Beziehungen oder Positionen sauber setzen muss.
Button (Knopf)
Ermöglicht das entgegennehmen von Aktionen und deren Auswertung im Code.
<Button android:id="@+id/hi_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/hi_button" />
Der Knopf braucht neben der Beschriftung, welche in der strings.xml definiert wird, noch eine id, welche wieder im Programm über ein Event ausgewertet werden kann.
EditText (Eingabefeld)
Dieses Feld kann Text vom Benutzer entgegen nehmen. Durch setzen der Eigenschaft inputType kann man die Eingaben einschränken etwa auf Text, URI, E-Mail, Zahlen, Passwort, Dezimalzahlen, Datum, Uhrzeit, Telefonnummer, usw. (eigene Filter sind möglich).
<EditText android:id="@+id/name_field" android:layout_width="fill_parent" android:layout_height="wrap_content" />
Hier bekommt das Feld eine id("name_field"), welche man später im Programm verwenden kann, um den Wert auszulesen.
ImageView
Ermöglicht das Darstellen von Bildern. Diese kann man aus den Ressourcen laden oder vom internen Speicher.
Spinner
Entspricht in anderen Sprachen einer Radiobox, bei der man von mehreren Einträgen nur einen auswählen kann.
Switch
Auswahl zwischen zwei Werten. Entspricht einer Checkbox.
TextView (Label)
Stellt einen nicht bearbeitbaren Text dar etwa für Beschriftungen.
<TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="20dp" android:text="@string/enter_your_name" />
Hier müssten wir noch den String "enter_your_name" in der strings.xml definieren.
WebView
Darin lässt sich eine (lokale) Webseite direkt anzeigen. Kann man auch für Hilfeseiten verwenden.
Verweise
Damit man aus dem Java-Code auf die einzelnen Elemente der Oberfläche zugreifen kann, braucht es eine eindeutige ID, welche man jedem Element vergeben muss, das man im Code ansprechen möchte. Dazu dient die ID bei den Eigenschaften in der Layout-Datei
.
<TextView android:id="@+id/TextStartDateTime"
Das + vor der ID ist notwendig, damit Android weiss, dass die Ressource vor dem Zugriff evtl. noch erstellt werden muss.
Ressourcen
Damit man Texte übersetzen oder Bilder verwenden kann, muss man diese im Programm zur Verfügung stellen. Eine kurze Übersicht sieht man im Abschnitt Verwendete Dateien. Während Bilder oder Videos einfach referenziert werden, möchte man Sprachen auch übersetzen. Entsprechend verwendet man im Programm nur eine Referenz, welche dann je nach Spracheinstellung auf den richtigen Spracheintrag verweist.
Texte
Standardmässig steht strings.xml zur Verfügung, doch man kann mit der entsprechenden Referenz auch auf andere Dateien verweisen, falls man etwa pro Activity eine eigene Referenzdatei möchte.
Damit die Referenzdatei auch verwendet wird, muss man im Layout auch darauf verweisen. Dazu wird bei der Eigenschaft des Elements entsprechend nicht einfach ein Text hinterlegt, sondern ein Verweis auf eine Textressource. Anstatt android:text="Beschriftung"
heisst es dann @string/LabelStartTime
. Damit verweist man auf eine Stringressource mit Namen LabelStartTime
. Nun kann in der Datei strings.xml
der Eintrag zu den Ressourcen hinzugefügt werden: <string name="LabelStartTime">Start</string>
.
Will man mehrere Sprachen zur Verfügung stellen, so werden entsprechend Kopien der strings.xml erstellt, doch nicht mehr im Unterordner values
, sondern bei englisch etwa values-en
oder französisch values-fr
. In der Datei werden dann einfach die übersetzen Texte hineingeschrieben und so kann Android je nach Sprachwahl die korrekten Texte anzeigen. Wichtig ist, dass die Datei weiterhin strings.xml heisst oder wie auch immer man die Referenzdatei genannt hat.
Leider weiss ich noch nicht, wo man die Referenz setzt, wenn man etwa einen anderen Namen oder mehrere Dateien möchte. Der Verweis kann entweder manuell in den Dateien erstellt werden oder über einen Rechtsklick auf den Eintrag in der layout.xml Datei mit dem Menü "Extract string ressource". Es ist auch direkt im Designer mittels Doppelklick aufs Element möglich. Dort bei den Eigenschaften verweist man dann mit "Add New Ressource -> new string value" auf den String. Siehe Im Androidbuch Kapitel 3.3.2 Ressourcen für die Texte ab Seite 83.
Bilder und Videos
Abstände
Siehe im Androidbuch ab Seite 92 das Kapitel Innenabstand als Ressource.
Damit man Abstände nicht manuell anpassen muss, kann man diese genauso wie Texte als Ressource auslagern und darauf verweisen. So muss man anschliessend die Anpassungen nur noch in der Ressourcendatei vornehmen und kann dort auf mehrere Orte verweisen. Normalerweise wird dafür die Datei dimens.xml
verwendet.
Die Abstände können in folgenden Masseinheiten angegeben werden:
- dp oder dip: Auflösungsunabhängiges Pixel, welches je nach Auflösung grösser dargestellt wird, damit es immer gleich gross aussieht.
- sp: Ähnlich dp, doch kann es skaliert werden. Wird meist für Texte verwendet.
- pt: 1/72 Zoll fix
- px: Reales Pixel. Entsprechend wäschst oder schrumpft eine solche Angabe je nach Auflösung
- mm: Milimeter
- in: Zoll (inch)
Services
Laufen im Hintergrund. Werden verwendet, um Operationen aufzuführen, welche länger dauern und daher ausgelagert werden, wie etwa das herunterladen einer Datei von einem Server.
Content Provider
Sind die Schnittstellen nach aussen. So kann man mit der entsprechenden Berechtigung etwa die Kontaktdaten abfragen oder einen Telefonanruf starten, ohne selber eine Telefon-Activity programmieren zu müssen. Damit nicht jede App einfach auf ein anderes Programm zugreifen kann, muss man den Zugriff in der AndroidManifest.xml anmelden und der Benutzer muss beim ersten Zugriff dies erlauben.
Broadcast Receiver
Sind Benachrichtigungen, welche vom Betriebssystem und zum Teil auch von Apps versandt werden und auf die man entsprechend reagieren kann. Dies kann etwa "Power connected" oder Airplane Mode" sein. Eine Liste enthält dieser Link: https://developer.android.com/guide/components/broadcasts
Programmierbeispiel komplett
Wenn man ein Android-Projekt unter Eclipse erstellt, so generiert Eclipse mehrere Dateien. Hier werden nun alphabetisch alle Dateien aufgeführt, welche im Beispielprojekt manuell angepasst wurden.
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.helloworkshop" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="16" /> <supports-screens android:anyDensity="true" android:largeScreens="true" android:smallScreens="true" /> <application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name="com.example.helloworkshop.HelloWorkshopActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>
HelloWorkshopActivity.java
package com.example.helloworkshop; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.EditText; import android.widget.TextView; import android.widget.Toast; public class HelloWorkshopActivity extends Activity implements OnClickListener { private Button hiButton; private Button helloButton; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); hiButton = (Button)findViewById(R.id.hi_button); hiButton.setOnClickListener(this); helloButton = (Button)findViewById(R.id.hello_button); helloButton.setOnClickListener(this); } // end onCreate @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.hello_workshop, menu); return true; } // end onCreateOptionsMenu public void onClick(View v) { EditText nameField = (EditText) findViewById(R.id.name_field); String name = nameField.getText().toString(); if (name.length() == 0) { new AlertDialog.Builder(this).setMessage( R.string.error_name_missing).setNeutralButton( R.string.error_ok, null).show(); return; } if (v == hiButton || v == helloButton) { int resourceId = v == hiButton ? R.string.hi_greeting : R.string.hello_greeting; String greeting = getResources().getString(resourceId, name); Toast.makeText(this, greeting, Toast.LENGTH_LONG).show(); TextView greetingField = (TextView) findViewById(R.id.greeting_field); greetingField.setText(greeting); } } // end onClick } // end class HelloWorkshopActivity
main.xml
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <TextView android:id="@+id/greeting_field" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="20dp" android:text="@string/enter_your_name" /> <EditText android:id="@+id/name_field" android:layout_width="fill_parent" android:layout_height="wrap_content" > </EditText> <LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="wrap_content" > <Button android:id="@+id/hi_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/hi_button" /> <Button android:id="@+id/hello_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/hello_button" /> </LinearLayout> </LinearLayout>
strings.xml
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="action_settings">Settings</string> <string name="app_name">Hello Workshop</string> <string name="enter_your_name">Gib bitte Deinen Namen ein:</string> <string name="error_name_missing">Please enter your name.</string> <string name="error_ok">OK</string> <string name="hello">Hallo Welt Workshop!</string> <string name="hello_button">Say Hello!</string> <string name="hello_greeting">Hello %s!</string> <string name="hi_button">Say Hi!</string> <string name="hi_greeting">Hi %s!</string> </resources>
Programm auf Gerät verschieben
Mittels Google-Konto
- Im Ordner bin/res befindet sich die Datei "Projektname.apk". Diese ist die notwendige Datei.
- Die Datei als Anhnag ans Google-Konto senden
- Den Anhang im Gerät anwählen und danach installieren. Will das Gerät dies nicht, kann evtl. das Programm AKPatcher verwendet werden (hat bei mir aber immer nur den Info-Screen angezeigt)
- Anschliessend kann die App übers App-Menü gestartet werden
Mittels USB-Verbindung
Folgende Bildergalerie verwenden: http://www.chip.de/bildergalerie/So-geht-s-APKs-via-USB-installieren-Galerie_56637615.html
- Einstellung: Unbekannte Quellen zulassen
- Verbinden im Massenspeicher Modus
- APK-Datei auf das Gerät in den gewünschten Ordner kopieren
- Mit dem Dateimanager ins obige Verzeichnis navigieren und die Datei anwählen und installieren
Links
Link | Beschreibung | Niveau |
---|---|---|
Java | Java-Wiki | Anfänger |
http://www.vogella.com/articles/Android/article.html | Android-Einführungstutorial englisch | Anfänger-Fortgeschrittene |
http://www.makeuseof.com/tag/write-google-android-application/ | Android erste Applikation von Google englisch | Anfänger |
http://www.kammerath.net/android-app-programmieren.html | Android app programmieren deutsch | Anfänger |
http://www.vogella.com/articles/AndroidIntent/article.html | Android Intents englisch | Fortgeschrittene |