App-Entwicklung | Wie entwickle ich eine Android-App – Teil 1

Schon seit längerer Zeit habe ich vor, eine eigene App zu entwickeln. Bisher ist es aber immer daran gescheitert, dass ich mich nicht genügend motivieren konnte, mich in die Technologie einzuarbeiten und ich keine gute Idee für eine App hatte. Nun aber möchte ich das Thema angehen und in mehreren Teilen – wie viele es werden, weiß ich noch nicht genau – meinen Fortschritt dokumentieren. Damit möchte ich auch dir helfen, falls du ebenfalls an App-Entwicklung interessiert bist 🙂

Helfen soll mir dabei unter anderem ein Udemy-Kurs, den ich mir gekauft habe. Die Java-Entwicklung kenne ich schon sehr gut aus Schule und Ausbildung, mit Android Studio, was ich als IDE verwenden möchte, hatte ich bisher aber noch gar keine Berührungspunkte.

Schritt 1: Die Idee

Wie gesagt mangelte es mir lange an einer Idee für eine solche App. In letzter Zeit ist mir aber immer öfter aufgefallen, wie ich mich für teilweise ein oder zwei Kommandozeilen-Befehle, die ich auf meinem Server ausführen möchte, an meinem Laptop oder Handy auf den Server aufwählen muss. Oftmals sind die Befehle dabei auch noch gleich. Deswegen habe ich mir überlegt, ob es nicht praktisch wäre, wenn ich eine App habe, mit der ich einen solchen vorkonfigurierten Befehl per Druck auf einen Button abschicken kann. Zwar gibt es zum Beispiel mit Mercury-SSH Commander schon eine entsprechende Lösung, jedoch finde ich diese Idee sehr spannend und außerdem ist die Konfiguration bei der App meiner Meinung nach ein wenig kompliziert umgesetzt.

Schritt 2: Installation und Einrichtung der IDE

Für die Entwicklung möchte ich Android Studio als Entwicklungsumgebung verwenden. Dazu ist es natürlich erst einmal notwendig, die Installationsdateien dafür herunterzuladen und dann die Installation durchzuführen. Als Betriebssystem nutze ich Windows 10, deswegen werde ich mich darauf beschränken, ich denke aber, dass sich auf den anderen Platformen ohnehin nicht zu große Unterschiede ergeben sollten.

Ist die Installation abgeschlossen, muss als nächster Schritt ein neues Projekt für die App angelegt werden. Bisher habe ich noch keine besseren Namen gefunden, deswegen nutze ich in diesem Tutorial für meine App den Namen Command Sender 🙂

Nach der Erzeugung des Projektes erhält man unter anderem zwei Dateien mit den Namen “MainActivity.java” und “activity_main.xml”. Erstere ist dabei die Datei, in der sich der Java-Code befindet, der beim Öffnen der App ausgeführt wird. In der genannten XML-Dateien wird das Layout der App festgelegt.

Schritt 3: Implementierung der SSH-Verbindung

Bevor ich mich um das Layout oder ähnliches gekümmert habe, wollte ich zuerst einmal wissen, wie ich mich überhaupt per Java auf einen entfernten Server aufwählen kann, da dies einen zentrale Komponente sein wird und dies auf jeden Fall möglich sein muss. Ansonsten hätte ich mir schon von Anfang an alternative Lösungswege einplanen müssen. Deswegen habe ich mir in Eclipse ein Test-Projekt angelegt, online nach Lösungen gesucht und testweise versucht, eine Verbindung zu meinem Server herzustellen. Dies ist mir mit dem folgenden Code gelungen.

private List sendCommandWithKeyAuthentication() 
        throws JSchException, IOException
{
    JSch jsch = initializeJSchObjectForKeyAuthentication(
            PATH_TO_PRIVATE_KEY,
            KEY_PASSPHRASE);
    Session session = initializeSessionForKeyAuthentication(
            jsch,
            USERNAME,
            HOST,
            SSH_PORT);
    ChannelExec channelSsh = sendCommand(session, command);
    List lines = readConsoleOutput(channelSsh);
    disconnect(channelSsh, session);
    return lines;
}

private JSch initializeJSchObjectForKeyAuthentication(
        String privateKeyPath,
        String passphrase) throws JSchException
{
    JSch jsch = new JSch();
    jsch.addIdentity(privateKeyPath, passphrase);
    return jsch;
}

private List readConsoleOutput(ChannelExec channelSsh) throws IOException
{
    InputStream stdOut = channelSsh.getInputStream();
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stdOut));
    List lines = new ArrayList<>();
    String line = null;
    while((line = bufferedReader.readLine()) != null) {
        lines.add(line);
    }
    return lines;
}

In diesem Code-Schnipsel habe ich die Java-Biblithek JSch benutzt. Die dafür notwendige Abhängigkeit sieht in Gradle, was ich grundsätzlich zum Bauen meiner Projekte benutze und was auch automatisch in Android Studio integriert ist, folgendermaßen aus:

compile 'com.jcraft:jsch:0.1.54'

Kurz möchte ich noch einmal darauf eingehen, was der Code macht. Im Grunde wird sich per Schlüssel-Authentifizierung auf einen entfernten Server aufgewählt und der angegebene Befehl ausgeführt. Die Kommandozeilen-Ausgabe wird als List zurückgegeben. Natürlich ist auch ein einfacher Login mit Benutzernamen und Passwort möglich, dafür sieht der Code noch ein wenig anders aus.

Der Test des Verbindungsaufbau zu einem Remote-Server mit Java ist damit geglückt! 🙂

Schritt 4: Grobe Gestaltung der Startseite

Die Anzahl der Kommandos soll konfigurierbar sein, also kann ich die Buttons nicht in der Layout-Datei einfügen, sondern muss das im Code dynamisch machen. Dafür nutze ich ein sogenanntes ListView, wo ich gleich noch drauf eingehe, wie ich damit die Buttons programmatisch erstelle. Unter den Buttons soll es noch ein Textfeld geben, in dem Fehlermeldungen oder die Ausgabe der Kommandozeile ausgegeben werden kann. Meine Layout-Datei sieht damit folgendermaßen aus.

Mit folgendem Code gelingt es mir, den ListView mit Inhalten zu füllen:

List list = createButtonListFromCommands(); //Create a list of all names of the commands
ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, list);

ListView listView = (ListView) findViewById(R.id.buttonlistView);
listView.setAdapter(adapter);
listView.setOnItemClickListener(new AdapterView.OnItemClickListener(){

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id)
    {
        final CommandConfiguration commandConfiguration = commandConfigurations.get(position);
        
        sendCommand(
                commandConfiguration.getCommand(),
                commandConfiguration.getHostConfiguration());
    }
});

Für jeden Eintrag der Liste mit den anzuzeigenden Display-Namen wird ein Eintrag erstellt. Zusätzlich wird für einen Touch-Befehl der jeweils dazugehörige SSH-Befehl hinterlegt.

Das Grundgerüst steht damit schon mal. Jedoch muss die App in der Lage sein, Konfigurationen für einen Host oder ein SSH-Befehl aufzunehmen und zu speichern und diese dann auslesen. Dies ist dann Thema im nächsten Teil!

Ich hoffe euch hat dieser Einstieg in diese Serie gefallen. Falls etwas nicht verständlich war, könnt ihr gerne eure Fragen in den Kommentaren lassen 🙂

Den aktuellen Stand der Entwicklung könnt ihr übrigens in folgendem GitHub-Repository nachvollziehen: Command-Sender Repository