Activity, View und Thread Kommunikation

Androidiot · 28. November 2014

Hallo zusammen,

ich möchte eine App mit folgenden Funktionen erzeugen:
Eine Aktivity die ein Koordinatensystem anzeigt mit einer Kennlinie.
Parallel soll ein Thread laufen, der zyklisch aufwendigere Berechnungen durchführt und nach einem Durchlauf das Ergebnis zurück gibt.
Das Koordinatensystem wird in einer separaten View-Klasse erzeugt.
Mein Ordentlichkeits-Sinn sagt mir, dass ich die 3 Klassen in eigenen .java-Dateien erzeuge.

Wie immer ist das Problem, dass alles miteinander kommuniziert wie es soll, also der Thread sein Ergebnis (ein Float oder Double Array) zyklisch an die Aktivity bzw. view übergibt.

Ich habe schon mehrere interessante Kommunikations-Ansätze gefunden: Runnables, Handler, Broadcasts, AsyncTasks
aber wie ich den Umweg dabei gehen soll, da ich ja in der View-Klasse zeichne und nicht in der Activity habe ich bisher bei keinem verstanden.
Dem Konstruktor der View darf ich z.B. keine benutzerdefinierten Parameter übergeben.
Außerdem habe ich schon Nachteile bei z.B. Broadcasts gelesen, dass diese nicht für zyklische Kommunikation geeignet wären.

Es wäre also sehr hilfreich einen Tipp zu haben mit welchem Java oder Android Kommunikationswerkzeug ich auf dem richtigen Weg bin oder besser wie das Kommunikations-Grundgerüst aussehen müsste um die Funktion zu erfüllen.
Vielen Dank vorab.

Grüße vom Bodensee

Marco Feltmann · 1. Dezember 2014

Moin,

das klingt nach der typischen Aufgabe für einen AsyncTask.
Den Du entgegen Deines Ordentlichkeits-Sinns nicht in eine eigene Java Datei packst, sondern als Klasse in Deine Activity.

Dort hast Du dann mit entsprechendem Aufbau direkten Zugriff auf Dein View und kannst aus dem onProgress direkt auf das View zugreifen.

Alternativ in einen Service damit und ein paar Callbacks definiert.

Androidiot · 6. Januar 2015

Hallo nochmal,

die AsyncTask, Broadcasts, Services scheinen alles Funktionen zu sein für mehr sporadische, länger laufende Aufgaben.
In meinem Fall soll immer die gleiche Funktion berechnet werden, nur eben x-mal pro Sekunde.
Natürlich mit anderen Zahlen sonst wärs ja langweilig!

Das ideale Mittel für die Aufgabe scheinen die Handler zu sein.
Das einzige Beispiel das dies mit unabhängigen Klassen erklärt habe ich auf Android-Developers gefunden.
Nur das ist leider so umfangreich gehalten, dass ich es nicht verstehe und nicht für meine Zwecke hinbiegen kann.
Das mit den internen Klassen kommt mir immer etwas wie Getrickse vor.

Gibt es nirgends ein kurz und knappes Programm-Gerüst mit einer Aktivity und einem normalen separaten Thread, wo z.B. ein int-Wert per Handler übergeben wird?

Gruß

Marco Feltmann · 7. Januar 2015

Das einzige Handler-Beispiel, das ich kenne, findet sich bei Vogella:
http://www.vogella.com/tutoria….html#concurrency_handler

Ich kann mir nicht vorstellen, dass Dir das in irgend einer Art und Weise helfen wird.
Das könnte daran liegen, dass ich bezüglich Deiner Problembeschreibung davon ausgehe, dass ständig irgendwas im Hintergrund berechnet wird und diese Berechnung ständig die Anzeige aktualisieren soll.

Die internen Klassen sind Gefrickel. Das liegt daran, dass Java zusammengefrickelt ist. Da hat es sich eingebürgert, so zu arbeiten.

Androidiot · 8. Juni 2015

Nach einigem Nachdenken und größeren Küstlerpausen, die gewünschte Antwort auf meine Frage.
Das Grundgerüst einer einfachen Activity ohne Schnikschnak.
Ein Arbeitsthread, der in einer separaten Klasse liegt und zyklisch Ergebnisse sendet.
Der Handler als Kommunikationsmedium zudem static mit einer WeakReference, dass die Warnung verschwindet.
Die zugehörige View besteht nur aus dem verlinkten Textview und einer Statusbar.
Hoffe das ganze arbeitet ressourcenarm, damit die Berechnungen möglichst komplex werden können.

Verbesserungsvorschläge sind natürlich willkommen.

Java

package example.akkustiksynth.de.threadhandler;


import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.ProgressBar;
import android.widget.TextView;


import java.lang.ref.WeakReference;




public class MainActivity extends Activity {
    ProgressBar progressBar1;
    TextView textView1;
    MainHandler mainHandler1;
    Thread thread1;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        // UI-Elemente zuweisen
        progressBar1 = (ProgressBar) findViewById(R.id.progressBar01);
        textView1 = (TextView) findViewById(R.id.textView2);


        // Weitere Elemente
        mainHandler1 = new MainHandler(this); // vor Thread erzeugen (Gleichzeitigkeit)
        thread1 = new WorkerThread(mainHandler1);
        thread1.start();
     }


    public void updateResults(int info1) {
        textView1.setText(String.valueOf(info1));
        progressBar1.setProgress(info1);
    }


    // UI-Handler statisch mit WeakReference gegen Memory-leaks
    private static class MainHandler extends Handler {
        private final WeakReference&lt;MainActivity&gt; currentActivity1;


        public MainHandler(MainActivity activity1) {
            currentActivity1 = new WeakReference&lt;MainActivity&gt;(activity1);
        }


        @Override
        public void handleMessage(Message message) {
            MainActivity activity = currentActivity1.get();
            if (activity != null){
                activity.updateResults(message.getData().getInt("info"));
            }


        }
    };


/*  // Thread als interne Klasse
    public class WorkerThread extends Thread {
        @Override
        public void run() {
            for (int i=0; i&lt;=100; i++) {
                Bundle bundle1 = new Bundle();
                Message message1 = Message.obtain();
                bundle1.putInt("info", i);
                message1.setData(bundle1);
                mainHandler1.sendMessage(message1);


                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }*/
}

Alles anzeigen

Code

package example.akkustiksynth.de.threadhandler;


import android.os.Bundle;
import android.os.Handler;
import android.os.Message;


public class WorkerThread extends Thread {
    Handler threadHandler1;


    public WorkerThread(Handler handler1) {
        threadHandler1 = handler1; // Handler mit UI-Handler verbinden
    }


    @Override
    public void run() {
        for (int i=0; i&lt;=100; i++) {
            // einfachen INT-Wert zyklisch senden
            Bundle bundle1 = new Bundle();
            Message message1 = Message.obtain(); // oder new Message();
            bundle1.putInt("info", i);
            message1.setData(bundle1);
            threadHandler1.sendMessage(message1);


            // Thread takten / pausieren
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
                return;
            }
        }
    }
}

Alles anzeigen

Ben · 10. Juni 2015

würde den thread vielleicht noch in einen service auslagern, ich weiß nicht ob android den prozess dann besser priorisiert, aber aufjedenfall bleibt er länger am leben wenn deine app nicht mehr im vordergrtund ist.

Activity, View und Thread Kommunikation

Jetzt mitmachen!

Teilen