Apps für Android programmieren leicht gemacht!
akku sparend programmieren

Akku sparend programmieren

Anders als bei direkt ans Stromnetz angeschlossenen Geräten ist die wohl wichtigste Resource bei einem Handy der Akku.
Alsbald wird es wohl voraussichtlich keine größeren und bezahlbaren neuen Akkus geben, so müssen wir als Entwickler dafür sorgen Akku sparend zu programmieren!

Welcher Spieler oder allgemein Nutzer möchte denn gerne ein Spiel oder eine App benutzen, die innerhalb kürzester Zeit den Akku „verschlingt“?
Ich denke niemand und so sollte es unsere Aufgabe als Programmierer sein nicht nur für ein gutes Aussehen der App, eine Fehler freie App, sondern auch für eine Akku sparende App Sorge zu tragen.

Dieser Artikel selber soll sich nun nicht mit expliziten Beispielen großartig auseinander setzen, sondern lediglich Hilfestellungen geben.
Wir werden zwar Beispiele ansetzen, allerdings mehr zur Verdeutlichung und nicht zur Vertiefung.
Des weiteren werden wir uns darum bemühen diesen Artikel von Zeit zu Zeit mit neuen Tipps, Tricks und Kniffen zu füttern,  zum Akku sparend programmieren.

Was bedeutet Akkuleistung ?

Grundsätzlich sollten wir uns erst einmal darüber im Klaren sein, was Akkuleistung überhaupt im physikalischen Sinne bedeutet.
Im Leistungskurs Informatik lernt man, dass ein Prozessor, der ja Arbeit verrichtet, aus ganz vielen verschiedenen „Schaltstellen“ (um es mal ganz platt auszudrücken) besteht. Diese „Schaltstellen“ (Ich entschuldige mich nochmal für dieses Wort) verrichten durch das ein- oder ausschalten von elektrischen Schaltkreisen eine Berechnung, die vorher programmiert wurde.
An jeder „Schaltstelle“ geht ein wenig Strom verloren (Wiederstand).
Je mehr wir nun also unnötiger Weise berechnen, desto schneller ist am Ende der Akku leer.

Mir ist wohl bewusst, dass sich bei dieser Erklärung Herr Georg Simon Ohm, Herr Alessandro Volta und Herr André-Marie Ampère im Grabe umdrehen werden, allerdings soll diese Erklärung nur zur einfachen Verdeutlichung dienen. Wir wollen keinen unverständlichen Wikipedia-Eintrag schreiben.

Wir wollen nun also versuchen unnötige Berechnungen zu vermeiden, Speicher gar nicht erst unnötig zu belasten und werden dabei sogar noch etwas an der Performance der App schrauben.
Denn der Theorie nach sollte der Verzicht auf unnötige Berechnungen mehr Rechenleistung für die „wichtigen“ Berechnungen frei machen. So können wir nicht nur Akku sparend programmieren, sondern auch noch Performance verbessern.

Auf in die Praxis!

Genug der theoretischen Überlegungen, rein ins Getümmel!

Unnötige Variablen vermeiden

So banal es auch klingen mag.
Variablen werden beim Start der App erstellt und dieser Vorgang verbraucht nicht nur Rechenleistung und damit Akku, sondern auch noch Ram.
Versucht ungenutzte Variablen am Ende der Programmierung zu finden und zu entfernen. Natürlich kann es mal vorkommen, dass man eine Variable erstellt, weil man denkt man könne sie brauchen. Macht euch die Mühe und löscht diese aus dem Programmcode.
Eine zum Start der App erstellte Variable ist nicht dramatisch.
Schlimm könnte es erst werden wenn eine Funktion, die mehrfach in der Sekunde aufgerufen wird, eine unnötige Variable enthält und jedes mal von neuem erstellt.

App richtig beenden

Ein weit verbreiteter „Aberglaube“ ist, dass wenn man auf Zurück klickt, dass die App dann auch geschlossen ist. Nicht nur unter Anwendern sondern auch unter Programmierern selber.
Das stimmt so nicht ganz!

Um Akku sparend zu Programmieren sollte man tunlichst versuchen die App bei nichtgebrauch auch zu schließen.
Klickt ein Nutzer auf den Home-Button ist das vorerst nicht unser Problem, die App wird weiter ausgeführt und kann später wieder geöffnet werden.
Klickt der Nutzer jedoch mehrfach auf den Zurück-Button sollten wir als Entwickler auch so fair sein unsere App ganz zu beenden.
Immerhin möchte man nun anderen Apps Performance frei machen und nicht mit übermäßigen Akkuverbrauch aufregen.

Zum Akku sparend programmieren benötigt man lediglich folgenden Code und die App schließt sich nach einem Doppelklick (1 Sekunde Zeit) auf die Zurücktaste komplett:

public long backpressed;
@Override
public void onBackPressed() {
    if (backpressed + 1000 > System.currentTimeMillis()){
        System.exit(0);
    }
    else{
        Toast.makeText(getBaseContext(),"Doppelklick zum Beenden der App", Toast.LENGTH_SHORT).show();
    }
    backpressed = System.currentTimeMillis();
}

Listener statt Schleifen

Versucht immer eine  Listener zu verwenden, sofern es diesen gibt.
Bei einem Button benutzt man zum Beispiel einen OnClickListener.

Diese Listener sind im Groben gesagt Funktionen die erst dann ausgeführt werden, wenn auch etwas geschieht. Ein OnClickListener wird also genau dann EINMAL ausgeführt ERST wenn der Button auch gedrückt wurde.
Alternativ müsste man alle 0,1 Sekunden fragen ob der Button gerade gedrückt wurde. Sehr performant und energiesparend ist das nicht.

Richtig Pausieren

Gibt es in deinem Spiel vielleicht eine Pausetaste ?
Wenn ja dann versuche nach Möglichkeit die Ausführung aller Funktionen die es in deinem Spiel gibt zu stoppen.
Wenn man zum Beispiel einen Timer in einem Spiel benutzt sollte man diesen Stoppen und später wieder starten, statt ihn weiter laufen zu lassen und innerhalb des Timer zu fragen ob gerade Pause ist.
Hier ein Beispiel:

// ----- ACHTUNG, FALSCHER WEG -----

public Timer timer;
public boolean pause = false; //Gerade keine Pause

public void onCreate(){
   timer = new Timer();    
   refresher = new TimerTask() {
       public void run() {
          if(!pause){
             //Hier wird etwas aufgeführt
          }
       };
   };
   //Timer, Funktion startet jede 0,1 Sekunden
   timer.scheduleAtFixedRate(refresher, 0, 100); 
}

//Diese Funktion wird ausgeführt, wenn Pause geklickt wird
public void PauseKnopf(){
   if( !pause ){
      pause = true; //Starte Pause (Timer wird ausgeführt)
   }else{
      pause = false; //Beende Pause (Timer wird ausgeführt)
   }
}
// ----- RICHTIGER WEG -----

public Timer timer;
public boolean pause = false;

public void onCreate(){
   timer = new Timer();    
   refresher = new TimerTask() {
       public void run() {

             //Hier wird etwas aufgeführt (ohne Pauseabfrage)

       };
   };
   //Timer, Funktion startet jede 0,1 Sekunden
   timer.scheduleAtFixedRate(refresher, 0, 100); 
}

//Diese Funktion wird ausgeführt, wenn Pause geklickt wird
public void PauseKnopf(){
   if( !pause ){
      pause = true; //Starte Pause
      timer.cancel(); // Timer wird gestoppt und verbraucht keinen Akku
   }else{
      pause = false; //Beende Pause
      timer.scheduleAtFixedRate(refresher, 0, 100);  //Timer wird wieder gestartet, da Pause beendet
   }
}

Funktionen stoppen

Allgemein sollte man die Ausführung von Funktionen vermeiden, wenn diese gerade nicht gebraucht werden.
Ich habe es bereits in ein paar Java Quellcodes erlebt, dass jemand eine Funktion durchgehend ausgeführt hat, obwohl sie nicht gebraucht wurde.

Nehmen wir an wir führen eine Funktion aus, die einen roten Kreis auf dem Bildschirm im Kreis drehen lässt.
Nun wird das Layout gewechselt und es ergeben sich zwei Möglichkeiten. Wir lassen die Funktion für die Kreisbewegung weiterlaufen oder wir stoppen die Funktion und starten sie bei Bedarf wieder neu.

Ich lasse euch mal selber entscheiden, welche Möglichkeit wohl besser geeignet ist.

Animationen vermeiden

Animationen sehen schön aus, können eure App attraktiver machen und verbessern die Freude des Nutzers vielleicht ein wenig, aber aufgepasst!
Animationen müssen berechnet und angezeigt werden und damit gehören sie zu den Akku fressenden Dingen.
Nutzt sie also in Maßen, denn ohne Animationen sieht eine App dann doch etwas „ungeliebt“ aus.

Weiß vermeiden

Versucht große weiße Flächen in eurer App zu vermeiden, z.b. beim Hintergrund.
Ok zugegeben, dieser Tipp klingt verdammt lächerlich. Er hat allerdings einen ernsthaften Sinn und ist nicht ganz unberechtigt.

Jeder Pixel eures Displays besteht aus drei LED’s. Einer roten, gelben und einer blauen LED.
Je nachdem wie stark diese einzelnen LED’s leuchten erscheint der Pixel für das menschliche Auge in einer anderen Farbe.
Leuchtet keine der drei LED’s, erscheint der Pixel schwarz.
Leuchtet nur die rote LED, erscheint der Pixel rot.
Leuchten alle der drei LED’s, erscheint der Pixel weiß.

Genau hier haben wir den Knackpunkt!
Lassen wir große Flächen weiß, dann müssen innerhalb dieser Flächen viele LED’s unter Volllast leuchten und das zieht Akku.
Versucht es doch mal mit einem Grauton, bei diesem strahlen die Pixel nicht so hell und es wird Akku gespart.

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