Come impedire che l'attività venga caricata due volte premendo il pulsante

Sto cercando di impedire il caricamento dell'attività due volte se premo il pulsante due volte immediatamente dopo il primo clic.

Ho un'attività che si carica al clic di un pulsante, ad esempio

 myButton.setOnClickListener(new View.OnClickListener() {
      public void onClick(View view) {
       //Load another activity
    }
});

Ora, poiché l'attività da caricare ha chiamate di rete, il caricamento richiede un po 'di tempo (MVC). Mostra una visualizzazione di caricamento per questo, ma se premo il pulsante due volte prima, posso vedere l'attività caricata due volte.

Qualcuno sa come impedirlo?

Nel listener di eventi del pulsante, disabilita il pulsante e mostra un'altra attività.

    Button b = (Button) view;
    b.setEnabled(false);

    Intent i = new Intent(this, AnotherActitivty.class);
    startActivity(i);

Sostituisci onResume()per riattivare il pulsante.

@Override
    protected void onResume() {
        super.onResume();

        Button button1 = (Button) findViewById(R.id.button1);
        button1.setEnabled(true);
    }

Aggiungi questo alla tua Activitydefinizione in AndroidManifest.xml...

android:launchMode = "singleTop"

Per esempio:

<activity
            android:name=".MainActivity"
            android:theme="@style/AppTheme.NoActionBar"
            android:launchMode = "singleTop"/>

Puoi usare i flag di intenti in questo modo.

Intent intent = new Intent(Class.class);    
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
activity.startActivity(intent);

Verrà aperta una sola attività in cima allo stack della cronologia.

Poiché SO non mi consente di commentare altre risposte, devo inquinare questo thread con una nuova risposta.

Risposte comuni per il problema "l'attività si apre due volte" e le mie esperienze con queste soluzioni (Android 7.1.1):

1. Pulsante Disabilita che avvia l'attività: funziona ma sembra un po 'goffo. Se hai diversi modi per avviare l'attività nella tua app (ad esempio un pulsante nella barra delle azioni E facendo clic su un elemento in una visualizzazione elenco), devi tenere traccia dello stato abilitato / disabilitato di più elementi della GUI. Inoltre, non è molto comodo disabilitare gli elementi su cui si è fatto clic in una visualizzazione elenco, ad esempio. Quindi, non un approccio molto universale.
2. launchMode = "singleInstance": non funziona con startActivityForResult (), interrompe la navigazione con startActivity (), non consigliato per le normali applicazioni dalla documentazione di Android manifest.
3. launchMode = "singleTask": Non funziona con startActivityForResult (), non consigliato per le normali applicazioni dalla documentazione di Android manifest.
4. FLAG_ACTIVITY_REORDER_TO_FRONT: pulsante Indietro.
5. FLAG_ACTIVITY_SINGLE_TOP: non funziona, l'attività è ancora aperta due volte.
6. FLAG_ACTIVITY_CLEAR_TOP: Questo è l'unico che funziona per me.

EDIT: questo era per iniziare le attività con startActivity (). Quando si utilizza startActivityForResult (), è necessario impostare sia FLAG_ACTIVITY_SINGLE_TOP che FLAG_ACTIVITY_CLEAR_TOP.

Funzionava solo per me quando startActivity(intent)

intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);

Usa singleInstance per evitare attività da invocare due volte.

<activity
            android:name=".MainActivity"
            android:label="@string/activity"
            android:launchMode = "singleInstance" />

Diciamo che @wannik ha ragione, ma se abbiamo più di 1 pulsante che chiama lo stesso ascoltatore di azioni e faccio clic su due pulsanti una volta quasi alla stessa volta prima di iniziare l'attività successiva ...

Quindi è bene se hai campo private boolean mIsClicked = false;e nell'ascoltatore:

if(!mIsClicked)
{
    mIsClicked = true;
    Intent i = new Intent(this, AnotherActitivty.class);
    startActivity(i);
}

E onResume()dobbiamo restituire lo stato:

@Override
protected void onResume() {
    super.onResume();

    mIsClicked = false;
}

Qual è la differenza tra la mia risposta e quella di @ wannik?

Se si imposta abilitato su falso nel listener della sua chiamata, verrà comunque abilitato un altro pulsante che utilizza lo stesso listener. Quindi, per essere sicuri che l'azione dell'ascoltatore non venga chiamata due volte, devi avere qualcosa di globale che disabiliti tutte le chiamate dell'ascoltatore (non importa se è una nuova istanza o no)

Qual è la differenza tra la mia risposta e le altre?

Stanno pensando nel modo giusto ma non stanno pensando a un futuro ritorno allo stesso esempio dell'attività chiamante :)

Per questa situazione, sceglierò uno dei due avvicinati, singleTaskin manifest.xml OPPURE un flag in Activity onResume()&onDestroy() rispettivamente nei metodi .

Per la prima soluzione: preferisco utilizzare singleTaskper l'attività nel manifest piuttosto che singleInstance, come da utilizzo, singleInstanceho capito che in alcune occasioni l'attività crea una nuova istanza separata per se stessa che risulta avere una finestra di due applicazioni separate nelle app in esecuzione in bcakground e oltre ad allocazioni di memoria extra che risulterebbero una pessima esperienza utente quando l'utente apre la vista app per scegliere alcune app da riprendere. Quindi, il modo migliore è definire l'attività nel manifest.xml come segue:

<activity
    android:name=".MainActivity"
    android:launchMode="singleTask"</activity>

puoi controllare le modalità di avvio delle attività qui .

Per la seconda soluzione, devi solo definire una variabile statica o una variabile di preferenza, ad esempio:

public class MainActivity extends Activity{
    public static boolean isRunning = false;

    @Override
    public void onResume() {
        super.onResume();
        // now the activity is running
        isRunning = true;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // now the activity will be available again
        isRunning = false;
    }

}

e dall'altro lato quando vuoi avviare questa attività, controlla:

private void launchMainActivity(){
    if(MainActivity.isRunning)
        return;
    Intent intent = new Intent(ThisActivity.this, MainActivity.class);
    startActivity(intent);
}

Penso che tu stia risolvendo il problema nel modo sbagliato. In generale si tratta di una cattiva idea per un'attività per essere fare richieste web a lungo in esecuzione in uno qualsiasi dei suoi metodi di avvio del ciclo di vita ( onCreate(), onResume(), ecc). In realtà questi metodi dovrebbero essere usati semplicemente per istanziare e inizializzare gli oggetti che la tua attività userà e dovrebbero quindi essere relativamente veloci.

Se devi eseguire una richiesta web, fallo in un thread in background dalla tua attività appena avviata (e mostra la finestra di dialogo di caricamento nella nuova attività). Una volta completato il thread di richiesta in background, è possibile aggiornare l'attività e nascondere la finestra di dialogo.

Ciò significa che la tua nuova attività dovrebbe essere avviata immediatamente e impedire che il doppio clic sia possibile.

Spero che questo ti aiuti:

 protected static final int DELAY_TIME = 100;

// to prevent double click issue, disable button after click and enable it after 100ms
protected Handler mClickHandler = new Handler() {

    public void handleMessage(Message msg) {

        findViewById(msg.what).setClickable(true);
        super.handleMessage(msg);
    }
};

@Override
public void onClick(View v) {
    int id = v.getId();
    v.setClickable(false);
    mClickHandler.sendEmptyMessageDelayed(id, DELAY_TIME);
    // startActivity()
}`

Un'altra soluzione molto molto semplice se non vuoi usare onActivityResult()è disabilitare il pulsante per 2 secondi (o per il tempo che vuoi), non è l'ideale, ma può risolvere in parte il problema in alcuni casi e il codice è semplice:

   final Button btn = ...
   btn.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            //start activity here...
            btn.setEnabled(false);   //disable button

            //post a message to run in UI Thread after a delay in milliseconds
            btn.postDelayed(new Runnable() {
                public void run() {
                    btn.setEnabled(true);    //enable button again
                }
            },1000);    //1 second in this case...
        }
    });

// variabile per tenere traccia del tempo dell'evento

private long mLastClickTime = 0;

2.In onClick controlla che se l'ora corrente e la differenza di orario dell'ultimo clic sono inferiori a 1 secondo, non fare nulla (ritorno) altrimenti vai per l'evento clic

 @Override
public void onClick(View v) {
    // Preventing multiple clicks, using threshold of 1 second
    if (SystemClock.elapsedRealtime() - mLastClickTime < 1000) {
        return;
          }
    mLastClickTime = SystemClock.elapsedRealtime();
            // Handle button clicks
            if (v == R.id.imageView2) {
        // Do ur stuff.
         }
            else if (v == R.id.imageView2) {
        // Do ur stuff.
         }
      }
 }

Mantieni solo una bandiera nel pulsante sul metodo Fare clic come:

public boolean oneTimeLoadActivity = false;

    myButton.setOnClickListener(new View.OnClickListener() {
          public void onClick(View view) {
               if(!oneTimeLoadActivity){
                    //start your new activity.
                   oneTimeLoadActivity = true;
                    }
        }
    });

Se stai usando onActivityResult, puoi usare una variabile per salvare lo stato.

private Boolean activityOpenInProgress = false;

myButton.setOnClickListener(new View.OnClickListener() {
  public void onClick(View view) {
    if( activityOpenInProgress )
      return;

    activityOpenInProgress = true;
   //Load another activity with startActivityForResult with required request code
  }
});

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  if( requestCode == thatYouSentToOpenActivity ){
    activityOpenInProgress = false;
  }
}

Funziona anche con il pulsante Indietro premuto perché il codice di richiesta viene restituito all'evento.

aggiungere la modalità di avvio come singola attività nel manifest per evitare che l'attività si apra due volte al clic

<activity
        android:name=".MainActivity"
        android:label="@string/activity"
        android:launchMode = "singleTask" />

myButton.setOnClickListener(new View.OnClickListener() {
      public void onClick(View view) {
      myButton.setOnClickListener(null);
    }
});

Usa una flagvariabile per impostarlo to true, controlla se è vero, returnaltrimenti esegui la chiamata di attività.

Puoi anche usare setClickable (false) per eseguire la chiamata di attività

flg=false
 public void onClick(View view) { 
       if(flg==true)
         return;
       else
       { flg=true;
        // perform click}
    } 

Potresti semplicemente sovrascrivere startActivityForResult e utilizzare la variabile di istanza:

boolean couldStartActivity = false;

@Override
protected void onResume() {
    super.onResume();

    couldStartActivity = true;
}

@Override
public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
    if (couldStartActivity) {
        couldStartActivity = false;
        intent.putExtra(RequestCodeKey, requestCode);
        super.startActivityForResult(intent, requestCode, options);
    }
}

Puoi provare anche questo

Button game = (Button) findViewById(R.id.games);
        game.setOnClickListener(new View.OnClickListener() 
        {
            public void onClick(View view) 
            {
                Intent myIntent = new Intent(view.getContext(), Games.class);
                startActivityForResult(myIntent, 0);
            }

        });