Apps für Android programmieren leicht gemacht!
4.6 Kaffee Clicker

4.6 Kaffee Clicker

Ich habe mir zum Abschluss der Artikelreihe „Kaffee Clicker“ noch etwas ganz Feines einfallen lassen.

Nehmen wir an unsere App wird im PlayStore ein riesen Hit, aber nach kurzer Zeit spielt einfach niemand mehr. Woran kann das liegen ?
Die naheliegenste Lösung wäre, dass sie das Spiel vergessen.

Also können wir nun die folgenden 2 Dinge tun:

  1. Den Spieler an das Spiel, per Benachrichtigung, erinnern.
  2. Den Spieler für das Wiederkommen belohnen.

Ich mir einfallen lassen genau diese beiden Dinge mit euch umzusetzen.
Ich setze für die Benachrichtigung voraus, dass ihr den Artikel zu Anzeige von Benachrichtigungen gelesen habt.

 

Spieler belohnen:

Als Erstes habe ich mir gedacht, dass wir vielleicht unsere Belohnung rechnen und ausschütten könnten. Zusätzlich wäre eine kleine Benachrichtigung, über die Belohnung garnicht mal so schlecht.

Zur Berechnung und Vergebung der auszuschüttenden Belohnung ist eine neue Funktion von Nöten, die direkt beim Öffnen der App aufgerufen wird.

Wir schreiben also

public void vergebeBelohnung(){

   //Hier findet später die Berechnung statt.

}

und fügen ans Ende der „onCreate()“ Methode den Aufruf dieser Funktion hinzu:

vergebeBelohnung();

Als nächstes sollten wir die Funktion „vergebeBelohung“ mit Leben füllen.
Wir schreiben:

//Momentane Zeit in Millisekunden, seit dem 1.1.1970
Long zeitMilli = System.currentTimeMillis();

//Momentane Zeit in Sekunden, seit dem 1.1.1970
int zeit = (int) (zeitMilli / 1000);

//Zeit des letzen Aufrufes in Sekunden (Wenn es vorher keinen Aufruf gab, dann setze die letzte Zeit auf jetzt)
int letzteZeit = laden("letzteZeit", zeit);

//Vergangene volle Stunden, seit dem letzten Aufruf
int stunden = (zeit - letzteZeit) / 3600;

//Verkaufe Kaffees für jede vergangene Stunde
for(int i = 0; i < stunden; i++){
    verkaufeKaffee();
}

//setze die momentane Zeit als die Zeit des letzten Aufrufes
speichern("letzteZeit", zeit);

//Meldug mittels Toast ausgeben
Toast.makeText(this, "Du hast eine Belohunung erhalten.", Toast.LENGTH_SHORT).show();
  •  Zur Erklärung, was wir hier eigentlich tun:
  • Wir lesen die momentane Zeit in Millisekunden aus und errechnen daraus die Unix Zeit in Sekunden.
  • Wir lesen ebenfalls die Unix Zeit des letzten Aufrufes aus. Ist dieser Wert noch nicht gesetzt (App wird das erste mal geöffnet.) setzen wir die Zeit des letzten Aufrufes auf die momentane Zeit.
  • Wir errechnen die Differenz der beiden Zeiten und Teilen durch 3600, um auf die Anzahl der vollen Stunden zu kommen.
  • Für jede Stunde Differenz simulieren wir einen Klick auf den Kaffeebecher.

 

Benachrichtigung ausgeben:

Zusätzlich war es ja unser Plan eine Benachrichtigung auszugeben. Mit dieser täglichen Benachrichtigung können wir den Spieler animieren wieder zu kommen.

 

Vorarbeit:

Für unser Vorhaben ist etwas an Vorarbeit nötig.
Vorerst sollten wir eine neue Klasse erstellen. Wir nennen sie idealerweise „Erinnerung.java“ und gehen nach Erstellung in die Datei „Androidmanifest.xml“.
In dieser XML-Datei ist es von Nöten etwas hinzuzufügen. Wir werden nun nämlich im Laufe des Artikels versuchen einen „Alarm“ zu erstellen. Dieser Alarm bekommt eine bestimmte Zeit zugewiesen und wird von Android automatisiert ausgeführt, wenn die zeit abgelaufen ist.
Unsere Alarm-Klasse wird die Klasse „Erinnerung.java“ sein. Android benötigt in der „AndroidManifest.xml“-Datei allerdings noch die Information, dass es eben eine solche „Erinnerung.java“ Klasse gibt und sie als Alarm-Klasse aufrufbar ist.

Innerhalb des Tags „Application“ fügen wir die Information „<receiver android:process=“:remote“ android:name=“.Erinnerung“/>“ ein, in etwa so:

<manifest>
   [...]
   <application>
      [...]
      <receiver android:process=":remote" android:name=".Erinnerung"/>
      [...]
    </application>
   [...]
</manifest>

Innerhalb des Tags „Manifest“ fügen wir zusätzlich noch eine Berechtigung ein, dass unser „Alarm“ auch gestartet werden darf, wenn sich das Smartphone gerade im Standby befindet. Etwa so:

<manifest>
   [...]
   <uses-permission android:name="android.permission.WAKE_LOCK"/>
   [...]
</manifest>

 

Erinnerung.java:

Machen wir uns an die Programmierung der Klasse „Erinnerung.java“.
Diese Klasse wird als Alarm-Klasse später von Android aufgerufen und soll unsere Benachrichtigung starten.

Ich habe mir mal herausgenommen das Grundgerüst der Klasse „Erinnerung.java“ fertig zu schreiben:

package de.droid_lernen.kaffeeclicker;

import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.support.v7.app.NotificationCompat;


public class Erinnerung extends BroadcastReceiver {
    
    //Wird automatisch aufgerufen, wenn Android den "Alarm" auslöst. (Analog zu onCreate in MainActivity)
    @Override
    public void onReceive(Context context, Intent intent) {

    }

    public void notifi(Context context, String Nachricht){
        //Es wird die Klasse ActivityMain.class beim Klick aufgerufen
        final Intent notificationIntent = new Intent(context, MainActivity.class);
        final PendingIntent pi = PendingIntent.getActivity(context, 0, notificationIntent, 0);
        NotificationCompat.Builder mBuilder =
                (NotificationCompat.Builder) new NotificationCompat.Builder(context)
                        .setSmallIcon(R.mipmap.ic_launcher)
                        .setContentTitle("KaffeeClicker")
                        .setOngoing(true)
                        .setContentIntent(pi)
                        .setContentText(Nachricht);
        NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        mNotificationManager.notify(1, mBuilder.build());
    }
}

Als Vorlage für die Funktion „notifi“ diente der Artikel „Benachrichtigungen„.
Die Funktion „onReceive“ wird – wie auch „onCreate“ – aufgerufen, wenn Android den Alarm auslöst. „onCreate“ wird aber nur gestartet, wenn man die App manuell öffnet. onReceive, wenn der Alarm ausgelöst wird.

Da wird nun wissen, was „onReceive“ macht können wir die Funktion zur Anzeige der Benachrichtigung nutzen.
Wir schreiben:

notifi(context, "Es wartet eine neue Belohnung auf dich.");

 

MainActivity.java:

Zurück zu unserer Hauptklasse.
Wir haben soeben erfolgreich eine Klasse geschrieben, die als Alarm ausgeführt werden und und anschließend eine Benachrichtigung anzeigt.

Uns fehlt nun nur noch der Code, um einen Alarm zu registrieren.
Da wir eine Benachrichtigung allerdings nur dann anzeigen lassen wollen, wenn der Spieler einen ganzen Tag nicht mehr online war, müssen wir einen Alarm auch wieder abbrechen können.
Unsere Vorgehensweise innerhalb unserer Hauptklasse ist nun wie folgt:

  • Wir brechen einen bestehenden Alarm, bei Öffnung der App ab.
  • Wir erstellen einen neuen Alarm in genau einem Tag.
//Registriert einen Alarm in einem Tag. (86400 Sekunden)
public void setAlarm(Context context) {
    AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    Intent i = new Intent(context, Erinnerung.class);
    PendingIntent pi = PendingIntent.getBroadcast(context, 0, i, 0);
    am.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), 1000 * 60 * 60 * 24, pi); // Millisekunden * Sekunden * Minuten * Stunden
}

//Bricht einen laufenden Alarm ab.
public void cancelAlarm(Context context) {
    Intent intent = new Intent(context, Erinnerung.class);
    PendingIntent sender = PendingIntent.getBroadcast(context, 0, intent, 0);
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    alarmManager.cancel(sender);
}

Am Ende der Funktion „onCreate“ schreiben wir:

cancelAlarm(this);

setAlarm(this);

Schon sind wir fertig.

 

Benachrichtigung entfernen:

Eine Kleinigkeit wäre da noch.
Wenn wir auf die erscheinende Benachrichtigung klicken verschwindet diese nicht.
Oberhalb der letzten beiden eingefügten Zeilen in „onCreate“ können wir alle angezeigten Benachrichtigungen entfernen.

// Schließe eine vielleicht bestehende Benachrichtigungen
NotificationManager mNotificationManager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.cancelAll();

 

Ende:

Damit wären wir dann auch am Ende unserer ersten eigenen Android App.
Was haben wir denn durch unsere eigene erste App so gelernt?

  1. Wir können unsere App nun grafisch gestalten.
  2. Wir können auf Klick reagieren.
  3. Wir können Berechnungen durchführen.
  4. Wir können Daten speichern und laden.
  5. Wir können nun Benachrichtigungen ausgeben.
  6. Wir können unsere App sich selber in einiger zeit aufrufen lassen.

Ich hoffe euch hat das Kapitel 4 gefallen und ihr seit auch in Kapitel 5 wieder dabei. In diesem Kapitel werden wir lernen, wie wir uns einen Google Developer Account erstellen können, mit der Developer Konsole umgehen und Apps veröffentlichen.

Die App Kaffeeklicker wird demnächst auch kostenfrei im PlayStore erhältlich sein.

KaffeeClicker - Komplette App


Lade dir jetzt den kompletten und fertigen Source Code der App KaffeeClicker herunter.

DownloadLizenzbedingungen

Marvin

Ich bin 23 Jahre jung und studiere zurzeit Wirtschaftsinformatik an der Georg-August-Universität in Göttingen. Ich bin ein Mensch, der sich neben der Programmierung noch für tausend andere Dinge interessiert, die mal mehr und mal weniger verrückt sind. Vor allem aber bin ich Feuer und Flamme mit der Programmierung von eigenen kleinen Apps und Programmen, die mein Leben bereichern.

Kommentar hinzufügen

*Pflichtfeld