Aggiorna barra di avanzamento da AsyncTaskLoader?

Question

Quando si utilizza AsyncTaskLoader, come si aggiorna una barra di avanzamento che mostra lo stato di aggiornamento? Normalmente si aspetta che il callback venga rimosso una volta terminato, ma come eseguire gli aggiornamenti in esecuzione? Vuoi lasciare che il thread principale (ui) esegua il polling dei dati mentre viene impostato o qualcosa del genere?

Modifica: Sto parlando di AsyncTaskLoader, guarda la parte del caricatore. Ecco il link alla classe: http://developer.android.com/reference/android/content/AsyncTaskLoader.html

Voglio usarlo perché è il futuro :), so come farlo con AsyncTask.

Answer 1

Si può fare con caricatori, ma è necessario tenere ed aggiornare un WeakReference sulla vostra attività:

public class LoaderTestActivity extends FragmentActivity implements LoaderCallbacks<Void> { 
    private static final int MAX_COUNT = 100; 

    private ProgressBar progressBar; 

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

     progressBar = (ProgressBar) findViewById(R.id.progressBar1); 
     progressBar.setMax(MAX_COUNT); 
     AsyncTaskCounter.mActivity = new WeakReference<LoaderTestActivity>(this); 
    } 

    @Override 
    public boolean onCreateOptionsMenu(Menu menu) { 
     getMenuInflater().inflate(R.menu.activity_async_task_test, menu); 
     return true; 
    } 

    public void onStartButtonClick(View v) { 
     startWork(); 
    } 

    void startWork() { 
     getSupportLoaderManager().initLoader(0, (Bundle) null, this); 
    } 

    static class AsyncTaskCounter extends AsyncTaskLoader<Void> { 
     static WeakReference<LoaderTestActivity> mActivity; 

     AsyncTaskCounter(LoaderTestActivity activity) { 
      super(activity); 
      mActivity = new WeakReference<LoaderTestActivity>(activity); 
     } 

     private static final int SLEEP_TIME = 200; 

     @Override 
     public Void loadInBackground() { 
      for (int i = 0; i < MAX_COUNT; i++) { 
       try { 
        Thread.sleep(SLEEP_TIME); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
       Log.d(getClass().getSimpleName(), "Progress value is " + i); 
       Log.d(getClass().getSimpleName(), "getActivity is " + getContext()); 
       Log.d(getClass().getSimpleName(), "this is " + this); 

       final int progress = i; 
       if (mActivity.get() != null) { 
        mActivity.get().runOnUiThread(new Runnable() { 

         @Override 
         public void run() { 
          mActivity.get().progressBar.setProgress(progress); 
         } 
        }); 
       } 
      } 
      return null; 
     } 

    } 

    @Override 
    public Loader<Void> onCreateLoader(int id, Bundle args) { 
     AsyncTaskLoader<Void> asyncTaskLoader = new AsyncTaskCounter(this); 
     asyncTaskLoader.forceLoad(); 
     return asyncTaskLoader; 
    } 

    @Override 
    public void onLoadFinished(Loader<Void> arg0, Void arg1) { 

    } 

    @Override 
    public void onLoaderReset(Loader<Void> arg0) { 

    } 

} 

Answer 2

Trasmetto un Intento all'attività (ed è ricevuto da un BroadcastReceiver). Non sono molto contento di questa soluzione, ma funziona. AsynTask publishProgress è davvero più facile da usare. Hai trovato qualche altra soluzione?

Answer 3

È possibile utilizzare handler, penso che sarà più leggero per il sistema di intenti

public class MyFragmentActivity extends FragmentActivity{ 
private final static int MSGCODE_PROGRESS = 1; 
private final static int MSGCODE_SIZE = 2; 

    private final Handler mHandler = new Handler() { 
    public void handleMessage(Message msg) { 
     Bundle bundle = msg.getData(); 
     if(null != bundle){ 
      int data = msg.getData().getInt(BUNDLE_PROGRESS); 
      if(msg.what == MSGCODE_SIZE){ 
       mProgressBar.setMax(data); 
      } else if(msg.what == MSGCODE_PROGRESS){ 
       mProgressBar.setProgress(data); 
      } 
     } 
    } 
}; 
} 

Set mHandler al costruttore di AsyncTaskLoader e da loadInBackground è possibile aggiornare il progresso

Bundle bundle = new Bundle(); 
bundle.putInt(BUNDLE_PROGRESS, lenghtOfFile); 
Message msg = new Message(); 
msg.setData(bundle); 
msg.what = MSGCODE_SIZE; 
mHandler.sendMessage(msg); 

Answer 4

sto usando questo con il mio AsyncTaskLoader, all'interno di loadInBackground

runOnUiThread(new Runnable() { 
    public void run() { 
     //UI code 
    } 
}); 

Tuttavia, questo non funziona con una modifica alla configurazione (come la modifica dell'orientamento). Non sono convinto che il AsyncTaskLoader sia il migliore da utilizzare se è necessario aggiornare l'interfaccia utente, ma funziona meglio quando si gestiscono le modifiche alla configurazione. Non so perché hanno creato sia uno AsyncTaskLoader sia uno AsyncTask ciascuno con i propri compromessi. Frustra e confonde gli sviluppatori. Inoltre, lo AsyncTaskLoader ha pochissima documentazione.

Answer 5

Andando fuori @ di garmax risposta, ho trovato un sito che ha mostrato come combinare AsyncTaskLoader s con Fragments on: http://habrahabr.ru/post/131560/

E 'in russo, ma potrei postare la mia implementazione di un secondo momento.

EDIT: Ecco un link al ZIP contenente che l'attuazione: http://www.2shared.com/file/VW68yhZ1/SampleTaskProgressDialogFragme.html

Answer 6

Ho appena avuto questo problema. Ho usato un AtomicInteger statico nella mia attività per memorizzare i progressi. Il caricatore lo aggiorna tramite una richiamata e l'attività esegue il polling e visualizza i progressi.

Nel callback del caricatore onLoadFinished Nascondo il pannello di avanzamento, che provoca l'uscita del ciclo di polling.

Normalmente eviterei lo stato statico, ma nel complesso questo è più semplice delle alternative. Nel mio caso, ho un layout diverso in orizzontale, quindi sono più felice di lasciare che i cambi di orientamento si comportino normalmente.

private Handler progressHandler; // init with new Handler(getMainLooper()) 
private static AtomicInteger progress = new AtomicInteger(0); 

... 

private void beginProgressUiUpdates() { 
    progress.set(0); 
    displayProgress(); 
    progressHandler.postDelayed(pollProgress, PROGRESS_POLL_PERIOD_MILLIS); 
} 

private Runnable pollProgress = new Runnable() { 
    public void run() { 
     if (findViewById(R.id.progressPanel).getVisibility() == View.VISIBLE) { 
      displayProgress(); 
      progressHandler.postDelayed(pollProgress, PROGRESS_POLL_PERIOD_MILLIS); 
     } 
    } 
}; 

private void displayProgress() { 
    ((ProgressBar)findViewById(R.id.progressBar)).setProgress(progress.get()); 
}