Android AsyncTaskLoader ne démarre pas loadInBackground?

Je suis en train de mettre en œuvre un chargeur exemple sur Android, mais ne pouvez pas l'obtenir pour démarrer le chargeur. Je suis en utilisant le code suivant. Elle sera sur le "Créer un Loader", mais il n'atteindra jamais le "Chargement a commencé" message de log. Suis-je en manque un à l'appel que j'ai besoin?

Activité:

    public class TestingZoneActivity extends ListActivity implements LoaderCallbacks<ArrayList<Content>>{

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);

            getLoaderManager().initLoader(0, null, this);
        }

        @Override
        public Loader<ArrayList<Content>> onCreateLoader(int id, Bundle args) {
            Log.e("TEST", "Create Loader");
            return new ImageLoader(this);
        }

        @Override
        public void onLoadFinished(Loader<ArrayList<Content>> loader, ArrayList<Content> data) {
            setListAdapter(new ImageAdapter(this, data));
        }

        @Override
        public void onLoaderReset(Loader<ArrayList<Content>> loader) {
            setListAdapter(null);
        }
    }

Chargeur:

    public class ImageLoader extends AsyncTaskLoader<ArrayList<Content>> {

        public ImageLoader(Context context) {
            super(context);
        }

        @Override
        public ArrayList<Content> loadInBackground() {
            Log.e("TEST", "Loading started");
        }

    }

êtes-vous à l'aide de la bibliothèque de compatibilité?Si oui, jetez un oeil à cette question
Non, je suis ciblage 3.0
Bien que le thread a résolu mon problème. Poster une réponse et je vais accepter.
La meilleure façon pour vous de comprendre qui est la vérification de la CursorLoader du code source. En fait, vous devez prendre soin de quand loadInBackground() doit être appelé, ainsi que de la façon dont votre code n'est pas appelée. Juste remplacer loadInBackground() n'est pas suffisant, et vous pouvez le vérifier dans la documentation. Par exemple, à l'intérieur de votre application, vous avez à décider par les conditions lors de la forceLoad() doit être exécutée.

InformationsquelleAutor Bobbake4 | 2012-05-09

android java

128

J'ai eu le même problème à l'aide de la bibliothèque de compatibilité.
Je l'ai résolu en appelant forceLoad
```
getLoaderManager().initLoader(0, null, this).forceLoad();
```
Évidemment la documentation sur AsyncLoader est ce qui manque et ce problème existe aussi sur le Nid d'abeille. Plus d'informations peuvent être trouvées ici

Officiel exemple de AsyncTaskLoader est également un appel forceLoad() donc ce n'est pas un bug, mais je continue de penser que ce comportement n'est pas très intuitive.
- Merci beaucoup! Il est vraiment dommage que le fonctionnaire Android documentation a ce genre de problèmes/incongruences.
- Comme vous le savez si demandé chargeur existe déjà et a généré des données de l'appelant LoaderManager.initLoader() déclenche le tir LoaderCallbacks<D>.onLoadFinished() omettant AsyncTaskLoader<D>.onLoadInBackground() de rappel. Mais dans le même temps " AsyncTaskLoader<D>.forceLoad()` forces de la procédure de chargement de recommencer sans déclaration lorsque vous avez terminé. Cela peut entraîner un comportement inattendu. Meilleure apparence à la méthode AsyncTaskLoader<D>.onStartLoading() et de mettre en œuvre AsyncTaskLoader<D>.forceLoad() là.
- Juste pour être complet, j'ai aussi besoin d'appeler #forceLoad() sur getLoaderManager().restartLoader(...) en plus de getLoaderManager().initLoader(...)
- Cela provoque loadInBackground() d'être appelé inutilement souvent, c'est à dire sur le changement d'orientation, qui ne se produit pas lors de la substitution deliverResult() et onStartLoading() correctement.
- Cela n'a pas fonctionné pour moi, onContentChanged() au lieu de forceLoad() ni. Peut-être que c'est parce que je suis en utilisant getSupportLoaderManager(). Mais ce qui a fonctionné pour moi, était-ce: getSupportLoaderManager().restartLoader(0, null, MyActivity.this);
- Merci man, vous avez sauvé ma journée. Si quelqu'un à l'aide de l'appui du syndicat. ils peuvent utiliser "getSupportLoaderManager()" au lieu de "getLoaderManager()"
InformationsquelleAutor Renard
25

Primordial loadInBackground() n'est pas assez.

Ont un look à la AppListLoader sur http://developer.android.com/reference/android/content/AsyncTaskLoader.html .

À moins d'y ajouter ces deux méthodes pour votre chargeur:
```
        @Override
        protected void onStartLoading() {
            if (takeContentChanged())
                forceLoad();
        }

        @Override
        protected void onStopLoading() {
            cancelLoad();
        }
```
et appel onContentChanged() de son constructeur.
- Il semble que vous aussi, vous devez utiliser getLoaderManager().initLoader(0, null, this).onContentChanged(); construction
- C'est pour le cas si le chargeur se bloque lorsque l'image a commencé à charger, puis s'arrêta, puis reprit.
- Juste l'ajout de ces deux méthodes n'est pas suffisant, vous devez ajouter onContentChanged(); dans le constructeur, après un appel à super(). (Ou utiliser le .onContentChanged (), où vous pouvez l'appeler comme @boris dit
InformationsquelleAutor rrayst
13

rrayst's avis est assez compact. Si vous écrivez votre méthode comme ceci:
```
protected void onStartLoading() {
    forceLoad();
}
```
vous "ll remarquer que lorsqu'une activité enfant vient et puis vous revenez à la mère de l'un, onStartLoading (et donc loadInBackground) sont de nouveau appelé la!

Que pouvez-vous faire?
Définir une variable interne (mContentChanged) à true dans le constructeur; puis vérifier cette variable à l'intérieur de onStartLoading. Seulement quand il est vrai, commencer à charger pour de vrai:
```
package example.util;

import android.content.Context;
import android.support.v4.content.AsyncTaskLoader;

public abstract class ATLoader<D> extends AsyncTaskLoader<D> {

    public ATLoader(Context context) {
        super(context);
        //run only once
        onContentChanged();
    }

    @Override
    protected void onStartLoading() {
        //That's how we start every AsyncTaskLoader...
        //-  code snippet from  android.content.CursorLoader  (method  onStartLoading)
        if (takeContentChanged()) {
            forceLoad();
        }
    }

    @Override
    protected void onStopLoading() {
        cancelLoad();
    }
}
```
- Je déteste ce comportement. Dans n'importe quel endroit de la documentation qu'il dit onStartLoading() sera appelée après qu'un enfant de l'activité se termine et le parent est de retour. Heureusement takeContentChanged() résout le problème.
- Est-il possible de vérifier si le chargeur a terminé son travail? Serait-réglage de la valeur d'une variable booléenne dans deliverResult faire l'affaire? Ou dois-je faire de plus?
- Faut-il appeler "cancelLoad" dans "onStopLoading" ?
- Bien que je n'avais pas de problèmes d'omettre cet appel, j'ai édité mon code.
InformationsquelleAutor KitKat
2

Puisque aucune de ces réponses ici (en plus de l'accepté un) seul m'a aidé à résoudre ce problème, ici, est de savoir comment il a travaillé pour moi.

Je ne pense pas que l'on a accepté la réponse est la bonne solution, car elle provoque des loadInBackground() être appelé le plus souvent que nécessaire, c'est à dire sur le changement d'orientation, qui ne se produit pas lorsque correctement surchargeant les méthodes suivantes dans le chargeur ainsi:
```
@Override
public void deliverResult(final List<Participant> data) {
    participants = data;

    if (isStarted()) {
        super.deliverResult(data);
    }

}

@Override
protected void onStartLoading() {
    if (takeContentChanged() || participants == null) {
        forceLoad();
    }
}
```
InformationsquelleAutor Torsten Römer
0

Si vous utilisez un chargeur personnalisé, vous pouvez enregistrer les dernières données de référence, et qu'il est disponible via un getter. lorsque l'utilisateur fait pivoter son écran, vous pouvez obtenir le chargeur de retour de getLoaderManager().getLoader méthode, puis, de retour à la référence. Pour mes tests j'ai remarqué que startLoadering va tout le chemin à CustomLoader.onLoadFinished mais le résultat n'est jamais le livrer à l'activité.onLoadFinished.Je soupçonne l'activité de référence est perdue lors de la rotation. Par la façon dont la grande chose au sujet de la création de chargeurs, c'est qu'ils sont persistantes à travers LoaderManager. Pensez à elle comme une autre saveur de headless fragments.. lol.
```
Loader loader  =  getLoaderManager().getLoader(LOADER_ID);

if( loader == null )
{
    getLoaderManager().initLoader(LOADER_ID, null, MyActivity.this );
}
else
{
    listAdapter.addAll(((CustomLoader) loader).getLastData());
}
```
InformationsquelleAutor Juan Mendez
0

J'ai constaté que chacune des solutions ci-dessus ont des problèmes, en particulier lorsque l'application démarre lorsque l'écran est éteint, et le chargement prend que quelques instants.

Voici ma solution (sur une base de ce):

https://stackoverflow.com/a/22675607/878126

InformationsquelleAutor android developer

Vous devez vous connecter pour publier un commentaire.