Cómo evitar que la actividad se cargue dos veces al presionar el botón

Estoy tratando de evitar que la actividad se cargue dos veces si presiono el botón dos veces instantáneamente después del primer clic.

Tengo una actividad que se carga al hacer clic en un botón, digamos

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

Ahora que la actividad que se va a cargar tiene llamadas de red, se tarda un poco en cargar (MVC). Muestro una vista de carga para esto, pero si presiono el botón dos veces antes de eso, puedo ver que la actividad se carga dos veces.

¿Alguien sabe cómo prevenir esto?

En el detector de eventos del botón, desactive el botón y muestre otra actividad.

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

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

Anular onResume()para volver a habilitar el botón.

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

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

Agregue esto a su Activitydefinición en AndroidManifest.xml...

android:launchMode = "singleTop"

Por ejemplo:

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

Puede usar los indicadores de intención de esta manera.

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

Hará que solo una actividad esté abierta en la parte superior de la pila del historial.

Como SO no me permite comentar sobre otras respuestas, tengo que contaminar este hilo con una nueva respuesta.

Respuestas comunes para el problema "la actividad se abre dos veces" y mis experiencias con estas soluciones (Android 7.1.1):

1. Desactivar el botón que inicia la actividad: funciona pero se siente un poco torpe. Si tiene varias formas de iniciar la actividad en su aplicación (por ejemplo, un botón en la barra de acción Y haciendo clic en un elemento en una vista de lista), debe realizar un seguimiento del estado habilitado / deshabilitado de múltiples elementos GUI. Además, no es muy conveniente desactivar los elementos en los que se hizo clic en una vista de lista, por ejemplo. Entonces, no es un enfoque muy universal.
2. launchMode = "singleInstance": no funciona con startActivityForResult (), interrumpe la navegación con startActivity (), no recomendado para aplicaciones regulares por la documentación del manifiesto de Android.
3. launchMode = "singleTask": no funciona con startActivityForResult (), no se recomienda para aplicaciones normales en la documentación del manifiesto de Android.
4. FLAG_ACTIVITY_REORDER_TO_FRONT: Botón para retroceder.
5. FLAG_ACTIVITY_SINGLE_TOP: No funciona, la actividad todavía se abre dos veces.
6. FLAG_ACTIVITY_CLEAR_TOP: Este es el único que funciona para mí.

EDITAR: Esto fue para iniciar actividades con startActivity (). Cuando uso startActivityForResult (), necesito configurar FLAG_ACTIVITY_SINGLE_TOP y FLAG_ACTIVITY_CLEAR_TOP.

Solo funcionaba para mí cuando startActivity(intent)

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

Use singleInstance para evitar que la actividad se invoque dos veces.

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

Digamos que @wannik tiene razón, pero si tenemos más de 1 botón llamando al mismo oyente de acción y hago clic en dos botones una vez casi al mismo tiempo antes de comenzar la siguiente actividad ...

Entonces es bueno si tiene un campo private boolean mIsClicked = false;y en el oyente:

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

Y onResume()necesitamos devolver el estado:

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

    mIsClicked = false;
}

¿Cuál es la diferencia entre mi respuesta y la de @ wannik?

Si establece habilitado en falso en el oyente de su llamada, ver otro botón que usa el mismo oyente aún estará habilitado. Entonces, para asegurarse de que la acción del oyente no se llame dos veces, debe tener algo global que deshabilite todas las llamadas del oyente (no importa si es una nueva instancia o no)

¿Cuál es la diferencia entre mi respuesta y otras?

Están pensando de la manera correcta, pero no están pensando en regresar en el futuro a la misma instancia de la actividad de llamada :)

Para esta situación, elegiré uno de los dos abordados, singleTasken manifest.xml O una bandera en los métodos onResume()& de la Actividad onDestroy()respectivamente.

Para la primera solución: prefiero usar singleTaskpara la actividad en el manifiesto en lugar de singleInstance, según el uso singleInstance, descubrí que en algunas ocasiones la actividad crea una nueva instancia separada para sí misma, lo que da como resultado una ventana de dos aplicaciones separadas en las aplicaciones en ejecución en bcakground y además de asignaciones de memoria extra que resultarían en una experiencia de usuario muy mala cuando el usuario abre la vista de aplicaciones para elegir alguna aplicación para reanudar. Entonces, la mejor manera es tener la actividad definida en el manifest.xml como se muestra a continuación:

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

puedes consultar los modos de inicio de actividad aquí .

Para la segunda solución, solo tiene que definir una variable estática o una variable de preferencia, por ejemplo:

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;
    }

}

y desde el otro lado, cuando desee iniciar esta actividad, simplemente marque:

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

Creo que estás resolviendo el problema de manera incorrecta. En general es una mala idea para una actividad que se va haciendo larga ejecución peticiones web en cualquiera de sus métodos de puesta en marcha del ciclo de vida ( onCreate(), onResume(), etc.). Realmente, estos métodos deberían usarse simplemente para crear instancias e inicializar objetos que su actividad usará y, por lo tanto, deberían ser relativamente rápidos.

Si necesita realizar una solicitud web, hágalo en un hilo de fondo de su actividad recién iniciada (y muestre el diálogo de carga en la nueva actividad). Una vez que se completa el hilo de solicitud en segundo plano, puede actualizar la actividad y ocultar el diálogo.

Esto significa que su nueva actividad debe iniciarse de inmediato y evitar que el doble clic sea posible.

Espero que esto ayude:

 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()
}`

Otra solución muy muy simple si no quieres usar onActivityResult()es deshabilitar el botón por 2 segundos (o el tiempo que quieras), no es lo ideal, pero puede solucionar en parte el problema en algunos casos y el código es simple:

   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...
        }
    });

// variable para rastrear el tiempo del evento

private long mLastClickTime = 0;

2.En onClick, compruebe que si la hora actual y la diferencia de tiempo del último clic son menos de un segundo, no haga nada (regresar), de lo contrario, vaya al evento de 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.
         }
      }
 }

Simplemente mantenga una bandera en el botón onClick método como:

public boolean oneTimeLoadActivity = false;

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

Si está usando onActivityResult, podría usar una variable para guardar el estado.

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;
  }
}

También funciona con el botón Atrás presionado porque el código de solicitud se devuelve en el evento.

agregue el modo de inicio como una sola tarea en el manifiesto para evitar que la actividad se abra dos veces al hacer 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);
    }
});

Use una flagvariable to true, configúrelo, verifique si es cierto, solo returnrealice una llamada de actividad.

También puede usar setClickable (false) one ejecutando la llamada de actividad

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

Puede simplemente anular startActivityForResult y usar la variable de instancia:

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);
    }
}

Puedes probar esto también

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);
            }

        });