zurück zum Artikel

Google stellt Android-Entwickler auf Android Studio um. Das frisch in Version 2.0 erschienene Werkzeug bietet viele, teilweise versteckte Tricks zur Steigerung der Produktivität.

Android Studio ist eine kostenfreie, auf Android beschränkte Variante der kommerziell vertriebenen Entwicklungsumgebung IntelliJ IDEA. Sie bringt Funktionen mit, die Anwender sonst nur gegen Bezahlung erhalten.

Der wichtigste Unterschied zu Eclipse ist ein komplett geändertes Buildsystem namens Gradle, mit dem Entwickler jedoch nicht unbedingt in Kontakt kommen. Wegen des immensen Funktionsumfangs von Gradle beschränkt sich der Artikel auf die IDE.

Workspace Ahoi

Eclipse lagert Nutzereinstellungen und Applikationen in einem als Workspace bezeichneten Ordner. Bei IntelliJ heißt die Zusammenfassung Projekt, die Unterapplikationen nennt man Module.

Auf Android Studio umsteigende Entwickler klagen gern über die Projektflut. Das liegt daran, dass der Menüeintrag File | New Project seinem Namen gerecht wird und ein neues Projekt anlegt, was einem neuen Eclipse-Workspace entspricht. Wer ein vorhandenes Projekt um eine weitere Applikation erweitern möchte, muss stattdessen File | New Module auswählen.

Nach dem Abarbeiten des Assistenten wartet auf Entwickler normalerweise ein kleiner Schock: Es dauert bis zu 30 Sekunden, bis das zweite Projekt erscheint.

Wer mit mehreren Projekten gleichzeitig arbeiten möchte, muss das Verhalten von File | Open in der Rubrik Appearance&Behavior | System Settings | Project Opening umstellen. Steht das Attribut auf "Open project in the same window", öffnet Android Studio neue Projekte im vorhandenen Fenster – "Open Project in new window" behebt das Problem. Als (weniger komfortable) Alternative dazu bietet sich das Starten mehrerer Instanzen an – jedes Android Studio-Fenster ist auf ein Projekt beschränkt.

Nützliche Filter

Projekte ufern im Laufe der Zeit aus: Eine aus mehreren tausend Codedateien bestehende Applikation ist heute keine Seltenheit mehr. Android Studio vereinfacht die Navigation an mehreren Stellen. Erstens lässt sich die in Abbildung 2 gezeigte Zeile anklicken – die linke Maustaste öffnet ein Kontextmenü, das die Inhalte der Ordnerebene anbietet.

In so gut wie allen Fenstern inklusive der Kontextmenüs reduziert die Eingabe eines Filter-Strings die Ergebnisliste (s. Abb. 3).

Leider ist das direkte Eintippen von Filterstrings nur Teil der Miete: Bei komplexeren Dialogen wie der Projektübersicht gilt der Filter für die aktuell angezeigten Elemente. Das bedeutet, dass die in zusammengeklappten Teilen des Baums enthaltenen Informationen unsichtbar bleiben.

Wer das geöffnete Projekt als Ganzes durchsuchen möchte, nutzt stattdessen ein als "Double Shift" bezeichnetes Verfahren: Ein schnelles zweimaliges Drücken der Umschalttaste holt das in der Abbildung 4 gezeigte blaue Fenster auf den Bildschirm.

Neben der allumfassenden Suche bietet IntelliJ IDEA einige Suchfunktionen an, die die generierten Resultate auf bestimmte Objektgattungen beschränken. Strg + N öffnet ein Fenster zum Durchsuchen des Projekts nach Klassennamen. Die Recherche nach Dateinamen lässt sich mittels Strg + Shift + N aktivieren. Strg + Alt + Shift + N sucht nach Symbolen – neben Klassen sind Variablen, Konstanten und Methoden legitime Ziele.

Strg + Shift + A öffnet ein Suchfenster, das sich auf die Namen der im Benutzerinterface der IDE befindlichen Aktionen konzentriert. Beispielsweise ist das Öffnen das Preferences-Menü durch Strg + Shift + A und die anschließende Eingabe von "Pre" möglich.

Editorhilfen

Bösartiger Bearbeiter

IntelliJ IDEA bietet zwei Formen von Autovervollständigung: Neben dem stets aktivierten und notfalls per Strg + Leertaste aufrufbaren Fenster gibt es eine als "Smart Type" bezeichnete Variante, die nur bei Bedarf per Strg + Shift + Leertaste anspringt. Sie unterscheidet sich vom gewöhnlichen Vertreter dadurch, dass sie eine umfangreichere Analyse des umgebenden Codes durchführt und auch mehrstufige Ergebnisse liefert. Die Unterschiede zwischen den beiden Methoden zeigen die beiden Abbildungen 5 und 6.

Bei der Fehlersuche hilft ein Blick hinter die Kulissen. Android Studio bietet dafür zwei Tastenkombinationen: Strg + B öffnet die Deklaration einer Methode und Strg + Alt + B die Implementierung. Die IDE greift bei Letzterem auf einen Dekompilator zurück, der Code aus .jar-Dateien zurückgewinnt.

JavaDoc ist Segen und Fluch zugleich: Während seine Verwendung in Bibliotheken eine wesentliche Erleichterung des Lebens für Entwickler darstellt, hat das fanatische Einfordern von Kommentaren im universitären Bereich zur Entstehung automatischer Dokumentations-Plug-ins beigetragen. IntelliJ IDEA nutzt die Inhalte, um im Editor hilfreiche Informationen einzublenden. Das Drücken von Strg + Q zeigt den JavaDoc-Eintrag zum Element unterhalb des Cursors an, während Strg + P eine Liste der erlaubten Parameterpermutationen einer bestimmten Funktion anzeigt.

Zur Steigerung der Produktivität existieren einige Shortcuts, die Code zeilenweise verarbeiten: Strg + D dupliziert die aktive Zeile, und Shift + Entf verschiebt sie in die Zwischenablage. Das Einfügen erfolgt wie in den meisten Anwendungen per Strg + V. Strg + Shift + V bietet eine Liste der letzten fünf Zwischenablageninhalte zum Einfügen an.

Markierte Codepassagen lassen sich durch Tab und Shift + Tab nach links oder rechts verschieben. Strg + / kommentiert die aktuelle Passage aus, während Strg + Shift + / sie reaktiviert. Mit QWERTZ-Tastaturen arbeitende Entwickler müssen dazu auf den numerischen Tastenblock ausweichen, da das /-Zeichen im deutschen Tastaturlayout bereits das Drücken der Shift-Taste erfordert.

Das automatische Kommentierwerkzeug kollidiert gelegentlich mit im Code enthaltenen, wie folgende Routine dokumentiert, die sowohl /*- als auch //-Kommentardelimeter verwendet:

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar
    getMenuInflater().inflate(R.menu.menu_main, menu);
    /*Das ist ein Testkommentar*/
    return true;
}

Nach dem erstmaligen Drücken von Strg + / präsentiert sich der Codeblock folgendermaßen:

//    @Override
//    public boolean onCreateOptionsMenu(Menu menu) {
//
//        // Inflate the menu; this adds items to the action bar
//        getMenuInflater().inflate(R.menu.menu_main, menu);
//        /*Das ist ein Testkommentar*/
//        return true;
//    }

Wer die Routine im nächsten Schritt durch Drücken von Strg + Shift + / zu reaktivieren sucht, bekommt vom Editor ein unerwartetes Ergebnis präsentiert:

/*    @Override
//    public boolean onCreateOptionsMenu(Menu menu) {
//        // Inflate the menu; this adds items to the action bar
//        getMenuInflater().inflate(R.menu.menu_main, menu);
//    *//*Das ist ein Testkommentar*//*
//        return true;
//    }*/

Weiteres Aktivieren der beiden Tastenkürzel verbessert die Situation nicht. Wer seinen Code IntelliJ-freundlich gestalten möchte, sollte Kommentare in Routinen immer nur mit // einleiten und Code mit vorhandenen mehrzeiligen Kommentaren nur von Hand deaktivieren.

Fehlersuche

Kreative Jagd im Editor

Fehlersuche ist eine entscheidender Teil des Entwicklungsprozesses. Der Autor implementierte vor vielen Jahren eine Filter-Pipeline, die auf Gedeih und Verderb nur mit kleineren Datenmengen funktionieren wollte. Das Finden der Ursache nahm einige Zeit in Anspruch: Es lag im Endeffekt daran, dass das Freigeben von Ressourcen in einem Sonderfall unterblieb.

Strg + Shift + F7 hebt alle Austrittspunkte einer Methode blau hervor. Die Suche nach den Quellen bestimmter Exceptions lässt sich über dieselbe Tastenkombination bewerkstelligen, indem der Cursor über dem throws-Befehl steht.

Wer bestimmte Zeichenfolgen im Code sucht, drückt auf Strg + F. Nach der Eingabe des Suchstrings hebt der Editor relevante Passagen gelb hervor; F3 und Shift + F3 wechseln zwischen den einzelnen Resultaten.

Zu guter Letzt gibt es in der IDE drei spezielle Codegeneratoren, die sich auf das Erzeugen von Routinenskeletten spezialisiert haben. Das Drücken von Strg + O öffnet eine Liste aller in der Superklasse enthaltenen Funktionen und erzeugt auf Wunsch auch Methodenskelette samt @Override-Deklaration.

Alt + Einfg aktiviert einen Member-Generator, der Setter, Getter, Konstruktoren, toString()-Funktionen und anderen Standardelementen erzeugt. Fehlende Methoden eines Interfaces lassen sich per Strg + I nachträglich implementieren.

Lasst uns fauchen!

Bei der Arbeit an größeren Projekten hilft eine Ablage zum Zwischenspeichern aktuell nicht benötigten Codes. IntelliJ IDEA bildet sie über Scratches ab: Text- beziehungsweise Codedateien, die durch Strg + Shift + Alt + Einfg ins Leben gerufen werden.

Eine Liste der aktuell aktiven Scratches findet sich im Projektfenster, wenn es – wie in Abbildung 8 gezeigt – im Scratch-Auflistungsmodus ist.

Vorlagen

Intelligente Vorlage

Applikationen zur Verwaltung mehrerer Clipboards finden in jedem Buch zur Effizienzsteigerung für Programmierer Erwähnung – klassische Zwischenablagen leiden darunter, dass sich der in ihnen befindliche Text nicht oder nur schwer an die aktuellen Gegebenheiten anpassen lässt.

Live Templates stellen eine Art permanente Zwischenablage mit diversen intelligenten Funktionen dar. IntelliJ unterteilt die Templates in folgende drei Gruppen:

• Simple Live Template: einfache Vorlage, die an der vom Cursor markierten Stelle erscheint.
• Parametrized Live Template: Vorlage, die beim Einfügen mit Template-Parametern konfiguriert wird.
• Surround Live Template: spezielle Variante des Simple Live Template, die den markierten Code umfasst.

Die Aktivierung des Live-Template-Systems erfolgt durch Drücken von Strg + J; Android Studio blendet daraufhin eine Abkürzungsliste ein. Alternativ dazu können Entwickler die gewünschte Abkürzung eingeben und das Template-System im Anschluss mit Strg + J aktivieren.

Beim Einfügen eines Parametrized Live Templates zeigt IntelliJ IDEA die Template-Variablen in roten Rechtecken an – die folgende Abbildung zeigt, wie die IDE die Laufvariable einer Iteration hervorhebt. Das Bearbeiten des hervorgehobenen Rechtecks wirkt sich automatisch auf den Rest des Templates aus.

Surround Live Templates lassen sich alternativ mit Strg + Alt + J einfügen. Der relevante Code muss dafür im Editor markiert sein.

Vorlage Marke Eigenbau

Google stattet Android Studio mit einigen Live Templates aus, die häufige Aufgaben wie das Absetzen von Meldungen via Log.* erleichtern. Deren Anatomie ist interessant, da sie einige wichtige Aspekte des Template-Systems näher beschreibt.

Nach dem Klick auf File | Settings und der Auswahl der Rubrik Editor | Live Templates gruppiert IntelliJ IDEA die Vorlagen in Gruppen: AndroidLog | LogI ist als android.util.Log.i(TAG, "$METHOD_NAME$: $content$"); deklariert.

Edit Variables öffnet ein Pop-up-Fenster, das die einzelnen Variablen auflistet. Die IDE bietet einige Dutzend vordefinierte Variablen an, die sie im Rahmen der Extraktion automatisch mit Kontextinformationen befüllt – eine vollständige Liste steht bei JetBrains https://www.jetbrains.com/idea/help/live-template-variables.html#pdtv zum Download bereit.

IntelliJ IDEA hebt Variablen normalerweise nur dann mit einem roten Rechteck hervor, wenn sie im Template mindestens zweimal vorkommen.

Automatische Verbesserung

Refactoring ist spätestens seit dem Aufkommen von Extreme Programming in aller Munde – es gibt kaum eine IDE, die Entwickler nicht beim Anbringen von Verbesserungen an bestehenden Codebasen unterstützt.

Die in IntelliJ IDEA enthaltenen Verbesserungsfunktionen sind in zwei Gruppen zusammengefasst. Unter Refactor | * findet sich eine Liste aller möglichen Verbesserungen. Das per Rechtsklick auf ein bestimmtes Element aufrufbare Kontextmenü beschränkt die angebotenen Optionen.

Die IDE arbeitet erfahrungsgemäß äußerst zuverlässig. Dennoch sollten Entwickler ihren Code vor dem Refactoring sichern – im Idealfall nutzen sie dazu ein Versionskontrollsystem.

Versionsverwaltung

CVS oder lokal?

Android Studio ist von Haus aus zur Integration mit CVS, Subversion, Git und Mercurial befähigt: Wer eines der vier verbreiteten Versionskontrollsysteme nutzt, kommt ohne Plug-in aus. Die Aktivierung des jeweiligen Moduls erfolgt durch Anklicken von VCS | Enable Version Control history.

Falls die Verbindung zu einem externen Server nicht möglich ist, hilft Android Studio mit der "Local History" aus. Das ist ein Protokoll, in dem die Umgebung Speicherungen und Änderungen von Dateiinhalten lokal vermerkt. Rechtsklick | Local History zeigt die gespeicherten Inhalte an.

Veraltete Versionen liegen in einem Unterverzeichnis des Nutzerprofils und sind nicht Teil des Projektordners. Wer die in der Local History liegenden Dateien trotzdem löschen möchte, führt File | Invalidate Caches/Restart aus. Der eigentliche Löschprozess beginnt erst beim Neustart der IDE. Anschließend ist zudem ein kompletter Rebuild aller Projekte erforderlich. Dass Aktualisieren der IDE beseitigt den Inhalt der Local History ebenfalls.

Jage den Fehler!

Versionskontrollsysteme sind besonders hilfreich, wenn es an die Bekämpfung durch Änderungen eingeführter Fehler geht. Der Gutteil der Bugs fällt indes scheinbar vom Himmel. IntelliJ bietet einige Funktionen zum Aufspüren dieser Fehler.

Zu erwähnen ist die permanente Darstellung der Variableninhalte: Wenn der Debugger ein laufendes Programm anhält, zeigt das Tool den aktuellen Wert direkt neben der Deklaration an.

Das in der folgenden Abbildung gezeigte Variablenfenster ist zweigeteilt: Die Liste auf der linken Seite zeigt die einzelnen Stackframes beziehungsweise aktiven Methoden an. Entwickler können durch Markieren des Frames den Kontext des aktiven Elements in den mittleren Bereich holen und dort die Inhalte von Structs und anderen komplexen Strukturen aufschlüsseln.

Über die Watches-Liste festgelegte Ausdrücke berechnet der Debugger bei jedem Anhalten des Programms. Das ist unter anderem zur Überwachtung von Variablen sinnvoll. Das Errichten ausgefeilter Breakpointstrukturen erweist sich in der Praxis insofern als zweischneidiges Schwert, als sie viele Klicks bei jedem geplanten Anhalten erfordern. Die Option "Mute all Breakpoints" löst das Problem elegant.

Wer beim Debugging die Übersicht verliert, erhält mit der Run to Cursor-Funktion die Kontrolle zurück. Sie weist den Debugger an, die Applikation so lange laufen zu lassen, bis sie den Code unter dem Cursor erreicht.

Varianten und Fazit

Varianten des Studios

Google bietet vier Varianten an: Wer Android Studio herunterlädt, bekommt die Stable Version. Die im Artikel gezeigten Screenshots entstanden mit dem beim Schreiben aktuellen Stable Android Studio 1.5.1 unter einer 64-Bit-Variante von Ubuntu 14.04LTS .

Wer neue Features vor dem offiziellen Release ausprobieren möchte, kann seine IDE unter File | Settings | Appearance & Behavior | System Settings | Updates auf einen der anderen Channels umstellen. Die Dev- und Canary-Produkte können jedoch mitunter äußerst fehleranfällig sein.

Android Studio bietet unter Help | Productivity Guide eine Liste besonders hilfreicher Features, die auch die bisherige Verwendungshäufigkeit anzeigt. Da der Dialog Funktionen im Allgemeinen nach ihrer Art gruppiert, finden Entwickler Alternativen und Varianten gern verwendeter Kommandos.

Unterbrechungsfrei unterwegs

Die Implementierung der besprochenen Funktionen belastet die CPU. Wer unterwegs arbeitet, ist mitunter bereit, zugunsten längerer Akkulaufzeit auf automatische Codeüberprüfung zu verzichten. Die IDE zeigt den durch File | Power Save Mode aktivierten Stromsparmodus durch das in der folgenden Abbildung dargestellte Männchen an.

Fazit

Der Mensch ist ein Gewohnheitstier. Der Informatiker ist – frei nach Paul Grahams lesenswertem Buch "Hackers & Painters" – ein Übermensch und damit konsequenter Weise ein noch größeres Gewohnheitstier, das auf Änderungen mit besonderer Bissigkeit reagiert.

Die Umstellung von Eclipse auf Android Studio bringt fraglos das eine oder andere Wuterlebnis mit sich. Entwickler haben jedoch kaum eine andere Wahl: Wer nicht auf iOS oder Qt umsteigen möchte, muss sich ob der Umstellung auf Gradle früher oder später mit Android Studio anfreunden. Vielleicht helfen die im Artikel aufgeführten Tricks, das eine oder andere graue Haar zu vermeiden.

Tam Hanna
befasst sich seit der Zeit des Palm IIIc mit Programmierung und Anwendung von Handheldcomputern. Er entwickelt Programme für diverse Plattformen, betreibt Onlinenews-Dienste zum Thema und steht für Fragen, Trainings und Vorträge gern zur Verfügung.

(rme [1])

URL dieses Artikels:
https://www.heise.de/-3173614

Links in diesem Artikel:
[1] mailto:rme@ix.de

Copyright © 2016 Heise Medien