Googles neue IDE im Test

Finsternis über Eclipse
Kommentare

Eclipse und die Entwicklung von Handcomputersoftware gehen seit jeher Hand in Hand. Schon zu Zeiten des seligen Palm OS nutzten Programmierer eine PODS genannte Entwicklungsumgebung, die auf dem quelloffenen System der Apache Foundation basierte.

Auf der Hausmesse I/O sorgte Googles Ankündigung einer neuen IDE für enorme Aufregung. Die Android Studio genannte Entwicklungsumgebung basiert auf der von JetBrains vermarkteten Software IntelliJ – diese seit 2001 verfügbare Software hat sich im Laufe der Jahre eine geradezu fanatische Kundschaft erarbeitet.
Diese führt im Wesentlichen zwei Gründe an. Erstens sei IntelliJ schneller und speichersparender, zweitens arbeiten die Such-, IntelliSense- und Refactoring-Werkzeuge zuverlässiger. Dabei handelt es sich mit Sicherheit auch um subjektive.

Erste Schritte

Google bietet Android Studio für Linux, Mac OS X und Windows an. Der Download findet sich für alle drei Systeme hier (400 MB). Während der Downloadzeit sollten Sie sich mit dem Gedanken vertraut machen, dass diese IDE noch in sehr früher Betaphase ist. Google weist explizit darauf hin, dass viele Funktionen noch unfertig sind. Zudem besteht das Risiko von Bugs und Macken – wenn Sie damit nicht leben möchten, sollten Sie im Produktiveinsatz unbedingt weiter auf Eclipse setzen.
Um die Serverressourcen des Unternehmens nicht über Gebühr zu strapazieren, bietet Google derzeit nur die Version 0.1.1 zum Download an. Nach dem Abarbeiten des Installations-Wizards sollten Sie die IDE starten. Die Frage nach dem Import von Einstellungen verneinen Sie. Taucht nach der Installation die Frage nach einem Update auf ihrer Maschine aus irgendeinem Grund nicht auf, so klicken Sie nach dem Öffnen eines Projekts auf Help | Check for Update, um die Aktualisierungsfunktion der Software anzuwerfen.

Projekt vs. Workspace

Der erste wichtige Unterschied zwischen den beiden Systemen offenbart sich gleich nach dem Start. Während Eclipse alle auf der Anlage befindlichen Projekte in einem Workspace zusammenfasst, präsentiert IntelliJ nach dem Laden einen Projektauswahl-Wizard. Die eigentliche Entwicklungsumgebung erscheint erst dann, wenn ein Projekt zur Bearbeitung freigegeben ist – klicken Sie auf New Project, um ein Skelett zu erstellen. Eventuell aufscheinende Firewall-Warnungen müssen bejaht werden, da die IDE mit einigen Subkomponenten ausschließlich per TCP/IP kommuniziert. Zudem ist es ratsam, eine Internetverbindung zu haben: manche Operationen (wie das Erstellen eines Projekts) scheitern, wenn die IDE nicht nach Hause telefonieren darf.

Eclipse blendet die Projektstrukturansicht von Haus aus ein. In IntelliJ verschwindet diese, um Platz am Bildschirm zu sparen. Zum Aufrufen klicken Sie auf den Project-Tab am linken Bildschirmrand, alternativ drücken Sie die Tastenkombination ALT+1. In Abbildung 1 sehen Sie die Struktur eines Default-Projekts. Wichtig ist, dass der Code des als „Modul“ bezeichneten Programms in einem Unterordner liegt. Sonst sind die auf den ersten Blick sichtbaren Unterschiede eher minimal.

Abb. 1: Die Projektstruktur sieht unter IntelliJ etwas anders aus

Eine Frage des Build-Systems

Eclipse nutzt im Hintergrund Ant zur Generierung der Android-Applikationen. Das altehrwürdige Build-Tool hat im Laufe der Jahre einige Haare angesetzt und ist heutigen Ansprüchen nicht mehr vollwertig gewachsen.
Google ist aus diesem Grund seit einiger Zeit dabei, auf Gradle umzusteigen. In der Dokumentation verspricht das Unternehmen unter Anderem die Automatisierung der Erstellung von komplexen Distributionen. In der Praxis würde das bedeuten, dass Ihr Projekt in Zukunft selbständig alle Subversionen generiert – das manuelle Adaptieren der Einstellungen zum Produzieren von verschiedenen APKs entfällt.
Ein weiterer wichtiger Vorteil ist die Trennung von IDE und Code. Ein .gradle-Build-File ist im Grunde genommen nur eine Textdatei. Wenn Sie die Entwicklungsumgebung ändern, hat das keinerlei Einfluss auf den Build-Prozess – im Idealfall erfolgt die Erstellung der Konfigurationsdateien ohne automatisierte Unterstützung. Der Effekt davon ist, dass das Upgraden der nun zu einem gloriosen Editor degradierten IDE um einiges einfacher fällt und weniger Zeit in Anspruch nimmt.
Zum Anpassen der Kompilation müssen Sie die build.gradle-Dateien adaptieren. Die für Ihr Projekt wichtigste Datei findet sich im /src-Verzeichnis des Moduls mit der Applikation – sie sieht im von Android Studio erstellten Beispielprojekt aus wie in Listing 1.

 

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:0.4'
  }
}
apply plugin: 'android'

dependencies {
  compile files('libs/android-support-v4.jar')
}

android {
  compileSdkVersion 17
  buildToolsVersion "17.0.0"

  defaultConfig {
    minSdkVersion 7
    targetSdkVersion 16
  }
}

Im ersten, mit buildscript beginnenden Teil des Skripts konfigurieren Sie die diversen zur Programmerstellung notwendigen Programme. Die hier gemachten Einstellungen wirken sich nur auf den Build-Prozess aus und haben auf das Endprodukt keinerlei direkte Auswirkung. In unserem Fall importieren wir ein Skript und laden eine Dependency-Datei.
Builds erfolgen in Gradle über so genannte Plug-ins. Diese kleinen Programme enthalten die erforderliche Intelligenz – je nach Sprache kommt ein anderes zum Einsatz. Beim Erstellen von Android-Apps muss das gleichnamige Modul zum Einsatz kommen; die Kompilation mit dem java-Plug-in scheitert. Im dritten Teil des Skripts wird die eigentliche Android-Kompilation deklariert. Hier stellen Sie diverse Parameter ein, die das Build-Verhalten der Werkzeuge beeinflussen.

Spielereien mit Dateien

In Codebeispielen im Internet findet sich häufig eine Build-File-Passage, die einzelne Dateien und/oder Ordner zum Build-Prozess hinzufügt. Diese ist nur dann notwendig, wenn die Ordnerstruktur ihres Projekts von der von Gradle erwarteten abweicht. Die von Android Studio selbst erstellte Struktur macht derartige Passagen überflüssig.
Google plant, über Gradle in ferner Zukunft auch das bedingte Kompilieren von verschiedenen Versionen eines Programms zu erstellen. Der dazu notwendige Konfigurationsmanager findet sich schon jetzt in Android Studio – vollständig implementiert wurde die Funktion bisher aber nicht.
Durch manuelles Editieren der Konfigurationsdateien können Sie einen Teil der enthaltenen Funktionen schon jetzt nutzen. Im Grunde genommen arbeitet Gradle mit Flavors und Types, die gemeinsam Varianten ergeben. Typen legen normalerweise fest, wie die Kompilation zu erfolgen hat (Debug oder Release). In den Flavors (engl. Begriff für Geschmacksrichtungen) erfolgt die genaue Einteilung, welche Klasse und welche Datei zu welcher Version des zu generierenden Programms gehört.
Dabei geht das Build-System sehr flexibel vor. Neben dem Inkludieren von spezifischen Versionen einer Klasse oder Ressourcendatei ist es auch möglich, die SDK-Baseline pro Datei unterschiedlich festzulegen. Ersteres ist als Schutzmaßnahme gegen Softwarepiraten hilfreich: Fehlen die für die Vollversion eines Spiels erforderlichen Daten, so ist das Umgehen des Kopierschutzes der Testversion vergebliche Liebesmühe.
Leider ist Gradle zu komplex, um in einem einzelnen Fachartikel vorgestellt zu werden. Die genaue Syntax des Build-Systems ist in der diesbezüglichen Dokumentation im Detail beschrieben.

GUI bearbeiten in Komfortabel

Android-Entwickler erstellen die grafische Benutzeroberfläche ihrer Applikationen so gut wie immer in XML – das „Zur-Laufzeit-Zusammenbauen“ aus einzelnen Klassen ist aus Performance- und aus Übersichtlichkeitsgründen aus der Mode gekommen.
Der in Eclipse integrierte Ressourceneditor ist langsam und bietet keine wirklich nützlichen Funktionen an. Android Studio genehmigt sich nach dem Anklicken einer Layoutdatei zwar auch die eine oder andere Schrecksekunde – danach ist allerdings Höchstleistung angesagt. Änderungen an Steuerelementeigenschaften wirken sich wie in Visual Studio sofort auf das Vorschaurendering der Benutzerschnittstelle aus. Klicken Sie auf den Tab Text auf der Bildschirmunterseite, um in den Quellcodebearbeitungsmodus zu gelangen. Auf der linken Seite erscheint wie gewohnt der Code des Files – rechts wird von Haus aus ein Nexus 4 eingeblendet. Selbstverständlich gilt auch hier, dass die diversen Änderungen am Code sofort in der Bildschirmdarstellung reflektiert werden.
Die Toolbar über dem Rendering des Telefons erlaubt den Zugriff auf diverse Darstellungsoptionen. Besonders witzig ist die nur auf großen Bildschirmen sinnvolle Möglichkeit der parallelen Anzeige mehrerer „Viewports“. Zum Hinzufügen eines weiteren Geräts wählen Sie das kleine „Android-Dokument“ in der oberen Bildschirmkante und klicken danach auf Preview all screen sizes. Android Studio zeigt Ihnen daraufhin sechs verschiedene Telefone an (Abb. 2).

Abb. 2: Jedes dieser Telefone enthält eine angepasste Darstellung der geöffneten Ressourcendatei

Die in der Toolbar befindlichen Optionen wirken sich immer nur auf das Telefon aus, das ganz oben links dargestellt wird. Wenn Sie eines der Handys dorthin bewegen möchten, so klicken Sie in seinen Bildschirm – der Verschiebeprozess erfolgt automatisch.

Automatische Fehlersuche

In Zeiten von Symbian OS sorgte der Begriff der statischen Analyse für Furore – ein amerikanisches Unternehmen versprach seinen Kunden, Fehler in der Codebasis mit einem automatisierten Verfahren zu finden. Aufgrund enormer Preise war die Technologie damals für Einzelentwickler kaum leistbar – in Android Studio finden Sie ein vollwertiges Analysewerkzeug.
Es lässt sich durch das Menü-Item Analyze | Inspect Code aufrufen. Neben dem bereits bekannten Android Lint enthält die IDE auch einige Sondertools, die u. a. auch auf Fehler und Unsauberkeiten in der XML-Syntax reagieren.
Die Darstellung der Resultate ist hervorragend gelungen. Jeder Fehler erscheint in einer Baumansicht unter dem für seine Detektierung zuständigen Werkzeug – das erleichtert das Ausblenden von unwichtigen Problemstellen. Automatische Codeprüfer lokalisieren oft eine Vielzahl von „Fehlerstellen“, deren Behebung außerhalb des akademischen Bereichs unökonomisch und unsinnvoll ist. Klicken Sie ein Werkzeug oder eine Datei rechts an, um sie aus zukünftigen Analyseläufen auszuschließen.

Hilfreiche Shortcuts

Eines der attraktivsten Features von IntelliJ ist die hochleistungsfähige IntelliSense-Erkennung. Diese liefert nicht nur Ergebnisse für AutoComplete – mindestens ebenso wertvoll sind die dadurch ermöglichten Shortcuts bei der Navigation zwischen Dateien und Inhalten.
Fehler erkennt das Produkt schon während der Eingabe, die relevanten Stellen erscheinen am Bildschirm in roter Schrift. Zum Beheben der Probleme platzieren Sie den Cursor über der Problemstelle und drücken dann ALT+ENTER. IntelliJ zeigt daraufhin ein Pop-up-Menü an, in dem Sie eine mögliche Korrektur auswählen dürfen. Leider gibt es keinen anderen (effizienten) Weg, um in diese Funktion zu gelangen – das Memorisieren der Tastenkombination ist Pflicht.
Selbiges gilt auch für die Funktion zur Anzeige von Parametervorschlägen. Drücken Sie STRG+P, um ein Pop-up mit den diversen Overloads der gerade bearbeiteten Funktion anzuzeigen – bis dieses Fenster von selbst erscheint, vergehen einige Sekunden.
Das Öffnen der Deklaration bestimmter Klassen erleichtert die IDE durch eine globale Suchfunktion. Drücken Sie einfach die Tastenkombination STRG+N, und geben sie im daraufhin erscheinenden Fenster den Namen des Elements ein. IntelliJ sucht daraufhin automatisch nach den Dateien, in denen sich das betreffende Konstrukt findet – sie lassen sich mit einem Klick im Editor öffnen.
Besonders nützlich ist eine als Speed Search bezeichnete Funktion. Klicken Sie in ein Fenster und geben Sie den Namen der gesuchten Ressource ein – IntelliJ beginnt automatisch, die dort angezeigten Elemente zu beschränken. Dies funktioniert mit fast allen Ansichten in der IDE.
Wollen Sie stattdessen alle Orte finden, an denen eine bestimmte Klasse oder ein bestimmtes Feld auftritt, so markieren Sie es im Editor und drücken danach auf ALT+F7. Auf der Unterseite des Bildschirms erscheint sodann ein Fenster, in dem sie alle Vorkommnisse nach Klasse und/oder Typ der Nutzung aufgelistet vorfinden.
Bei bestehender Internetverbindung integriert sich Android Studio bereitwillig in die online von Google bereitgestellte Dokumentation. Drücken Sie STRG+Q, um ein Fenster mit Informationen über das darunter befindliche Systemelement aufzurufen.
Häufig benötigte Funktionen – Stichwort toString, Konstruktor und Destruktor – generiert IntelliJ über das Create-Menü. Es lässt sich durch ALT+EINFÜGEN aufrufen; die von den Wizards erstellten Methoden offenbaren an vielen Stellen eine geradezu schockierende Menge an Eigenintelligenz. Mit STRG+O und STRG+I erstellen Sie automatisch Überschreibungen oder in einem Interface erstellte Methoden.
Als besonderes Gimmick bietet die IDE ein Shortcut-Memorysystem an. Dieses lässt sich über Help | Productivity Guideaufrufen. Es listet Funktionen auf, die das manuelle Eingeben oder Navigieren erleichtern – und zeigt auch an, wie oft Sie auf die jeweiligen Features zugreifen. Finden Sie dort einen von Ihnen häufig per Hand durchgeführten Job, so klicken Sie den Eintrag an – im darunter befindlichen Hilfsfenster erscheinen wie von Zauberhand Informationen, wie Sie die Aufgabe mit IntelliJ schneller erledigen.

[header = Codequalität verbessern]

Codequalität verbessern

Refactoring ist keine besonders angenehme Tätigkeit – es ist für die meisten Entwickler reizvoller, das Produkt um neue und witzige Funktionen zu erweitern. Trotzdem führt kein Weg an dieser lästigen Pflicht vorbei.
Erfreulicherweise bietet IntelliJ eine Vielzahl von Funktionen zur Erleichterung der Arbeit an. Zum Einbau von try/catch-Statements und/oder synchronize-Blöcken bietet sich die Funktion Surround With an. Dieses durch STRG+Alt+T aufrufbare Feature sorgt dafür, dass der markierte Code mit der ausgewählten „Umgebung“ versehen wird – das fehlerträchtige manuelle Einpflegen der schließenden geschwungenen Klammer entfällt.
Extract Variables trägt zur Verbesserung der Codequalität bei, indem es komplexe Funktionsaufrufe in ihre Einzelteile zerlegt. Als Beispiel dafür dient das Codebeispiel aus Listing 2.

@Override
protected void onCreate(Bundle savedInstanceState) {
  . . .

  testMethod(new Button(getApplicationContext()),2);
}

Markieren Sie nun den mit new beginnenden Parameter, und drücken Sie die Tastenkombination CTRL+ALT+V. Das Resultat zeigt Listing 3.

@Override
protected void onCreate(Bundle savedInstanceState) {
  . . .

  Button aButton = new Button(getApplicationContext());
  testMethod(aButton,2);
}

Häufig verwendete Code-Snippets erstellen Sie am Besten über Live-Templates. Diese unter File | Settings | Live Templates konfigurierbaren Strings erlauben Ihnen das Parametrieren der zu generierenden Codesequenzen. Mittels Code | Reformat Code passen Sie eine Datei automatisch an die von Ihnen im Einstellungsmenü vorgegebenen Formatvorlagen an. Dadurch gehören religiöse Streitigkeiten um die Positionierung von Klammer und Co. der Vergangenheit an – in größeren Teams ist das ein nicht zu unterschätzender Vorteil.
IntelliJ enthält ein gutes Dutzend weiterer Refactoring-Funktionen. Diese finden Sie im gleichnamigen Menü der IDE – es zahlt sich immer aus, einen Blick auf die dort enthaltenen Goodies zu werfen.

Von Eclipse nach Android Studio

Aufgrund der verschiedenen Build-Systeme ist es nicht ohne Weiteres möglich, ein Projekt aus Eclipse in Android Studio zu übernehmen. Das Übertragen einer auf Ant basierenden Applikation ist zwar machbar, deaktiviert aber einige fortschrittliche Funktionen wie z. B. das (noch nicht durchrealisierte) Erstellen von mehreren APKs in einem Build-Prozess.
Erfreulicherweise generiert Eclipse auf Zuruf ein Gradle-Build-File. Dazu ist lediglich die aktuellste Version des ADT-Plug-ins erforderlich – alle Versionen ab v22 enthalten die dazu notwendige Funktion.
Klicken Sie danach im Hauptmenü auf Export, um den Export-Wizard zu starten. Er erlaubt Ihnen das Erstellen eines Gradle-Build-Files – die dazu notwendige Option verbirgt sich unter Android | Generate Gradle Build Files.Öffnen Sie danach Android Studio und wählen Sie im Startbildschirm die Option Import Project aus. Selektieren Sie die im Projektverzeichnis erstellte build.gradle-Datei und klicken Sie auf OK. Im daraufhin erscheinenden Dialog müssen Sie dem Projekt nur mehr ein Skelett verpassen – wählen Sie die Option Use Gradle Wrapper und klicken Sie auf OK, um den Import abzuschließen.

Kampf der Giganten

Nach diesen Überlegungen ist es an der Zeit, ein kleines Resümee zu ziehen. Das neue Gradle-Build-System ermöglicht einige Operationen, die in Ant nicht oder nur mit enormen Aufwand möglich sind. In größeren Projekten ist es mitunter lohnend, die Umstellung zu wagen.
Sonst schenken sich die beiden Entwicklungsumgebungen wenig. Das derzeit nur in Android Studio verfügbare Layoutwerkzeug dürfte im Laufe der nächsten Monate auch in Eclipse verfügbar werden; selbiges gilt für einige andere Features.
Trotzdem gibt es aufgrund der dahinterstehenden Organisationen einige grundlegende Differenzen. IntelliJ ist im Grunde genommen kommerzielle Software – so Sie ein Fehler ausreichend quält, können Sie ihn durch Bezahlen des Herstellers beseitigen lassen. Bei Eclipse dürfen Sie einen Bugreport einpflegen – ob und wann jemand darauf reagiert, ist Glückssache. Außerdem ist die IntelliSense-Erkennung etwas besser.
Für Eclipse spricht indes das enorme Ökosystem im Hintergrund. Tausende Entwickler realisieren Plug-ins für die Entwicklungsumgebung, im gut sortierten Fachhandel gibt es sogar ein Magazin für Nutzer dieser IDE aus demselben Haus.
In Summe verhält es sich so, dass jede der beiden Umgebungen ihre individuellen Stärken und Schwächen aufweist. Die Frage nach der „besseren Arbeitsumgebung“ ist so persönlich wie die Frage nach dem Lieblingsvodka – der Wille des Entwicklers ist sein Himmelreich.

Fazit

Im Rahmen der Vorstellung des Produkts hat Google mehrfach betont, dass das ADT für Eclipse weitergepflegt wird. Wenn Sie sich seit zehn Jahren mit der IDE aus dem Hause der Apachen befassen, besteht kein Grund zur Sorge – es ist ganz im Gegenteil sogar davon auszugehen, dass das eine oder andere Feature zurückportiert wird.
Trotzdem spricht nichts dagegen, dem neuen System eine Chance zu geben. Die früher unter Umständen erforderliche kommerzielle Lizenz entfällt beim Einsatz des Android Studios. Sagt Ihnen die neue IDE zu, so sparen Sie Zeit.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -