Eingabeverarbeitung mit Android 

Es soll nun ein Programm erstellt werden, welches einen Zähler »MainActivity.this.i« bei jeder Aktivierung einer Tastfläche inkrementiert.

Ausdruck zum Inkrementieren von »MainActivity.this.i«

++MainActivity.this.i

Der neue Wert des Zählers soll in der Tastfläche selber angezeigt werden. Dazu wird der Zahlenwert mit »+ ""« in ein java.lang.String-Objekt gewandelt.

Ausdruck zur java.lang-String-Darstellung des Wertes von »MainActivity.this.i++«

++MainActivity.this.i + ""

Der Text der Tastfläche kann alsdann entsprechend verändert werden.

Anweisung zum Inkrementieren und Anzeigen

button.setText( ++MainActivity.this.i + "" );

Beim Aktivieren einer Tastfläche ruft Android  die Methode »onClick(android.view.View)« auf, daher muß die voranstehende Anweisung in eine entsprechende Methode verpackt werden, wenn sie beim Aktivieren einer Tastfläche ausgeführt werden soll.

Methode für Aktivierung der Tastfläche

public void onClick( final android.view.View view )
{ button.setText( ++MainActivity.this.i + "" ); }

Die voranstehende Methode muß in ein Objekt verpackt werden, das die Schnittstelle »android.view.View.OnClickListener« mit der Methode »onClick(android.view.View)« implementiert. So kann Android  erkennen kann, daß die Methode zu dieser Schnittstelle gehört.

Ausdruck für Implementation der Schnittstelle »android.view.View.OnClickListener«

new android.view.View.OnClickListener()
{ @java.lang.Override public void onClick( final android.view.View view )
  { button.setText( ++MainActivity.this.i + "" ); }}

Einer Tastfläche kann mit »setOnClickListener« dann eine Referenz auf eine Implementation von »android.view.View.OnClickListener« als Ereignisempfänger für Aktivierungen übergeben werden.

Anweisung zum Festlegen eines Ereignisempfängers für Aktivierung

button.setOnClickListener
( new android.view.View.OnClickListener()
  { @java.lang.Override public void onClick( final android.view.View view )
    { button.setText( ++MainActivity.this.i + "" ); }} );

Die Methode »onClick(android.view.View)« wird somit dann aufgerufen, wenn die Tastfläche aktiviert wird, was durch Antippen oder die Eingabetaste erfolgen kann.In dem folgenden Beispielprogramm wird dann immer ein Zählwert hochgezählt und als Text der Tastfläche angezeigt.

MainActivity.java

package com.example;

public class MainActivity extends android.app.Activity
{ int i = -1;

  @java.lang.Override public void onCreate( final android.os.Bundle bundle )
  { super.onCreate( bundle );

    final android.app.Activity activity = this;
    final android.content.Context context = this;
    final android.widget.Button button = new android.widget.Button( context ); 
    button.setGravity( android.view.Gravity.LEFT | android.view.Gravity.TOP  );
    button.setText( ++MainActivity.this.i + "" );

    button.setOnClickListener
    (

      new android.view.View.OnClickListener()
      {

        @java.lang.Override public void onClick( final android.view.View view )
        { button.setText( ++MainActivity.this.i + "" ); }} );

    activity.setContentView( button ); }}

App

.---------------------------------.
|---------------------------------|
| MainActivity                    |
|---------------------------------|
|.-------------------------------.|
|| 0                             ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
|'-------------------------------'|
'---------------------------------'

App

.---------------------------------.
|---------------------------------|
| MainActivity                    |
|---------------------------------|
|.-------------------------------.|
|| 0                             ||
||                               ||
||                               ||
||              |                ||
||            \   /              ||
||          -   *   -            ||
||            /   \              ||
||              |                ||
||                               ||
||                               ||
||                               ||
|'-------------------------------'|
'---------------------------------'

App

.---------------------------------.
|---------------------------------|
| MainActivity                    |
|---------------------------------|
|.-------------------------------.|
|| 1                             ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
||                               ||
|'-------------------------------'|
'---------------------------------'

Dieses Programm kann auch als ein Spiel interpretiert werden, bei dem es darum geht, durch schnelles Antippen der Tastfläche binnen einer Minute einen möglichst hohen Zählerstand zu erreichen.

Verdrahtung

Wir verstehen unter Verdrahtung, daß ein Objekt A  Kenntnis von einem anderen Objekt B  erhält. Das Objekt A  kann sich diese Information dann merken und auf diese Weise das Objekt B  später bei Bedarf erreichen.

Die Verdrahtung erfolgt in der Regel dadurch, daß das Objekt B  als Argument bei der Erzeugung des Exemplars A  verwendet wird, oder dadurch, daß das Objekt B  als Argument beim Aufruf einer Methode des Exemplars A  verwendet wird.

„A ist mit B verdrahtet“ bedeutet also so viel wie „A kennt B“ (oder manchmal auch „B kennt A“ – die Details muß man dem Zusammenhang entnehmen).

A und B sind verdrahtet

.-------------.          .-------------.
| A           |--------->| B           |
|             |          |             |
'-------------'          '-------------'

In der Sprechweise von UML nennt man die Verbindung (den „Draht“) auch eine Assoziation  und die Verdrahtung „Herstellung einer Assoziation“.

In unserem Programm erfolgt eine Verdrahtung eines Textfeldes »text« mit einem Block durch die Methode »setOnAction«. (Wir sehen den Block hier ebenfalls als eine Art von Objekt an.)

Die Tastfläche »button« und das mit »new« erzeugte Objekt werden verdrahtet

    button.setOnClickListener
    ( new android.view.View.OnClickListener()
      { @java.lang.Override public void onClick( final android.view.View view )
        { button.setText( ++MainActivity.this.i + "" ); }} );

Das Textfeld »text« kann sich den Block auch über die Dauer der Ausführung von »setOnAction« hinaus für eine spätere Verwendung merken.

Das Textfeld »text« und der Block sind verdrahtet

.-------------.          .-----------------------------------------------.
| button      |--------->| new android.view.View.OnClickListener() ...   |
|             |          |                                               |
'-------------'          '-----------------------------------------------'

Nach der Verdrahtung kennt das Textfeld den Block und kann ihn so jederzeit ausführen.

Bei der Verdrahtung wird ein Objektgraph  aufgebaut, das heißt eine Struktur aus miteinander verbundenen Objekten. Das Geschehen nach der Verdrahtung ergibt sich dann aus dem Zusammenwirken der Objekte dieses Graphen.

Die Verdraht erfolgt vor allem für zwei Zwecke, die im folgenden beschrieben werden.

Verdrahtung zur Aggregation

Aggregation: Ein GUI-Objekt »I« („Inhalt“) soll innerhalb eines anderen GUI-Objektes »B« („Behälter“) angezeigt werden. Dafür muß das Objekt »B« das Objekt »I« kennen. Also muß eine Leitung von »B« zu »I« gelegt werden. Dies kann dadurch geschehen, daß »B« bereits im Exemplarerzeugungsausdruck das Objekt »I« als Argument übergeben wird. Statt dessen kann aber auch nach der Erzeugung eine Methode von »B« aufgerufen werden, welche das Objekt »I« als Argument akzeptiert.

Verdrahtung vom Behälter zum Inhalt

.-------------.          .-------------.
| Behaelter   |--------->| Inhalt      |
|             |          |             |
'-------------'          '-------------'

Verdrahtung vom Behälter zum Inhalt in einem Methodenaufruf

activity.setContentView( button )

Verdrahtung zur Ereignisweiterleitung

Ereignisweiterleitung: Ein Objekt oder eine Methode »E« („Empfänger“) soll festlegen, was bei einem bestimmten Ereignis (einer bestimmten Benutzereingabe) passiert. Dann muß eine Leitung von einem Objekt »S« („Sender“), welches von diesem Ereigns weiß, zu »E« gelegt werden. Dazu wird meist eine Methode von »S« aufgerufen werden, welche das Objekt »E« als Argument akzeptiert.

Verdrahtung vom Sender zum Empfänger

.-------------.          .-------------.
| Sender      |--------->| Empfaenger  |
|             |          |             |
'-------------'          '-------------'

Die Startmethode »onCreate« in der GUI-Programmierung

Die Startmethode »onCreate« der meisten GUI-Programme ist nach dem Muster „Erzeugen, Verdrahten und Schluß“ aufgebaut.

• Zuerst werden einmal die benötigten GUI-Objekte erzeugt („Erzeugen“) und konfiguriert.
• Während der Erzeugung werden die GUI-Objekte auch wie benötigt verdrahtet („Verdrahten“).
• Dann wird die soeben aufgebaute Benutzeroberfläche sichtbar geschaltet und danach wird nichts mehr von der Start-Methode »onCreate« getan („Schluß“). (Vorgänge werden ab jetzt durch Benutzeraktivitäten ausgelöst.)

Android  läßt bei GUI-Programmen die App beim Ende der Startmethode »onCreate« noch weiterlaufen. Daher verschwindet die Benutzeroberfläche also am Ende der Startmethode nicht.

Übungsaufgaben

/   Würfel

Schreiben Sie ein Programm mit einer Tastfläche, welche bei jeder Berührung eine zufällig ausgewählte ganze Zahl zwischen 1 und 6 anzeigt.

/   Vokabeltrainer

Schreiben Sie ein Programm mit einer Tastfläche, welche ein zufällig ausgewähltes englisches Wort anzeigt (es sollte dabei mindestens sechs verschiedene Wörter geben).

Bei einer Berührung der Tastfläche soll dann die deutsche Übersetzung des Wortes angezeigt werden.

Bei einer weiteren Berührung der Tastfläche soll dann das ganze dann wieder von vorne beginnen, indem dann wieder ein zufällig ausgewähltes englisches Wort angezeigt wird.