AsyncTaskLoader exemple de base. (Android)

J'utilise un chargeur dans mon application et sur la base du résultat que je reçois de la requête que je réalise sur COntacts à l'aide de ce chargeur. J'effectue certains calculs et les stocke dans un DB Sqlite. Je veux que cette opération soit asynchrone, mais je suis confus entre l'utilisation d'une tâche Async, car j'ai beaucoup de différents types de données à renvoyer ou dois-je utiliser un gestionnaire simple ou AsyncTaskLoader, je veux qu'il soit simple car je suis nouveau Chargeurs. J'ai essayé de rechercher des exemples d'AsyncTaskLoader, mais il semble que la science des fusées, un exemple fonctionnel simple et simple de l'un des trois dans le contexte de mon scénario serait très utile.

  • ListView avec ArrayAdapter et ViewHolder ajoutant des icônes au mauvais élément
  • Comment trouver les restrictions disponibles d'une application pour DevicePolicyManager.setApplicationRestrictions
  • Flameur de fadein d'animation alpha Android avec des retards
  • Android viewview personnalisé, setOnItemSelectedListener ne fonctionne pas
  • BluetoothAdapter.startScan () vs BluetoothAdapter.startLeScan ()
  • Vérifiez si EditText est vide.
  • Comment trouver et activer le mode de débogage USB sur Nexus 4
  • SSLHandshakeException Trust ancre pour le chemin de certification introuvable Android HTTPS
  • Jouer de la vidéo à l'aide de la texture dans la vue de recyclage
  • Impossible de mettre à jour la vue, la liaison des données ne fonctionne pas - Angularjs et PhoneGap
  • Mot de passe protégeant mon application Android (la manière simple)
  • Twitter OAuth Rest Api Statut Paramètre '@' symbole
  • 5 Solutions collect form web for “AsyncTaskLoader exemple de base. (Android)”

    Depuis Honeycomb et la bibliothèque de compatibilité v4, il est possible d'utiliser AsyncTaskLoader . D'après ce que je comprends, AsyncTaskLoader peut survivre grâce à des changements de configuration comme les AsyncTaskLoader écran. Mais en utilisant AsyncTask vous pouvez faire des problèmes avec les modifications de configuration.

    Informations clés: AsyncTaskLoader est une sous-classe de Loader . Cette classe exécute la même fonction que AsyncTask, mais un peu mieux, elle peut également être utile pour gérer les modifications de configuration (orientation de l'écran).

    Un très bon exemple et explication est donné ici. http://www.javacodegeeks.com/2013/01/android-loaders-versus-asynctask.html

    Google a un très bon exemple directement dans les documents API. Les modèles de conception Android fournissent plus de détails et le raisonnement derrière les chargeurs.

    Ce tutoriel vous aidera définitivement. http://www.javacodegeeks.com/2013/08/android-custom-loader-to-load-data-directly-from-sqlite-database.html

    Si vous souhaitez utiliser AsyncTaskLoader, voici un bon exemple pour vous.

    EDIT: J'ai décidé de faire une solution plus simple:

     public abstract class AsyncTaskLoaderEx<T> extends AsyncTaskLoader<T> { private static final AtomicInteger sCurrentUniqueId = new AtomicInteger(0); private T mData; public boolean hasResult = false; public static int getNewUniqueLoaderId() { return sCurrentUniqueId.getAndIncrement(); } public AsyncTaskLoaderEx(final Context context) { super(context); onContentChanged(); } @Override protected void onStartLoading() { if (takeContentChanged()) forceLoad(); else if (hasResult) deliverResult(mData); } @Override public void deliverResult(final T data) { mData = data; hasResult = true; super.deliverResult(data); } @Override protected void onReset() { super.onReset(); onStopLoading(); if (hasResult) { onReleaseResources(mData); mData = null; hasResult = false; } } protected void onReleaseResources(T data) { //nothing to do. } public T getResult() { return mData; } } 

    Usage:

    Dans votre activité:

      getSupportLoaderManager().initLoader(TASK_ID, TASK_BUNDLE, new LoaderManager.LoaderCallbacks<Bitmap>() { @Override public Loader<Bitmap> onCreateLoader(final int id, final Bundle args) { return new ImageLoadingTask(MainActivity.this); } @Override public void onLoadFinished(final Loader<Bitmap> loader, final Bitmap result) { if (result == null) return; //TODO use result } @Override public void onLoaderReset(final Loader<Bitmap> loader) { } }); 

    Classe interne statique ou classe normale:

     private static class ImageLoadingTask extends AsyncTaskLoaderEx<Bitmap> { public ImageLoadingTask (Context context) { super(context); } @Override public Bitmap loadInBackground() { //TODO load and return bitmap } } 

    Voici un tutoriel étape par étape pour implémenter AsyncTaskLoader

    1. LoaderManager.LoaderCallbacks<String> sur MainActivity et créez un static int pour identifier de manière unique votre chargeur et créer une clé de chaîne pour passer l'URL de chaîne à votre chargeur

       public class MainActivity extends AppCompatActivity implements LoaderManager.LoaderCallbacks<String>{ public static final int OPERATION_SEARCH_LOADER = 22; public static final String OPERATION_QUERY_URL_EXTRA = "query"; //...} 
    2. Override onCreateLoader , onLoadFinished et onLoaderReset fonctions dans MainActivity

       @Override public Loader<String> onCreateLoader(int id, final Bundle args) { //Here we will initiate AsyncTaskLoader return null; } @Override public void onLoadFinished(Loader<String> loader, String operationResult) { //Think of this as AsyncTask onPostExecute method, the result from onCreateLoader will be available in operationResult variable and here you can update UI with the data fetched. Log.d("MAINACTIVITY","result : "+ operationResult); } @Override public void onLoaderReset(Loader<String> loader) { //Don't bother about it, Android Studio will override it for you } 
    3. onCreateLoader() renvoie un nouveau AsyncTaskLoader<String> comme une classe interne anonyme avec this comme paramètre du constructeur et surpasser loadInBackground & onStartLoading dans la classe interne anonyme

       @Override public Loader<String> onCreateLoader(int id, final Bundle args) { return new AsyncTaskLoader<String>(this) { @Override public String loadInBackground() { //Think of this as AsyncTask doInBackground() method, here you will actually initiate Network call return null; } @Override protected void onStartLoading() { //Think of this as AsyncTask onPreExecute() method,start your progress bar,and at the end call forceLoad(); forceLoad(); } }; } 
    4. Inside loadInBackground effectuez un appel réseau en utilisant HTTPUrlConnection ou OKHttp ou tout ce que vous utilisez.

        @Override public String loadInBackground() { String url = args.getString();//This is a url in string form if (url!=null&&"".equals(url)) { return null;//if url is null, return } String operationResult=""; try { operationResult = NetworkUtils.getResponseFromHttpUrl(url);//This just create a HTTPUrlConnection and return result in strings } catch (IOException e) { e.printStackTrace(); } return operationResult; } 
    5. À l'intérieur, onCreate initialiser le chargeur avec OPERATION_SEARCH_LOADER comme ID, null for the bundle, et ceci pour le contexte

       getSupportLoaderManager().initLoader(OPERATION_SEARCH_LOADER, null, this); 
    6. Appelez maintenant cette méthode, chaque fois que vous souhaitez déclencher le chargeur

       private void makeOperationSearchQuery(String url) { // Create a bundle called queryBundle Bundle queryBundle = new Bundle(); // Use putString with OPERATION_QUERY_URL_EXTRA as the key and the String value of the URL as the value queryBundle.putString(OPERATION_QUERY_URL_EXTRA,url); // Call getSupportLoaderManager and store it in a LoaderManager variable LoaderManager loaderManager = getSupportLoaderManager(); // Get our Loader by calling getLoader and passing the ID we specified Loader<String> loader = loaderManager.getLoader(OPERATION_SEARCH_LOADER); // If the Loader was null, initialize it. Else, restart it. if(loader==null){ loaderManager.initLoader(OPERATION_SEARCH_LOADER, queryBundle, this); }else{ loaderManager.restartLoader(OPERATION_SEARCH_LOADER, queryBundle, this); } } 

    Walla, vous avez terminé, juste pour vous rappeler NetworkUtils.getResponseFromHttpUrl(url); Est ma fonction personnalisée qui prend la chaîne la convertir en URL qui, à son tour, sert à créer HTTPUrlConnection

    J'aime ce bref exemple AsyncTask et AsyncTaskLoader .

     class FooLoader extends AsyncTaskLoader { public FooLoader(Context context, Bundle args) { super(context); // do some initializations here } public String loadInBackground() { String result = ""; // ... // do long running tasks here // ... return result; } } class FooLoaderClient implements LoaderManager.LoaderCallbacks { Activity context; // to be used for support library: // FragmentActivity context2; public Loader onCreateLoader(int id, Bundle args) { // init loader depending on id return new FooLoader(context, args); } public void onLoadFinished(Loader loader, String data) { // ... // update UI here // } public void onLoaderReset(Loader loader) { // ... } public void useLoader() { Bundle args = new Bundle(); // ... // fill in args // ... Loader loader = context.getLoaderManager().initLoader(0, args, this); // with support library: // Loader loader = // context2.getSupportLoaderManager().initLoader(0, args, this); // call forceLoad() to start processing loader.forceLoad(); } } 

    Je préfère utiliser Bolts-Android. c'est très facile.

    https://github.com/BoltsFramework/Bolts-Android

     Task.callInBackground(new Callable<Void>() { public Void call() { // Do a bunch of stuff. } }).continueWith(...); 
    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.