Update UI von einem AsyncTaskLoader

Habe ich umgewandelt mein AsyncTask zu einem AsyncTaskLoader (meist zum Umgang mit änderungen in der Konfiguration). Ich habe eine TextView ich bin mit so einem status und wurde mit onProgressUpdate im AsyncTask zu aktualisieren. Es sieht nicht wie AsyncTaskLoader hat ein gleichwertiges, also während loadInBackground (in der AsyncTaskLoader) ich bin mit diesem:

getActivity().runOnUiThread(new Runnable() {
    public void run() {
        ((TextView)getActivity().findViewById(R.id.status)).setText("Updating...");
    }
});

Ich bin mit diesem in einem Fragment, das ist, warum ich bin mit getActivity(). Diese Arbeit ziemlich gut, außer, wenn eine änderung der Konfiguration geschieht, wie die änderung der Ausrichtung des Bildschirms. Meine AsyncTaskLoader läuft (das ist, warum ich bin mit einem AsyncTaskLoader), aber die runOnUiThread scheint übersprungen.

Nicht sicher, warum es übersprungen wird oder wenn dies ist der beste Weg, um die Aktualisierung der Benutzeroberfläche von einer AsyncTaskLoader.

UPDATE:

Ich landete Rückkehr zu einer AsyncTask wie es scheint besser geeignet für die UI-updates. Wünschte, Sie könnte Zusammenführen, was zusammen mit einer AsyncTask mit einem AsyncTaskLoader.

InformationsquelleAutor Kris B | 2012-04-16

4

Es ist tatsächlich möglich. Sie im Grunde brauchen, um eine Unterklasse der AsyncTaskloader und Umsetzung einer publishMessage() Methode, die eine Handler zu liefern, die Fortschritte, die Botschaft für eine Klasse, die die ProgressListener (oder was auch immer Sie es nennen wollen) Schnittstelle.

Laden Sie diese für ein Beispiel: http://www.2shared.com/file/VW68yhZ1/SampleTaskProgressDialogFragme.html (mir Nachricht, wenn er offline geht) - dies wurde auf der Basis von http://habrahabr.ru/post/131560/
- Ich denke, das ist eine sehr clever hack. Ich habe nie darüber nachgedacht. Ich war auf der Suche für den Weg zu schicken, die meine Fortschritte von updates mittels Radlader. Ich bin gonna versuchen Sie es und lassen Sie wissen. Ich denke, deine Lösung sollte funktionieren!!
- Der link scheint defekt. Hier's a working man (ich denke es ist das gleiche).
InformationsquelleAutor Oleg Vaskevich

Emm... Sie sollten dies nicht tun.

denn wie eine anonyme Klasse Zugriff auf übergeordnete Klasse, Methode oder Feld ist durch die Lagerung einen unsichtbaren Verweis auf die übergeordnete Klasse.

zum Beispiel haben Sie eine Activity:

public class MyActivity
    extends Activity
{
    public void someFunction() { /* do some work over here */ }

    public void someOtherFunction() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true)
                    someFunction();
            }
        };
        new Thread(r).start(); //use it, for example here just make a thread to run it.
    }
}

den compiler wirklich erzeugt so etwas wie dieses:

private static class AnonymousRunnable {
    private MyActivity parent;
    public AnonymousRunnable(MyActivity parent) {
        this.parent = parent;
    }

    @Override
    public void run() {
        while (true)
            parent.someFunction();
    }
}

So, wenn Sie Ihre Eltern Activity zerstört (aufgrund der Konfiguration ändern, zum Beispiel), und Ihre anonymen Klasse immer noch vorhanden ist, wird die ganze Aktivität nicht gc-ed. (weil jemand immer noch eine Referenz.)

, DIE ZU EINEM SPEICHERVERLUST UND MACHEN SIE IHRE APP GEHEN, LIMBO!!!

Wenn es mir war, würde ich die Umsetzung der "onProgressUpdate()" für Radlader wie dieser:

public class MyLoader extends AsyncTaskLoader<Something> {
    private Observable mObservable = new Observable();
    synchronized void addObserver(Observer observer) {
        mObservable.addObserver(observer);
    }
    synchronized void deleteObserver(Observer observer) {
        mObservable.deleteObserver(observer);
    }

    @Override
    public void loadInBackground(CancellationSignal signal)
    {
        for (int i = 0;i < 100;++i)
            mObservable.notifyObservers(new Integer(i));
    }
}

Und in Ihrem Activity Klasse

public class MyActivity extends Activity {
    private Observer mObserver = new Observer() {
        @Override
        public void update(Observable observable, Object data) {
            final Integer progress = (Integer) data;
            mTextView.post(new Runnable() {
                mTextView.setText(data.toString()); //update your progress....
            });
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreated(savedInstanceState);

        MyLoader loader = (MyLoader) getLoaderManager().initLoader(0, null, this);
        loader.addObserver(mObserver);
    }

    @Override
    public void onDestroy() {
        MyLoader loader = (MyLoader) getLoaderManager().getLoader(0);
        if (loader != null)
            loader.deleteObserver(mObserver);
        super.onDestroy();
    }
}

erinnern zu deleteObserver() während onDestroy() ist wichtig, auf diese Weise die loader nicht über einen Verweis auf Ihre Tätigkeit für immer. (der loader wird wahrscheinlich am Leben gehalten werden während Ihres Application lifecycle...)

Es scheint fehlen dir ein setChanged() auf die Beobachtbare, sind Sie nicht?

InformationsquelleAutor 曾其威

1

Beantwortung meiner eigenen Frage, aber von was ich sagen kann, AsyncTaskLoader ist nicht die beste zu verwenden, wenn Sie brauchen, um die Aktualisierung der Benutzeroberfläche.

InformationsquelleAutor Kris B
0

In der Klasse, in die Sie implementieren LoaderManager.LoaderCallback (vermutlich Ihre Aktivität), gibt es eine onLoadFinished() Methode, die man überschreiben muss. Dies ist, was zurückgegeben wird, wenn die AsyncTaskLoader geladen wurde.
- Ich kann mich irren aber ist das nicht onLoadFinished aufgerufen, wenn der AsyncTaskLoader fertig ist laden? Nicht ganz sicher, wie die Adressen mein Problem, aber ich bin neu in AsyncTaskLoaders so kann ich etwas vermissen. Ist onLoadFinished entspricht onProgressUpdate in einem AsyncTask?
- Es ist das äquivalent onPostExecute
- Das ist nicht das, was ich Suche. Ich brauche das äquivalent von onProgressUpdate, so kann ich zeigen, den status, die als hintergrund-Prozess ausgeführt wird. Ich glaube nicht, dass AsyncTaskLoader hat.
- siehe meine Antwort ^
InformationsquelleAutor Jason Robinson

Die beste Methode ist die Verwendung von LiveData, 100% Arbeiten

Schritt 1: Hinzufügen von lifecycle-Abhängigkeit oder verwenden Sie androidx Artefakte, da ja während der Projekt-Erstellung

implementation "androidx.lifecycle:lifecycle-livedata:2.1.0"

Schritt 2: Erstellen der loader-Klasse wie folgt in der loader erstellen in öffentliche Methode zum setzen der livedata, dass beobachtet werden kann, von Aktivität oder fragment. finden Sie die setLiveCount Methode in meine loader-Klasse.

package com.androidcodeshop.asynctaskloaderdemo;

import android.content.Context;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.MutableLiveData;
import androidx.loader.content.AsyncTaskLoader;

import java.util.ArrayList;

public class ContactLoader extends AsyncTaskLoader<ArrayList<String>> {

private MutableLiveData<Integer> countLive = new MutableLiveData<>();


synchronized public void setLiveCount(MutableLiveData<Integer> observer) {
    countLive = (observer);
}


public ContactLoader(@NonNull Context context) {
    super(context);
}

@Nullable
@Override
public ArrayList<String> loadInBackground() {
    return loadNamesFromDB();
}

private ArrayList<String> loadNamesFromDB() {

    ArrayList<String> names = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        try {
            Thread.sleep(1000);
            names.add("Name" + i);
            countLive.postValue(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    return names;
}


@Override
protected void onStartLoading() {
    super.onStartLoading();
    forceLoad(); //forcing the loading operation everytime it starts loading
}
}

Schritt 3: Legen Sie die live-Daten aus Aktivität und beobachten Sie die änderung wie folgt

package com.androidcodeshop.asynctaskloaderdemo;

import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.MutableLiveData;
import androidx.loader.app.LoaderManager;
import androidx.loader.content.Loader;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import java.util.ArrayList;

public class MainActivity extends AppCompatActivity implements 
LoaderManager.LoaderCallbacks<ArrayList> {

private ContactAdapter mAdapter;
private ArrayList<String> mNames;
private MutableLiveData<Integer> countLiveData;
private static final String TAG = "MainActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mNames = new ArrayList<>();
    mAdapter = new ContactAdapter(this, mNames);
    RecyclerView mRecyclerView = findViewById(R.id.recycler_view);
    mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
    mRecyclerView.setAdapter(mAdapter);
    countLiveData = new MutableLiveData<>();
    countLiveData.observe(this, new androidx.lifecycle.Observer<Integer>() {
        @Override
        public void onChanged(Integer integer) {
            Log.d(TAG, "onChanged: " + integer);
            Toast.makeText(MainActivity.this, "" + 
    integer,Toast.LENGTH_SHORT).show();
        }
    });

    //initialize the loader in onCreate of activity
    getSupportLoaderManager().initLoader(0, null, this);
    //it's deprecated the best way is to use viewmodel and livedata while loading data
}

@NonNull
@Override
public Loader onCreateLoader(int id, @Nullable Bundle args) {

    ContactLoader loader = new ContactLoader(this);
    loader.setLiveCount(countLiveData);
    return loader;
}

@Override
public void onLoadFinished(@NonNull Loader<ArrayList> load, ArrayList data) {
    mNames.clear();
    mNames.addAll(data);
    mAdapter.notifyDataSetChanged();
}


@Override
public void onLoaderReset(@NonNull Loader loader) {
    mNames.clear();
}

@Override
protected void onDestroy() {
    super.onDestroy();
}

}

Hoffe, dies wird Ihnen helfen,:) happy coding

InformationsquelleAutor Prakash Sharma

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.