Aktualisierung ListView

Hallo Leute,
ich bin neu in der Android-Programmierung und versuche seit Tagen vergeblich ein Problem zu lösen:
Meine MainActivity mit NavigationDrawer ruft nach Klick auf einen Drawer-Eintrag ein ListFragment auf, das eine ListView anzeigt.
Dazu werden Daten (MyData-Objekte) aus einer SQLite-DB gelesen. Damit das nicht im UI-Thread erfolgt, habe ich eine Handler-Klasse DbHandler, die Runnable implementiert und über die ich asynchron auf die DB zugreife (Übergabe ArrayList sqlInputData, Rückgabe ArrayList sqlOutputData):

public class MyDataFragment extends ListFragment …

// Objekt der Handlerklasse für Arbeitsthread initialisieren
private DbHandler mDbHandler = null;

private void updateListAdapterData() {
    // alle DS aus DB lesen
    // Eingabedaten für Arbeitsthread vorbereiten 
    // (hier keine notwendig, da alle DS gelesen werden)
    ArrayList sqlInputData = new ArrayList();
    // Methode aufrufen, die SQL-Aktion antriggert und Arbeitsthread erzeugt; 
    // setNewSqlAction liefert nur true, wenn kein Thread läuft
    if (mDbHandler.setNewSqlAction(DbHandler.CMD_GET_ALL_MYDATA, sqlInputData)) {
        new Thread(mDbHandler).start();
    }
}

Das liefert mir die Daten für den ListAdapter, der ein Objekt meiner Klasse MyListDataArrayAdapter, abgeleitet von ArrayAdapter, ist:

public void handleSqlResponse(int sqlCommand, ArrayList sqlOutputData) {
    // Switch Statement, um für jede Aktion eine geeignete Ergebnisbehandlung durchzuführen
    switch (sqlCommand) {
        case DbHandler.CMD_GET_ALL_MYDATA:
             // Liste für Anzeige in der ListView
            List<MyData> mMyDataList =  (List<MyData> sqlOutputData.get(0);
            MyListDataArrayAdapter myListDataArrayAdapter =  
                           new MyListDataArrayAdapter(getActivity(),mMyDataList);
            // Adapter setzen
            setListAdapter(myListDataArrayAdapter);
            // Mehrzeilige Auswahl für CAB erlauben
            getListView().setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);
            break;

…

Die Methode updateListAdapterData rufe ich in onResume() und in Alert-Dialogen nach dem Neuerstellen oder Löschen von MyData-Objekten auf. Hier funktioniert alles und meine ListView wird aktualisiert angezeigt.

Nach Klick auf einen Listeneintrag starte ich eine 2. Activity, in der die Details dargestellt und geändert werden. Dort wird bei onStop() eine Speicherung der geänderten Daten in der DB asynchron über die DbHandler-Klasse gestartet.

Meine ListView bringt diese Änderung nicht, obwohl die Speicherung erfolgt. Der Test zeigt, das onResume() des ListFragments aufgerufen wird, bevor der Speichern-Thread zu ende ist. Damit ist die Speicherung noch nicht abgeschlossen, wenn der Adapter aktualisiert wird.

Kann mir bitte jemand helfen?

Hallo Pascal,

vielen Dank für Deine Hinweise.

Da ich verschiedene Datenobjekte in mehreren Tabellen verwalte, bin ich davon ausgegangen, dass ein eigener Thread notwendig ist. Die Datenmenge ist zwar nicht so groß, aber ich habe überall gelesen, dass man die DB-Zugriffe möglichst in einem eigenen Thread machen soll. Ich fange gerade erst mit der Android-Programmierung an und habe keine Erfahrung, ob es wirklich nötig ist. Das Speichern funktioniert aber.

Jetzt habe ich versucht, zu warten, bis der Thread fertig ist:

protected void onStop() {
    super.onStop();
    // Speichern der Daten im asynchronen Thread
    updateData();
    // Läuft noch Speichern-Thread?
    Boolean isWaiting = true;
    // Warten, bis Speichern-Thread aus Detail-Anzeige beendet ist: isBusy = false
    while (isWaiting) {
        Log.d(LOG, "onStop isBusy " + mDbHandlerTab.isBusy());
        if (!mDbHandlerTab.isBusy()) {
            // Thread ist beendet
            isWaiting = false;
            Log.d(LOG, "onStop isBusy " + mDbHandlerTab.isBusy());
        }
    }
}

Leider hat das nichts geändert. Im locat steht mehrfach ,
...D/ TabActivity: onStop isBusy true
dann
...D/ TabActivity : onStop isBusy false
und die ListView ist nicht aktuell.

Was meinst Du mit:

Dabei startest du dann deinen Thread mit callback.
…
Sobald der Thread fertig ist und das Callback aufgerufen wird, verlässt/beendest du einfach die aktuelle Acitivity.

? Wie starte ich einen Thread "mit callback"? Aus dem Thread kommt er ja in die Methode handleSqlResponse zurück. Dann ist der Thread auch fertig. Sollte ich dort die Activity mit finish() beenden?

Hallo Pascal,
gern möchte ich Deinen Hinweis umsetzen, es außerhalb von onStop zu machen. Ich weis aber nicht wo und wie.
Die 2. Activity ist eine Tab-Activity mit 3 Pages (Fragments), um verschiedene Daten, teilweise mit expliziten Intents, einzugeben. Der Nutzer kann selbst jederzeit durch Klick auf ein Symbol der Toolbar ein Speichern veranlassen (mit Alert-Dialog; funktioniert) und vor Ausführung der expliziten Intents erfolgt das Speichern automatisch.
Alle vorhandenen Daten werden zunächst beim Start eingelesen und stehen den Fragments als public static Variable der Activity zur Verfügung. Änderungen werden über die Listener der Steuerelemente in diesen Variablen zwischengespeichert.
Mein Ziel ist es, beim Verlassen des Programms einen Alert-Dialog aufzurufen, wenn es noch ungespeicherte Änderungen gibt (entsprechendes Flag gesetzt ist), und nur zu Speichern, wenn der User das auswählt. Damit will ich dem User die Möglichkeit geben, Änderungen zu verwerfen.
Den Alert-Dialog bei onStop aufzurufen (, der beim Klick auf Speichern funktioniert), ist mir bisher allerdings auch nicht gelungen (Er wird ohne weitere Fehlermeldung übergangen.), so dass ich erst einmal nur die Speichern-Methode aufrufe, die funktioniert.
Dir Code zu zeigen ist nicht ganz einfach, weil ich viele verschiedene Klassen nutze. Ich versuche mal das Wichtigste der Klasse DbHandler und des Speichern-Moduls der 2. Activity MyDataDetailTabActivity zusammenzufassen:

Ich nutze zum Speichern die gleiche Handler-Klasse DbHandler, wie in der 1. Activity:

// Objekt der Handlerklasse für Arbeitsthread initialisieren
private DbHandler mDbHandlerTab = null;

und in onCreate:

mDbHandlerTab = new DbHandler(mMyDataDataSource, this);

wodurch in der DbHandler-Klasse der entsprechende Konstruktor aufgerufen wird:

public class DbHandler implements Runnable {
…
    // Um nicht zwei Aktionen gleichzeitig auszuführen, wird ein Busy-Flag auf true gesetzt ,
    // solange die aktuelle Aktion noch nicht abgeschlossen ist.
    private boolean isBusy = false;
    // Da verschiedene Aktionen ausgeführt werden, wird die angeforderte Aktion
    // als Zahlencode mit einer eigenen Integer gemerkt, die hier gespeichert wird.
    private int currentSqlCommand = -1;
    // Flag, welches Fragment/Activity den Thread startet
    private int myInstance = -1;
    // lnstanzvariable für DB, welche später im Konstruktor übergeben wird
    private MyDataDataSource mMyDataDataSource = null;
…
    public static final int OBJ_MYDATADETAILTABACTIVITY = 3;
...
    // Referenz auf den Context, um die Ergebnisse der Abfragen an den UI Thread
    // weiterleiten zu können
    private MyDataDetailTabActivity myDataDetailTabActivity = null;
…
    //  Eingangs- und Ausgangsdaten
    private ArrayList sqlInputData = null;
    private ArrayList sqlOutputData = null;
…
    public static final int CMD_UPDATE_DATA = 9;
...
    // Konstruktor für MyDataDetailTabActivity
    public DbHandler(MyDataDataSource mMyDataDataSource, MyDataDetailTabActivity myDataDetailTabActivity) {
        this.mMyDataDataSource = mMyDataDataSource;
        this.myDataDetailTabActivity = myDataDetailTabActivity;
        this.myInstance = OBJ_MYDATADETAILTABACTIVITY;
    }
…
    public synchronized boolean setNewSqlAction(int newSqlComand, ArrayList sqlData) {
        // Läuft eine Aktion?
        if (this.isBusy) {
            // Ja - weitere Aktion kann nicht gestartet werden
            return false;
        }
        // Aktion kann gestartet werden - Flag setzen, weil ab jetzt die Aktion läuft
        this.isBusy = true;
        // Parameter übernehmen
        this.currentSqlCommand = newSqlComand;
        this.sqlInputData = sqlData;
        // true zurückgegeben als Indikation, dass der Befehl erfolgreich registriert wurde
        return true;
    }
…
    @Override
    public void run() {
        // Zur Reduzierung von "Ressourcen-Konkurenz" mit dem UI-Thread
        android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
        // Bereitstellung der Ergebnisse
        setResult();
        // Rückgabe der Ergebnisse an den UI-Thread
        restoreResult();
        // Busy-Flag zurücksetzen auf false, damit weitere Befehle abgearbeitet werden können
        this.isBusy = false;
    }
…
    // Getter zum einfachen Zugriff auf isBusy
    public boolean isBusy() {
        return isBusy;
    }

Die 2. Activity hat folgende Speichermethode:

 private void updateData() {
    // Eingabedaten für Arbeitsthread vorbereiten
    ArrayList sqllnputData = new ArrayList();
    sqllnputData.add(mMyData);
    sqllnputData.add(mWerteRankingList);
    sqllnputData.add(mNotiz);
    sqllnputData.add(mPartner);
    // Methode aufrufen, die SQL-Aktion antriggert und Arbeitsthread erzeugt
    // nur wenn Methode true liefert, kann Thread gestartet werden
    if (mDbHandlerTab.setNewSqlAction(DbHandler.CMD_UPDATE_DATA, sqllnputData)) {
        // Erzeugen und Starten eines neuen Thread
        new Thread(mDbHandlerTab).start();
    } else {
        Log.d(LOG, "Thread läuft noch");
        // anderer Thread läuft noch - Hinweis an den User, die Aktion zu wiederholen
        Toast.makeText(getApplicationContext(),
                getText(R.string.toast_mydata_busy),
                Toast.LENGTH_LONG).show();
    }
 }

Ich hoffe, dass das Dir die entscheidenden Codestellen zeigt.

Kannst Du mir bitte erläutern, was Du mit "außerhalb onStop()" und "Thread mit callback" meinst?

Hallo Pascal,
vielen, vielen Dank für Deine Hilfe! Jetzt klappt alles und meine ListView wird aktualisiert.