Como reiniciar a atividade no Android

Como reinicio um Android Activity? Eu tentei o seguinte, mas o Activitysimplesmente sai.

public static void restartActivity(Activity act){

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

}

Eu fiz o meu alternador de temas assim:

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

Basicamente, estou ligando finish()primeiro e usando exatamente a mesma intenção com a qual essa atividade foi iniciada. Isso parece fazer o truque?

ATUALIZAÇÃO: Conforme apontado por Ralf abaixo, Activity.recreate()é o caminho a seguir na API 11 e além. Isso é preferível se você estiver em um ambiente API11 +. Você ainda pode verificar a versão atual e chamar o snippet de código acima, se estiver na API 10 ou abaixo. (Por favor, não esqueça de votar de novo na resposta de Ralf!)

Desde o nível 11 da API (Honeycomb), você pode chamar o método recreate () da atividade (graças a esta resposta).

O método recrte () atua como uma alteração na configuração, portanto, os métodos onSaveInstanceState () e onRestoreInstanceState () também são chamados, se aplicável.

Antes do SDK 11, uma maneira de fazer isso é:

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

Apenas para combinar as respostas de Ralf e Ben (incluindo as alterações feitas nos comentários):

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

Eu usei esse código para poder suportar versões mais antigas do Android e usar recreate() -las em versões mais recentes do Android.

Código:

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

Amostra:

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 solução funcionou para mim.

Primeiro termine a atividade e depois inicie-a novamente.

Código de amostra:

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

Essa é de longe a maneira mais fácil de reiniciar a atividade atual:

finish();
startActivity(getIntent());

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

Obrigado,

Mesmo que isso tenha sido respondido várias vezes.

Se reiniciar uma atividade de um fragmento, eu faria assim:

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

Então você pode estar pensando que isso é um pouco exagerado? Mas a Handlerpostagem permite que você chame isso em um método de ciclo de vida. Eu usei isso em onRestart/onResume methods ao verificar se o estado mudou entre o usuário que volta ao aplicativo. (instalei algo).

Sem o Handler se você o chamar em um local estranho, ele simplesmente matará a atividade e não a reiniciará.

Sinta-se a vontade para fazer qualquer pergunta.

Cheers, Chris

Bem, isso não está listado, mas uma combinação de alguns que já foram publicados:

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

Em conjunto com o estranho comportamento do ciclo de vida do SurfaceView com a câmera . Descobri que recreate () não se comporta bem com o ciclo de vida do SurfaceViews. surfaceDestroyed nunca é chamado durante o ciclo de recreação. É chamado após onResume (estranho), momento em que meu SurfaceView é destruído.

A maneira original de recriar uma atividade funciona bem.

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

Não consigo descobrir exatamente por que isso ocorre, mas é apenas uma observação que, esperançosamente, pode guiar outras pessoas no futuro, porque corrigiu meus problemas que eu estava tendo com o SurfaceViews

Eu me pergunto por que ninguém mencionou Intent.makeRestartActivityTask()que faz exatamente esse propósito exato.

Crie um Intent que possa ser usado para reiniciar a tarefa de um aplicativo * em seu estado base.

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

Este método define Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASKcomo sinalizadores padrão.

Na verdade, o código a seguir é válido para os níveis 5 e superior da API; portanto, se sua API de destino for menor que isso, você terá algo muito semelhante ao código do EboMike.

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

Existe uma maneira hacky que deve funcionar em qualquer atividade, incluindo a principal.

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

Quando a orientação muda, o Android geralmente recria sua atividade (a menos que você a substitua). Este método é útil para rotações de 180 graus, quando o Android não recriar sua atividade.

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

tente usar isso ..

A solução para sua pergunta é:

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

Você precisa converter no contexto da atividade para iniciar uma nova atividade e também para concluir a atividade atual.

Espero que seja útil .. e funcione para mim.

Se você remover a última linha, criará uma nova actatividade, mas sua instância antiga ainda estará ativa.

Você precisa reiniciar a atividade como quando a orientação é alterada (ou seja, seu estado é salvo e passado para onCreate(Bundle))?

Caso contrário, uma solução alternativa possível seria usar uma atividade fictícia extra, que seria iniciada a partir da primeira atividade e qual tarefa iniciaria uma nova instância dela. Ou apenas adie a chamada paraact.finish() depois que a nova for iniciada.

Se você precisa salvar a maior parte do estado, está entrando em águas muito profundas, porque não é trivial passar todas as propriedades do seu estado, especialmente sem vazar seu antigo Contexto / Atividade, passando-o para a nova instância.

Por favor, especifique o que você está tentando fazer.

É assim que eu faço.

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

Se você estiver chamando de algum fragmento, faça o código abaixo.

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

você pode simplesmente usar

onRestart ()

método da seguinte maneira

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

e ligue para onRestart () onde deseja reiniciar a atividade atual

Chame o método onCreate. Por exemploonCreate(null);