Android_Tutorial_Lektion09_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 9: Eigene Android App auf dem Handy installieren

In dieser Lektion werden wir unsere Android App auf einem physikalischen Android Gerät, also einem Smartphone oder Tablet, ausführen lassen.

Bisher haben wir unsere Android App auf einem virtuellen Android Gerät (AVD) installiert und getestet. Das Testen der App auf einem AVD ist sehr hilfreich, kann aber das Testen auf einem physikalischen Android Gerät nicht komplett ersetzen.


Einige Android Funktionen, wie WiFi, Bluetooth, SD-Karten Erkennung, USB, NFC und angeschlossene Kopfhörer, sind nur auf einem Smartphone (Handy) oder Tablet verfügbar. Daher muss für das Nachstellen bestimmter Anwendungsfälle die App auf einem Android Gerät ausgeführt werden.

Damit wir unsere App auf dem Android Gerät ausführen können, müssen wir zuerst die Entwickleroptionen (Developer Options) des Geräts aktivieren. Anschließend werden wir mit Hilfe der Entwickleroptionen das USB-Debugging auf dem Android Gerät erlauben, wodurch es möglich ist die eigene App auf dem Gerät zu überwachen.

Danach werden wir das Android Gerät mit unserem Computer über USB verbinden und über die Android Debug Bridge die Verbindung zum Gerät überwachen. Abschließend werden wir unsere App von Android Studio auf das physikalische Android Gerät übertragen lassen und sie darauf ausgiebig testen.

1. Aktivieren der Entwickleroptionen (Developer Options)

Bevor das Android Gerät zum Testen mit dem PC über USB verbunden werden kann, muss die Verbindung zugelassen werden. Dazu müssen die Entwickleroptionen (Developer Options) aktiviert werden. Auf Smartphones (Handys) und Tablets, auf denen Android 4.2 oder neuer installiert ist, sind die Entwickleroptionen standardmäßig versteckt.

Wir werden nun zeigen wie die Entwickleroptionen auf zwei verschiedenen Android Geräten aktiviert werden. Der Aktivierungsvorgang verläuft sehr ähnlich, unterscheidet sich jedoch von Gerät zu Gerät etwas.

Die Entwickleroptionen bei einem Samsung Galaxy S4 mini aktivieren

  1. In das Menü des Samsung Galaxy S4 mini navigieren. Auf dem Gerät wird Android 4.4.2 ausgeführt.
  2. Im Menü des Android Geräts auf Einstellungen klicken.
  3. In Einstellungen auf den Tab Optionen klicken.
  4. In Optionen ganz nach unten scrollen und auf Geräteinformationen klicken.
  5. In Geräteinformationen jetzt 7 mal auf den Eintrag Buildnummer klicken. Dann erscheint eine Meldung, dass jetzt die Entwickleroptionen aktiviert wurden.
  6. Zurück zu Optionen gehen und ganz nach unten scrollen. Dann auf Entwickleroptionen klicken.
android_entwickleroptionen_aktivieren

Android Entwickleroptionen aktivieren – Anleitung für Samsung Galaxy S4 mini

Die Schritte für die Aktivierung der Android Entwickleroptionen auf einem Samsung Galaxy S4 mini sind in der oberen Abbildung zum besseren Verständnis noch einmal zusammengefasst (zum Vergrößern auf das Bild klicken).

Hat man die dargestellten Schritte ausgeführt, sind die Entwickleroptionen aktiviert und können über Einstellungen > Optionen > Entwickleroptionen konfiguriert werden.

Die Entwickleroptionen bei einem Samsung Galaxy S8 aktivieren

  1. Im Menü des Samsung Galaxy S8 auf Einstellungen klicken. Auf dem Gerät läuft Android 8.0.
  2. In Einstellungen ganz nach unten scrollen und auf Telefoninfo klicken.
  3. In Telefoninfo nach unten scrollen und auf Softwareinformationen klicken.
  4. In Softwareinformationen jetzt 7 mal auf den Eintrag Buildnummer klicken. Dann erscheint eine Meldung, dass jetzt die Entwickleroptionen aktiviert wurden.
  5. Zurück zu Einstellungen gehen und ganz nach unten scrollen. Dann auf Entwickleroptionen klicken.
entwickler_optionen_s8_flach

Android Entwickleroptionen aktivieren – Anleitung für Samsung Galaxy S8

Die Schritte für die Aktivierung der Android Entwickleroptionen auf einem Samsung Galaxy S8 sind in der oberen Abbildung zum besseren Verständnis noch einmal zusammengefasst.

Hat man die dargestellten Schritte ausgeführt, sind die Entwickleroptionen aktiviert und können über Einstellungen > Entwickleroptionen konfiguriert werden. Auf anderen Android Geräten können die einzelnen Schritte etwas abgewandelt sein.

Falls es bei euch überhaupt nicht klappen sollte, könnt ihr auf der Developer-Seite von Android unter folgendem Link weitere, sehr hilfreiche Tipps erhalten.

2. USB-Debugging auf dem Android Gerät aktivieren

usb_debugging_s8

USB-Debugging in den Entwickleroptionen aktivieren

Nachdem wir die Android Entwickleroptionen auf dem Android Gerät aktiviert haben, müssen wir einige Einstellungen in ihnen vornehmen. Dazu öffnen wir die Android Entwickleroptionen.

In unserem Fall öffnen wir die Entwickleroptionen über Einstellungen > Entwickleroptionen auf dem Samsung Galaxy S8.

In den Entwickleroptionen können sehr viele Einstellungen vorgenommen werden, die das Programmieren von Android Apps erleichtern. Wir benötigen aber nicht alle Optionen für das Entwickeln unserer App.

Für unsere Zwecke ist es ausreichend die folgenden Optionen zu aktivieren:

  1. Die Entwickleroptionen müssen aktiviert sein.
  2. Und das USB-Debugging muss aktiviert sein.

Die Abbildung rechst zeigt, welche Optionen auf dem Samsung Galaxy S8 aktiviert werden müssen. Auf anderen Android Geräten sollte es ähnlich aussehen.

Die Option USB-Debugging erlaubt unserem über USB angeschlossenen Rechner die Kommunikation mit dem Android Gerät. Nur wenn USB-Debugging aktiviert ist, können eigene Apps auf dem Gerät installiert und analysiert werden.

Es ist zudem empfehlenswert die Option Wach bleiben ebenfalls zu aktivieren. Sie ist in der Abbildung nicht dargestellt. Die Option Wach bleiben sorgt dafür, dass unser Android Gerät beim Laden nicht den Bildschirm in Standby schaltet und somit der Bildschirm nicht entsperrt werden muss. Die Wach bleiben Option ist sehr hilfreich, da es ohne sie zu Problemen mit dem Verbindungsaufbau kommen kann, wenn der Bildschirm des Android Geräts vor dem Authentifizieren erst entsperrt werden muss.

3. Das Android Gerät mit dem PC verbinden

Jetzt haben wir unser Android Gerät so konfiguriert, dass es Debugging-Verbindungen akzeptiert. Als Nächstes müssen wir dafür sorgen, dass unser Android Gerät beim Anschließen über USB vom Rechner korrekt erkannt wird. Danach können wir es über die Android Debug Bridge ansteuern, um schließlich unsere App darauf zu installieren.

Somit sind die nächsten beiden Arbeitsschritte:

  1. Installieren der USB-Treiber des Android Geräts auf dem PC
  2. Ansteuern des Android Geräts über die Android Debug Bridge

3.1 Installieren der USB-Treiber des Android Geräts auf dem PC

Damit das Android Gerät von dem PC korrekt erkannt werden kann, muss vorher der zum Gerät passenden USB-Treiber installiert werden. An dieser Stelle werden wir die Treiberinstallation für das Samsung Galaxy S8 auf einem Windows 10 Betriebssystem beschreiben.

Für andere Betriebssysteme, wie Mac OS X oder Linux, muss eine andere Vorgehensweise befolgt werden. Auf Techtopia könnt ihr unter folgendem Link eine sehr gute englische Anleitung für die anderen Betriebssysteme finden.

Die Treiberinstallation verläuft je nach Art des Android Geräts unterschiedlich:

  • Für Android Developer Phones (ADP), bspw. die Nexus-Reihe, müssen die Google USB Driver installiert werden. Eine ausführliche Installationsanleitung findet ihr hier.

  • Für alle anderen Android Geräte werden die Treiber des jeweiligen Herstellers benötigt. Eine Liste der Hersteller mit Treiber URL findet ihr hier. Nachdem der passende Treiber heruntergeladen worden ist, muss er nach den Angaben des jeweiligen Herstellers installiert werden.

Nachdem der passende USB-Treiber für das Android Gerät nach Angaben von Google bzw. des Herstellers installiert wurde, können wir überprüfen, ob das Gerät nun korrekt von dem Betriebssystem erkannt wird. Dazu öffnen wir den Geräte-Manager von Windows. Unser Android Gerät muss für diesen Schritt am PC über USB angeschlossen sein.

  1. In der Windows 10 Taskleiste klicken wir auf das Suchfeld Windows durchsuchen.
  2. Darin geben wir den Suchbegriff Geräte-Manager ein.
  3. Anschließend klicken wir auf das angezeigte Suchergebnis Geräte-Manager.
android_device_verbinden_geraetemanager

Geräte-Manager in Windows 10 starten

Es öffnet sich nun der Geräte-Manager von Windows 10 in einem eigenen Programmfenster. In dem Geräte-Manager sollte unser Android Gerät bereits unter Android Phone oder USB-Geräte als Android ADB Interface oder ADB Interface aufgeführt sein. Die tatsächliche Bezeichnung variiert je nach angeschlossenem Android Gerät.

In der unteren Abbildung ist der Geräte-Manager von Windows 10 dargestellt:

android_device_geraete_manager

Unser Testgerät wird als Samsung Android ADB Interface unter Samsung Android Phone aufgeführt

Unser verwendetes Testgerät, ein Samsung Galaxy S8, wird im Geräte-Manager von Windows 10 unter der Kategorie SAMSUNG Android Phone als SAMSUNG Android ADB Interface aufgeführt. So ähnlich sollte es auch bei eurem Android Gerät aussehen.

Unser Android Gerät wird nun korrekt vom Betriebssystem unseres Entwicklungs-PCs erkannt und ist im Geräte-Manager ordnungsgemäß aufgeführt. Somit können wir nun eine Verbindung zu unserem Testgerät über die Android Debug Bridge aufbauen. Dies werden wir als Nächstes durchführen.

3.2 Ansteuern des Android Geräts über die Android Debug Bridge

Wir werden nun eine Verbindung zu unserem Testgerät über die Android Debug Bridge aufbauen, um später mit ihrer Hilfe unsere App auf dem Gerät zu installieren. Dabei werden wir auch die Android Debug Bridge, ein sehr wichtiges Entwicklungswerkzeug, näher kennenlernen.

3.2.1 Was ist die Android Debug Bridge?

Die Android Debug Bridge (ADB) ist ein vielseitiges Befehlszeilen-Programm, welches für die Kommunikation mit Android Geräten eingesetzt wird. Die ADB ermöglicht die Kommunikation mit virtuellen und auch physikalischen Android Geräten. Mit ihrer Hilfe können Apps auf dem Testgerät installiert und analysiert werden. Dies kann direkt aus Android Studio heraus oder über die Kommandozeile erfolgen.

Die ADB ist als ein Client-Server Programm implementiert und besteht aus den folgenden drei Komponenten:

  • Einem Client – Über den Client werden die Befehle gesendet. Er wird auf dem Entwicklungssystem, also dem PC, ausgeführt.

  • Einem Server – Der Server verwaltet die Kommunikation zwischen dem Client und dem Daemon. Der Server wird als Hintergrundprozess auf dem Entwicklungssystem ausgeführt.

  • Einem Daemon – Die Befehle des Clients werden von dem Daemon auf dem Android Gerät ausgeführt. Der Daemon wird als Hintergrundprozess auf dem Android Gerät ausgeführt.

Der ADB Client kann über die Kommandozeile durch Aufrufen eines ADB-Befehls gestartet werden. Wird der ADB Client gestartet, prüft er als Erstes, ob ein ADB Server Prozess bereits im Hintergrund ausgeführt wird. Ist dies nicht der Fall, startet der Client einen Server Prozess. Der gestartete ADB Server überwacht den lokalen TCP-Port 5037 und wartet auf Befehle von ADB Clients. Alle Clients benutzen den Port 5037 für die Kommunikation mit dem Server.

3.2.2 Das Android Gerät über die Android Debug Bridge verbinden

Die Verbindung zum Android Gerät kann auf zwei Arten mittels der Android Debug Bridge hergestellt werden. Entweder manuell über die Kommandozeile oder automatisch mit Hilfe von Android Studio. Wir werden zunächst die Verbindung zum Android Gerät über die Kommandozeile herstellen, indem wir einen ADB Client in der Kommandozeile starten.

Da sich das ADB Programm in dem AndroidSDK/platform-tools/ Ordner befindet, müssen wir zuerst zu diesem Ordner in der Eingabeaufforderung (Kommandozeile) von Windows 10 navigieren.

Dazu öffnen wir die Eingabeaufforderung als Administrator:

  1. Zuerst drücken wir die Windows-Taste und geben Eingabeaufforderung als Suchbefehl ein.
  2. Danach klicken wir mit der rechten Maustaste auf den oberen Eintrag Eingabeaufforderung.
  3. In dem aufklappenden Kontext-Menü klicken wir auf Als Administrator ausführen.
intel_haxm_eingabeaufforderung

Ausführen der Windows 10 Eingabeaufforderung als Administrator

Es wird nun automatisch der Zustimmungs-Dialog der Benutzerkontensteuerung von Windows eingeblendet. Dieser müssen wir zustimmen, um die Eingabeaufforderung als Administrator ausführen zu können.

Anschließend öffnet sich die Eingabeaufforderung in einem eigenen Fenster:

navigieren_zur_adb

Navigieren in das Verzeichnis des ADB Programms in der Kommandozeile

In der Eingabeaufforderung navigieren wir nun in das Verzeichnis AndroidSDK/platform-tools/, in welchem sich das ADB Programm befindet. Der Befehl dir (Markierung A) listet die Dateien und Unterordner des Verzeichnisses auf.

In der oberen Abbildung ist auch der Pfad des AndroidSDK/platform-tools/ (Markierung B) zu sehen. Bei euch ist der Pfad wahrscheinlich anders. Er ist abhängig davon, welches Verzeichnis ihr bei der Installation von Android Studio als Android SDK Installation Location angegeben habt.

Auch das ausführbare ADB Programm adb.exe (Markierung C) wurde in der oberen Abbildung markiert. Wir werden es im nächsten Arbeitsschritt nutzen, um eine Verbindung zum Android Gerät herzustellen. Dazu muss das Gerät nun unbedingt an den PC über USB angeschlossen werden.

Achtung: Für die nächsten Arbeitsschritte muss das Android Gerät am PC per USB angeschlossen und der Bildschirm des Geräts die ganze Zeit entsperrt sein. Das Gerät muss sich also die ganze Zeit im Wach-Zustand befinden.

Wir geben nun den Befehl adb devices (Markierung D) in der Kommandozeile ein:

adb_devices

Angeschlossene Android Geräte mit dem Befehl adb devices auflisten

Durch den ADB-Befehl adb devices wird automatisch der ADB Server gestartet. Anschließend werden die angeschlossenen Android Geräte aufgelistet. In unserem Fall ist ein Android Gerät per USB angeschlossen, welches jedoch noch nicht für die Debugging-Verbindung zugelassen wurde. Dies wird uns mit unauthorized (Markierung E) angezeigt.

rsa_handshake_s8

USB-Debugging auf dem Android Gerät zulassen

Auch auf dem angeschlossenen Android Gerät sollte sich jetzt etwas getan haben.

Es sollte nun der Dialog USB-Debugging zulassen?, siehe Abbildung rechts, angezeigt werden. Damit der Dialog auch angezeigt wird, muss der Bildschirm vorher entsperrt gewesen sein, das Android Gerät sich also im Wach-Zustand befunden haben.

Hinweis: Wird der Dialog USB-Debugging zulassen? nicht auf dem Android Gerät angezeigt, sollte das USB Kabel noch einmal aus dem Gerät gezogen werden. Anschließend ist das Android Gerät anzuschalten und dessen Bildschirm zu entsperren. Wenn man nun das Gerät wieder an das USB Kabel anschließt, sollte der Dialog USB-Debugging zulassen? angezeigt werden. Ist dies immer noch nicht der Fall, hilft es manchmal den ADB Server manuell zu starten.

Der angezeigte Dialog ist ein Schutzmechanismus, den alle Android Geräte ab Android 4.2.2 besitzen. Der Mechanismus schützt vor unberechtigten Zugriffen auf das Gerät. Durch ihn wird sichergestellt, dass kein USB-Debugging und andere ADB-Befehle ausgeführt werden können, bevor nicht die Erlaubnis dazu explizit gegeben wurde.

Wenn wir den Dialog bestätigen, wird USB-Debugging auf dem Android Gerät erlaubt. Somit kann von dem Computer, zu dem der angezeigte RSA-Schlüssel-Fingerabdruck (RSA Key) gehört, USB-Debugging auf dem Android Gerät durchgeführt werden.

Wir werden nun USB-Debugging erlauben und den Dialog bestätigen. Damit wir in Zukunft diesen Dialog nicht bei jedem Verbinden erneut bestätigen müssen, haken wir auch das Kästchen „Von diesem Computer immer zulassen“ an. Anschließen bestätigen wir den Dialog durch Drücken des OK Buttons.

Da wir nun das USB-Debugging erlaubt haben, ist unser PC autorisiert mit dem angeschlossenen Android Gerät zu kommunizieren. Dies können wir überprüfen, indem wir nochmals den ADB-Befehl adb devices in der Kommandozeile ausführen, siehe folgende Abbildung:

adb_devices_autorisiert

Das angeschlossene Android Geräte ist nun verbunden

Das angeschlossene Android Gerät wird jetzt als device (Markierung F) aufgeführt. Somit können wir USB-Debugging auf dem Gerät durchführen. Wir sind nun in der Lage mit Hilfe von ADB-Befehlen unser physikalisches Android Gerät anzusteuern und die eigene Android App darauf zu installieren.

Dies werden wir auch als Nächstes tun. Dazu verlassen wir die Kommandozeile und öffnen Android Studio.

4. Ausführen der App auf dem Android Gerät

Für die Installation unserer App auf dem Android Gerät werden wir Android Studio verwenden. Wir öffnen daher unser Android Projekt in Android Studio.

Hinweis: Für die nächsten Arbeitsschritte muss die im vorherigen Abschnitt hergestellte Verbindung zwischen Android Gerät und Entwicklungssystem bestehen bleiben. Das Android Gerät also am PC per USB angeschlossen und der Bildschirm des Geräts die ganze Zeit entsperrt bleiben.

Nachdem unser Android Studio Projekt geöffnet wurde, überprüfen wir den Status der angeschlossenen Geräte. Dazu lassen wir das Logcat Tool Window durch eine Klick auf den Logcat Button (Markierung A) aufklappen oder öffnen es über die obere Menüleiste, indem wir auf View > Tool Windows > Logcat klicken:

logcat_tool_window

Unser Android Gerät wird im Logcat Tool Window als SAMSUNG SM-G950F aufgeführt

Das Android Smartphone oder Tablet sollte jetzt in dem Logcat Tool Window unter Devices, wie in der oberen Abbildung zu sehen, aufgeführt sein. In unserem Fall wird es als Samsung SM-G950F Android 8.0.0, API 26 (Markierung B) dort gelistet.

Wenn auch euer Android Gerät im Logcat Tool Window angezeigt wird, dann wurde es korrekt erkannt und die ADB-Verbindung ist autorisiert. Somit kann die App auf das Android Gerät installiert werden.

Hinweis: Falls anstelle der Gerätebezeichnung etwas der Art ce01182191ee4f3301 [OFFLINE] steht, muss der Dialog USB-Debugging zulassen? auf dem Android Gerät erneut bestätigt werden. Danach sollte es als erkanntes Android Gerät, wie in der oberen Abbildung dargestellt, aufgeführt sein.

Die Installation der App auf dem angeschlossenen Gerät wird von Android Studio übernommen. Dies ist möglich, da in Android Studio die Android Debug Bridge integriert ist und somit ADB-Befehle innerhalb der Entwicklungsumgebung ausgeführt werden können.

Wir starten nun den Installationsprozess unserer App auf das angeschlossene Android Gerät über die obere Menüleiste, indem wir auf Run > Run 'app' klicken:

run_app

Die Android App über die obere Menüleiste mit Run > Run ‚app‘ starten

Die App wird nicht direkt gestartet. Es ist noch ein weiterer Zwischenschritt notwendig. Nachdem wir auf den Run 'app' Menüeintrag geklickt haben, öffnet sich der Select Deployment Target-Dialog, in dem wir das Android Gerät festlegen, auf dem unsere App ausgeführt werden soll. Dabei können wir aus den verbundenen bzw. verfügbaren virtuellen und physischen Android Geräten auswählen.

Wir wählen nun das angeschlossene Android Gerät aus, welches unter dem Punkt Connected Devices aufgeführt ist. In unserem Fall wählen wir das Samsung SM-G950F (Android 8.0.0, API 26) aus und klicken anschließend auf den OK Button:

select_android_device

Auswählen des angeschlossenen Android Geräts als Zielgeräts auf dem die App ausgeführt werden soll

In unserem Fall erscheint nun der Instant Run-Dialog, da auf unserem physikalischen Android Gerät die Android 8.0.0 Version (Android API 26) ausgeführt wird und wir diese Android Platform nicht auf unserem Entwicklungsrechner installiert haben.

Wir benötigen die Instant Run-Funktion für das Testen unserer App auf dem Android Gerät nicht und klicken daher auf den Proceed without Instant Run Button:

instant_run

Wir wählen Proceed without Instant Run aus

Nun wird unser Android Projekt im Hintergrund neu erstellt und anschließend die Android App auf dem angeschlossenen Android Gerät installiert. Diesen Vorgang können wir im Run Tool Window von Android Studio überwachen.

Nachdem die App auf dem Android Gerät installiert worden ist, wird sie mittels Konsolenbefehl automatisch von Android Studio gestartet. Wenn alles funktioniert hat, ist unsere App jetzt auf dem angeschlossenen Gerät gestartet worden und wir erhalten als Text folgenden String angezeigt: Hello CodeYourApp World!

Wie unsere App auf dem Android Gerät aussieht, ist in der unteren Abbildung dargestellt:

screenshot_app_s8

Unsere App wird jetzt auf dem angeschlossenen Android Gerät ausgeführt

Da unsere Android App auf dem angeschlossenen Android Gerät installiert wurde, können wir sie auch selbst starten. Dazu einfach das Alle Apps-Menü auf dem Android Gerät öffnen und anschließend auf das Symbol unserer Android Anwendung.

Die App bleibt auf dem Android Gerät installiert. Wir können also unsere Anwendung wie eine normal installierte Android App starten. Das Starten erfolgt intuitiv über das Alle Apps-Menü des Android Geräts. Die App kann wie eine ganz normale Anwendung gestartet, verschoben und auch deinstalliert werden.

screenshot_app_installed_s8

Unsere Android App ist auf dem angeschlossenen Android Gerät installiert

In der oberen Abbildung ist das Symbol unserer Zitate-App im Alle Apps-Menü des Android Geräts zu sehen. Mit einem Klick auf das Zitate-Symbol können wir unsere eigene App vom Android Gerät aus starten.

Zusammenfassung

In dieser Lektion haben wir unsere App auf einem physikalischen Android Gerät installiert. Dazu mussten wir vorher das USB-Debugging für das Android Gerät zu aktivieren, da standardmäßig keine eigenen Apps auf dem Gerät per USB installiert werden können.

Das USB-Debugging haben wir folgendermaßen aktiviert:

  1. Freischalten und Aktivieren der versteckten Entwickleroptionen auf dem Android Gerät.
  2. Aktivieren des Debugging-Modus in den Entwickleroptionen.

Nachdem USB-Debugging für das Android Gerät zugelassen wurde, haben wir mit Hilfe der Android Debug Bridge eine autorisierte Verbindung zum Gerät über USB aufgebaut. Dabei haben wir den Aufbau und die Funktionsweise der ADB näher kennengelernt. Abschließend haben wir unsere Android App auf das angeschlossene Gerät übertragen und darauf ausgeführt.

Nun können wir unsere App sowohl im Android Emulator auf einem virtuellen Android Gerät als auch auf einem physikalischen Android Gerät testen. Jede der beiden Testmöglichkeiten hat ihre Vor- und Nachteile. Der Android Emulator ermöglicht das effektive Testen auf vielen verschiedenen Zielplattformen. Die Installation der App auf ein angeschlossenes Android Gerät ermöglicht das Testen unter realen Bedingungen.

Als Nächstes werden wir wieder an unserer eigenen Android App weiterarbeiten und ihr eine Layout-Ressource hinzufügen. Dabei erfahren wir, wie in Android die visuelle Struktur der grafischen Benutzeroberfläche definiert wird.

Weiterführende Literatur




Comments 45

  1. Hab nen Samsung Galaxy S3 neo, welches nicht aufgeführt ist.
    Hab die Treiber fürs S3 genommen, trzd. wird mein Handy nicht beim Geräte-Manager aufgeführt.
    Pls send help. 😀

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.