Cómo reiniciar Activity en Android

¿Cómo reinicio un Android Activity? Intenté lo siguiente, pero Activitysimplemente se fue.

public static void restartActivity(Activity act){

        Intent intent=new Intent();
        intent.setClass(act, act.getClass());
        act.startActivity(intent);
        act.finish();

}

Hice mi selector de tema así:

Intent intent = getIntent();
finish();
startActivity(intent);

Básicamente, llamo finish()primero, y estoy usando exactamente la misma intención con la que se inició esta actividad. Eso parece hacer el truco?

ACTUALIZACIÓN: Como señala Ralf a continuación, Activity.recreate()es el camino a seguir en API 11 y más allá. Esto es preferible si está en un entorno API11 +. Todavía puede verificar la versión actual y llamar al fragmento de código anterior si está en API 10 o inferior. (¡No olvides votar la respuesta de Ralf!)

Desde el nivel de API 11 (Honeycomb), puede llamar al método recreate () de la actividad (gracias a esta respuesta).

El método recreate () actúa como un cambio de configuración, por lo que también se llama a los métodos onSaveInstanceState () y onRestoreInstanceState (), si corresponde.

Antes del SDK 11, una forma de hacerlo es así:

public void reload() {
    Intent intent = getIntent();
    overridePendingTransition(0, 0);
    intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
    finish();
    overridePendingTransition(0, 0);
    startActivity(intent);
}

Solo para combinar las respuestas de Ralf y Ben (incluidos los cambios realizados en los comentarios):

if (Build.VERSION.SDK_INT >= 11) {
    recreate();
} else {
    Intent intent = getIntent();
    intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
    finish();
    overridePendingTransition(0, 0);

    startActivity(intent);
    overridePendingTransition(0, 0);
}

Utilicé este código para poder admitir versiones anteriores de Android y usar recreate()en versiones más nuevas de Android.

Código:

public static void restartActivity(Activity activity){
    if (Build.VERSION.SDK_INT >= 11) {
        activity.recreate();
    } else {
        activity.finish();
        activity.startActivity(activity.getIntent());
    }
}

Muestra:

import android.app.Activity;
import android.os.Build;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {
    private Activity mActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mActivity = MainActivity.this;

        Button button = (Button) findViewById(R.id.restart_button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                restartActivity(mActivity);
            }
        });
    }

    public static void restartActivity(Activity activity) {
        if (Build.VERSION.SDK_INT >= 11) {
            activity.recreate();
        } else {
            activity.finish();
            activity.startActivity(activity.getIntent());
        }
    }
}

Esta solución funcionó para mí.

Primero termina la actividad y luego comienza de nuevo.

Código de muestra:

public void restartActivity(){
    Intent mIntent = getIntent();
    finish();
    startActivity(mIntent);
}

Esta es, con mucho, la forma más fácil de reiniciar la actividad actual:

finish();
startActivity(getIntent());

Llamar a este método

private void restartFirstActivity()
 {
 Intent i = getApplicationContext().getPackageManager()
 .getLaunchIntentForPackage(getApplicationContext().getPackageName() );

 i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK );
 startActivity(i);
 }

Gracias,

Aunque esto ha sido respondido varias veces.

Si reinicia una actividad desde un fragmento, lo haría así:

new Handler().post(new Runnable() {

         @Override
         public void run()
         {
            Intent intent = getActivity().getIntent();
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION);
            getActivity().overridePendingTransition(0, 0);
            getActivity().finish();

            getActivity().overridePendingTransition(0, 0);
            startActivity(intent);
        }
    });

Entonces, ¿podrías estar pensando que esto es un poco exagerado? Pero la Handlerpublicación le permite llamar a esto en un método de ciclo de vida. He usado esto en onRestart/ onResumemétodos al verificar si el estado ha cambiado entre el usuario que regresa a la aplicación. (instalado algo).

Sin el Handlersi lo llamas en un lugar extraño, simplemente matará la actividad y no la reiniciará.

No dude en hacer cualquier pregunta.

Saludos, Chris

Bueno, esto no está en la lista, pero una combinación de algunos que ya está publicado:

if (Build.VERSION.SDK_INT >= 11) {
    recreate();   
} else {
    Intent intent = getIntent();
    finish();
    startActivity(intent);
}

En combinación con el extraño comportamiento del ciclo de vida de SurfaceView con la cámara . He descubierto que recrear () no se comporta bien con el ciclo de vida de SurfaceViews. SurfaceDestroyed nunca se llama durante el ciclo de recreación. Se llama después de onResume (extraño), en cuyo punto se destruye mi SurfaceView.

La forma original de recrear una actividad funciona bien.

Intent intent = getIntent();
finish();
startActivity(intent);

No puedo entender exactamente por qué es esto, pero es solo una observación que espero pueda guiar a otros en el futuro porque solucionó los problemas que tenía con SurfaceViews

Me pregunto por qué nadie mencionó lo Intent.makeRestartActivityTask()que hace este propósito exacto.

Haga una intención que pueda usarse para relanzar la tarea * de una aplicación en su estado base.

startActivity(Intent.makeRestartActivityTask(getActivity().getIntent().getComponent()));

Este método establece Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASKcomo banderas predeterminadas.

En realidad, el siguiente código es válido para los niveles de API 5 y superiores, por lo que si su API de destino es inferior a esto, terminará con algo muy similar al código de EboMike.

intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
overridePendingTransition(0, 0);

Hay una forma hacky que debería funcionar en cualquier actividad, incluida la principal.

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);

Cuando la orientación cambia, Android generalmente recreará su actividad (a menos que la anule). Este método es útil para rotaciones de 180 grados, cuando Android no recrea su actividad.

public void onRestart() {
    super.onRestart();
    Intent intent=new Intent();
    intent.setClass(act, act.getClass());
    finish();
    act.startActivity(intent);
}

intenta usar esto ...

La solución para su pregunta es:

public static void restartActivity(Activity act){
    Intent intent=new Intent();
    intent.setClass(act, act.getClass());
    ((Activity)act).startActivity(intent);
    ((Activity)act).finish();
}

Debe lanzar al contexto de actividad para comenzar una nueva actividad y también para finalizar la actividad actual.

Espero que esto sea útil ... y funciona para mí.

Si elimina la última línea, creará una nueva actActividad, pero su instancia anterior seguirá viva.

¿Necesita reiniciar la actividad como cuando se cambia la orientación (es decir, su estado se guarda y se pasa onCreate(Bundle))?

Si no lo hace, una posible solución sería usar una actividad ficticia adicional, que se iniciaría desde la primera actividad, y qué trabajo es iniciar una nueva instancia de la misma. O simplemente retrasar la llamada aact.finish() después de que se inicie la nueva.

Si necesita salvar la mayor parte del estado, está entrando en aguas bastante profundas, porque no es trivial pasar todas las propiedades de su estado, especialmente sin filtrar su Contexto / Actividad anterior, pasándolo a la nueva instancia.

Por favor, especifique qué está tratando de hacer.

Así es como lo hago.

        val i = Intent(context!!, MainActivity::class.java)
        i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
        startActivity(i)

Si está llamando desde algún fragmento, hágalo a continuación.

Intent intent = getActivity().getIntent();
getActivity().finish();
startActivity(intent);

simplemente puedes usar

onRestart ()

método de la siguiente manera

 @Override
    protected void onRestart() {
        super.onRestart();
        setContentView(R.layout.add_entry);
    }

y llame a onRestart () donde desea reiniciar la actividad actual

Llame al método onCreate. Por ejemploonCreate(null);