• Home
  • Das erste mal hier?
  • Kontakt
  • Downloads
  • App Reviews
  • Buch Reviews
  • Kategorien
    • App-Economy
    • App-Entwicklung
      • Android
      • Java
      • Planung
      • Testen
    • App-Marketing
      • Bloggen
      • Seo
      • Social Media
    • Fachbuch
    • Programmier Tutorials
  • App-Entwickler gesucht?

Tippscom.de

Erschaffe deine eigenen Apps

  • Android App programmieren
  • Java lernen
  • Komplette Apps
  • Tipps
  • Meine Apps
Aktuelle Seite: Startseite / App-Entwicklung / Android / Android App Tutorial – Wie du einen Reaktionstest programmierst

Android App Tutorial – Wie du einen Reaktionstest programmierst

16. September 2014 von Marius Kommentar verfassen

Reaktionstest-App in Android programmieren

Kompliment! Deine Reaktion ist sau gut, denn du hast dieses Tutorial angeklickt.

Wenn du dieses Tutorial durchgelesen hast, kannst du deinen eigenen Reaktionstest für dein Android-Gerät programmieren und dich mit deinen Freunden messen.

Wer wird wohl der schnellste sein?

Du natürlich, denn du bist ein treuer Tippscom-Leser und deine kognitiven Fähigkeiten, allen voran deine Auffassungsgabe, sind, durch die Lektüre meines hoch anspruchsvollen Blogs, bereits überdurchschnittlich groß.

Bevor du es deinen Freunden in einem hitzigen Reaktions-Duell zeigen kannst, musst du die App aber zuerst einmal programmieren. Wie das geht, zeige ich dir jetzt!

ReaktionActivity – Die einzige Activity unserer tollen App

Für den Reaktionstest benötigst du nur eine einzige Activity. Diese taufen wir auf den aussagekräftigen Namen: “ReaktionsActivity”.

Unsere Activity implementiert ganze 3 Interfaces und zwar Runnable, OnTouchListener und OnClickListener.

1
public class ReaktionsActivity extends Activity implements Runnable, View.OnTouchListener, View.OnClickListener {

Als nächstes benötigen wir einige Variablen und Gui-Elemente.

1
2
3
4
5
6
7
8
9
10
TextView nowView;
    TextView timeView;
    Button startButton;
    LinearLayout screenLayout;
    Thread countThread;
    boolean running;
    boolean reactNow;
    double time;
    double reactionTime;
    double reactionMoment;

Wie immer initialisierst du die Gui in der onCreate-Methode

Als nächstes kommen wir zur onCreate unserer Activity. Wir initialisieren, wie wir das immer tun, zuerst die Benutzeroberfläche, anhand der IDs unseres Layout, welches ich dir später noch zeigen werde.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        nowView = (TextView) findViewById(R.id.now_view);
        timeView = (TextView) findViewById(R.id.time_view);
        startButton = (Button) findViewById(R.id.start_button);
        screenLayout = (LinearLayout) findViewById(R.id.screen_layout);
 
        screenLayout.setOnTouchListener(this);
        startButton.setOnClickListener(this);
 
 
        countThread = new Thread(this);
        running = false;
        reactNow = false;
 
 
    }

Die onClick-Methode – Was passiert beim Klick auf den Button

Als nächstes kommen wir zur onClick-Methode, des Interface onClickListener, das die Activity implementiert. Da der Button dazu dient, den Reaktionstest zu starten, müssen wir jetzt alle Operationen ausführen, die wir zum Start benötigen.

Das wären:

  • Den Moment, berechnen, wann der User reagieren soll, sprich eine Zufallszahl.
  • Einen neuen Thread starten, der die Berechnungen vornimmt, mehr dazu gleich.
  • Den Button sperren, dass er nicht mehr angeklickt werden kann, solange der Reaktionstest läuft.

1
2
3
4
5
6
7
public void onClick(View v) {
        reactionMoment = ((Math.random()) * 6 + 2);
        running = true;
        countThread = new Thread(this);
        countThread.start();
        startButton.setClickable(false);
    }

Die onTouch-Methode – was passiert wenn der User den Bildschirm berührt

Das zweite Interface, onTouchListener kommt mit der Methode onTouch daher, in der wir definieren, was geschieht, sobald der User den Bildschirm berührt.

Bei unserer App, ist das Berühren des Bildschirms, die Reaktion, die der User vollführt, sobald er das entsprechende Kommando bekommt.

Also müssen wir den Thread Stoppen und den Button zum Starten des Reaktionstest wieder entsperren.

1
2
3
4
5
6
7
8
9
public boolean onTouch(View v, MotionEvent event) {
        if (running && reactNow) {
            running = false;
            reactNow = false;
            startButton.setClickable(true);
        }
 
        return true;
    }

Die Run-Methode – Die Berechnungen im Hintergrund

Diese Methode ist wahrscheinlich die Wichtigste der Activity. Hier wird die Zeit gezählt und wenn der Zeitpunkt erreicht ist, wenn User reagieren soll (reactionMoment) dann werden die entsprechenden Operationen in die Wege geleitet. Anschließend zählt der Thread die Zeit, wie lange der User benötigt, um zu reagieren.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public void run() {
 
        time = 0;
        reactionTime = 0;
        runOnUiThread(new Runnable() {
            public void run() {
                nowView.setText("Wait!");
                nowView.setVisibility(View.VISIBLE);
                timeView.setText(String.format("%.2f", reactionTime));
            }
        });
 
 
        while (running) {
            time = time + 0.01;
            if (time == reactionMoment) {
                reactNow = true;
 
            }
            if (reactNow) {
                reactionTime += 0.01;
                runOnUiThread(new Runnable() {
                    public void run() {
                        nowView.setText("React Now!");
                        timeView.setText(String.format("%.2f", reactionTime));
                    }
                });
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                Logger.getLogger(ReaktionsActivity.class.getName()).log(Level.SEVERE, null, ex);
            }
 
 
 
        }
        runOnUiThread(new Runnable() {
            public void run() {
                nowView.setVisibility(View.INVISIBLE);
            }
        });
    }

Je nachdem in welchem Zustand sich der Reaktionstest befindet, ändern wir den Text unseres TextView´s entweder zu “Wait!” oder “React Now!”. So weis der User sofort, wenn er reagieren soll, nämlich sobald der Text auf “React Now!” umspringt. Berührt er dann den Bildschirm der App, wird die Zeit gestoppt.

Das Layout der ReaktionsActivity

Das Layout ist simpel. Es besteht aus einem Button und 2 TextViews, die in einem LinearLayout liegen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
              android:id="@+id/screen_layout"
>
  
    <Button
        android:id="@+id/start_button"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Start"
    />
    
        
        
    <TextView
        android:id="@+id/time_view"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:textSize="25dp"
        android:gravity="center_horizontal"
    />
        
    <TextView
        android:id="@+id/now_view"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Wait!"
        android:visibility="invisible"
        android:textSize="40dp"
        android:gravity="center_horizontal"
    />  
</LinearLayout>

Fazit und Feedback!

Toll, du hast einen Reaktionstest für Android programmiert. Jetzt steht dir nichts mehr im Weg, deinen Freunden zu zeigen, wer hier der Meister der Reaktionen ist.

Wenn dir mein Tutorial gefallen hat, dann schreib mir doch ein Kommentar, oder teile es weiter! Das würde mich sehr freuen!

[button link=”http://www.tippscom.de/beispiel-apps-android-tutorials-fuer-komplette-applikationen/” color=”blue”]Mehr App-Tutorials[/button]

Reaktionstest in Android (405 Downloads)
Foto-Quelle: Pixabay.com

Kategorie: Android, App-Entwicklung Stichworte: App Tutorial, App-Entwicklung

Das wird dich auch interessieren

  1. Android App Tutorial – Wie du eine Stoppuhr-App in Android programmierst
  2. Android App Tutorial – Cocktaillexikon + Quellcode zum Download
  3. Android Anfänger Tutorial 9 – Context Menu
  4. Wie du eine To-Do-Listen-App in Android programmierst #1
  5. Android App Tutorial – So erstellst du eine Taschenrechner-App in Android

Über Marius

Hi, danke dass du dir meinen Artikel durchgelesen hast!

Ich heiße Marius, bin leidenschaftlicher Programmierer.

Hier auf meinem Blog möchte ich dir zeigen, wie du deine eigenen tollen Apps programmieren kannst.

Schreibe einen Kommentar Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Verbinde dich mit Tippscom

Like
Folgen
Folgen
Abonnieren

Beliebte Artikel

  • Wie du mit Java Spiele programmieren kannst
  • Java Anfänger Tutorial 6 – Methoden erklärt, anhand von Gettern und Settern
  • Android App Tutorial – So erstellst du eine Taschenrechner-App in Android
  • Java Programmieren lernen – Tutorial
  • Android Anfänger Tutorial 5 – Wie du deine Apps mit Buttons bestückst
  • Android Anfänger Tutorial 6 – Wie du Activities mit Intents starten und beenden kannst
  • Android programmieren Tutorial 7 – Wie du einfache Listen erstellst

Aktuelle Artikel

  • Brettspiel-Apps – Tolle Unterhaltung auf dem Smartphone
  • Paintastic – Erstelle Kunstwerke mit deinem Smartphone!
  • Puzzle Bubble Shooter Classic – Noch mehr Bubble-Spaß
  • 6 effektive Maßnahmen die dein App-Business zum Erfolg führen
  • Deutschland – Apps und News – Apps für deine Stadt
  • Animal Stickers – Versehe deine Nachrichten mit niedlichen Tier-Stickern für iOS
  • Panda Bubble Pop: Birds Free – Match-3-Bubble-Shooter

Blogroll

  • Android Developers
  • Basteldroid
  • Helfsoft – Game Developer

Letze Kommentare

  • A.Berger zu Java Anfänger Tutorial 11 – VererbungSehr gut, vielen Dank!
  • Takko-Fan zu 6 effektive Maßnahmen die dein App-Business zum Erfolg führenIch finde vor allem Deinen letzten Tipp "Auf User-Wünsche eingehen"
  • Marius zu Java Anfänger Tutorial 10 – ArraysHi Manu, absolut nicht kleinlich. Wenn du auf Fehler hinweist
  • Marius zu Android Anfänger Tutorial 5 – Wie du deine Apps mit Buttons bestückstHallo Lothar, das ist kein Problem. Du kannst das Package
  • sk zu Java Anfänger Tutorial 2 – Kompilieren in der Kommandozeile, wie in den 80ernHallo Marius, schon länger habe ich den Gedanken, wie ich

Wichtige Seiten

  • Impressum
  • Datenschutz
  • Haftungsausschluss
  • Kontakt
  • Werben

Kategorien

  • Android
  • Java
  • App-Marketing

Tutorials

  • Android lernen
  • Java lernen
  • Beispiel-Apps
  • Profi Tipps

Verlinkungen

Blogverzeichnis - Blog Verzeichnis bloggerei.de Bloggeramt.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste

Copyright © 2019 · Tippscom.de