Impedire l'esecuzione asynctask più volte

Question

Sto chiamando un asynctask dal mio thread dell'interfaccia utente al clic di un pulsante, che esegue alcune richieste HTTP-Get.

Cosa accadrebbe se un utente fa nuovamente clic sul pulsante prima che l'attività corrente sia completata? È gestito internamente da asynctask o devo occuparmene personalmente?

Answer 1

Ci sono due modi per farlo.

1: Mostra una finestra di dialogo di avanzamento e blocca l'utente per ulteriori input.

2: Crea la variabile AsyncTask in ambito privato. Quindi questo non funzionerà mai più di una volta.

Answer 2

è possibile chiamare getStatus() sul proprio AsyncTask per verificare se è già in esecuzione e ignorare il clic del pulsante in tal caso.

per farlo è assolutamente necessario salvare un'istanza di AsyncTask da qualche parte e avere accesso ad esso.

Answer 3

Viene generato un altro AsyncTask che probabilmente causerà delle difficoltà - condizioni di gara con i dati salvati se lo si sta persistendo ecc. Raccomanderei di disabilitare il pulsante quando si riceve l'evento onClick e di visualizzare uno spinner di qualche descrizione che indica che qualcosa sta accadendo in background.

Abbiamo raggiunto qualcosa di simile con un pulsante di aggiornamento collocato in una barra delle azioni. Si noti che la nostra attività asincrona viene eseguita sotto un app.Service quindi durante una modifica della configurazione (dove hasStartedSync viene riavviata) ci affidiamo a un controllo "isTheSyncServiceRunning".

// on setting the selection buttons up 
public void onPrepareOptionsMenu(final Menu menu) { 
super.onPrepareOptionsMenu(menu); 
final MenuItem refreshItem = menu.findItem(id.sync); 
    if (isSynchronisationServiceRunning() || hasStartedSync) { 
    refreshItem.setEnabled(false); 
    if (Build.VERSION.SDK_INT > 10) { 
    // Replace the refresh icon with an indeterminate spinner for > 10 API. 
    final LayoutInflater inflater = (LayoutInflater)getSherlockActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
    refreshItem.setActionView(inflater.inflate(layout.actionbar_indeterminate_progress, null)); 
    } 
} else { 
    refreshItem.setEnabled(true); 
    refreshItem.setActionView(null); 
} 
} 


// on selection. 
public boolean onOptionsItemSelected(final MenuItem item) { 
boolean isSelected; 
switch (item.getItemId()) { 
    case id.sync: 
    // Fire request to start GET here. 
    hasStartedSync = true; 
    invalidateOptionsMenu(); 
    break; 
    ... 

Answer 4

due modi:

1. In onPreExeccute() di AsyncTask mostrano un ProgressDialog con il suo setCancelable(false). In onPostExecute() di AsyncTask chiama dismiss() su ProgressDialog. Questo mostrerà una finestra di dialogo di avanzamento del blocco. Puoi anche mostrare qualche messaggio o progresso qui.

2. In onPreExeccute() di AsyncTask, chiamare setEnabled(false) sul pulsante. In onPostExecute() di AsyncTask chiama setEnabled(true) su Button. Questo disabiliterà il pulsante finché l'attività è in esecuzione. Puoi anche cambiare il testo del pulsante in questi punti. O anche temporaneamente sostituirlo con uno spinner di progresso (come in ActionBar).

Inoltre, è possibile attivare o disattivare il pulsante tra "Esegui" e "Annulla", come il pulsante di aggiornamento nei browser Web moderni. Ciò darà più controllo all'utente.

Una nota di cautela: Avvolgere tutto all'interno onDoInBackground() in un try-catch, in modo che AsyncTask esce sempre normalmente, e onPostExecute() viene sempre chiamato. Puoi giudicare dal parametro risultato di onPostExecute(result) se la richiesta HTTP ha ottenuto qualcosa o no.

Esempio: basta chiamare questo metodo per caricare un po 'di testo in un TextView dal server al clic di alcuni Button:

public static void runHTTP(final TextView targetView, final Button triggerBtn){ 

    //---new task---- 
    AsyncTask<Void,Void,String> task = new AsyncTask<Void, Void, String>(){ 
     @Override 
     protected void onPreExecute() { 
      super.onPreExecute(); 

      //----disable button--- 
      triggerBtn.setEnabled(false); 

      //---show message---- 
      targetView.setText("Loading..."); 
     } 

     @Override 
     protected void onPostExecute(String result) { 
      super.onPostExecute(result); 

      //----update result--- 
      targetView.setText(result); 

      //----re-enable button--- 
      triggerBtn.setEnabled(true); 
     } 

     @Override 
     protected String doInBackground(Void... voids) { 

      //---default value-- 
      String result = "No Data"; 

      //--for safety-- 
      try{ 

      //-----do time consuming stuff here --- 

      }catch (Exception e){ 

       //---error value-- 
       result = "Error fetching data"; 
      } 

      return result; 
     } 
    }; 

    //----run task---- 
    task.execute(); 
} 

Answer 5

Perché non utilizzare un flag booleano e verificare che sia stato? Uso questa logica nelle mie liste senza fine e non ha mai mancato di funzionare.

Toggle la bandiera nella doInBackground()

@Override 
protected Void doInBackground(Void... params) { 

    loadingData = true; 
} 

E poi di nuovo nel onPostExecute()

@Override 
protected void onPostExecute(Void result) { 

    // CHANGE THE LOADINGMORE STATUS TO PERMIT FETCHING MORE DATA 
    loadingData = false; 
} 

E per click ascoltatore del pulsante

your_btn.setOnClickListener(new OnClickListener() { 

    @Override 
    public void onClick(View v) { 

     if (loadingData == false) { 
      // RUN THE ASYNCTASK AGAIN 
     } else if (loadingData == true) { 
      // SHOW A TOAST THAT YOU ARE ALREADY FETCHING DATA 
     } 
    } 
});