android-fragments - Android.Fragmento getActivity()às vezes retorna nulo

Eu tenho lutado contra esse tipo de problema por um tempo, e acho que encontrei uma solução confiável.

É muito difícil saber com certeza que this.getActivity() não retornará null para um Fragment , especialmente se você estiver lidando com qualquer tipo de comportamento de rede que forneça a seu código tempo suficiente para retirar referências de Activity .

Na solução abaixo, eu declaro uma pequena classe de gerenciamento chamada ActivityBuffer . Essencialmente, esta class lida com a manutenção de uma referência confiável para uma Activity proprietária, e promete executar Runnable s dentro de um contexto de Activity válido sempre que houver uma referência válida disponível. Os Runnable s estão programados para execução no Thread de UI imediatamente se o Context estiver disponível, caso contrário, a execução é adiada até que o Context esteja pronto.

/** A class which maintains a list of transactions to occur when Context becomes available. */
public final class ActivityBuffer {

    /** A class which defines operations to execute once there's an available Context. */
    public interface IRunnable {
        /** Executes when there's an available Context. Ideally, will it operate immediately. */
        void run(final Activity pActivity);
    }

    /* Member Variables. */
    private       Activity        mActivity;
    private final List<IRunnable> mRunnables;

    /** Constructor. */
    public ActivityBuffer() {
        // Initialize Member Variables.
        this.mActivity  = null;
        this.mRunnables = new ArrayList<IRunnable>();
    }

    /** Executes the Runnable if there's an available Context. Otherwise, defers execution until it becomes available. */
    public final void safely(final IRunnable pRunnable) {
        // Synchronize along the current instance.
        synchronized(this) {
            // Do we have a context available?
            if(this.isContextAvailable()) {
                // Fetch the Activity.
                final Activity lActivity = this.getActivity();
                // Execute the Runnable along the Activity.
                lActivity.runOnUiThread(new Runnable() { @Override public final void run() { pRunnable.run(lActivity); } });
            }
            else {
                // Buffer the Runnable so that it's ready to receive a valid reference.
                this.getRunnables().add(pRunnable);
            }
        }
    }

    /** Called to inform the ActivityBuffer that there's an available Activity reference. */
    public final void onContextGained(final Activity pActivity) {
        // Synchronize along ourself.
        synchronized(this) {
            // Update the Activity reference.
            this.setActivity(pActivity);
            // Are there any Runnables awaiting execution?
            if(!this.getRunnables().isEmpty()) {
                // Iterate the Runnables.
                for(final IRunnable lRunnable : this.getRunnables()) {
                    // Execute the Runnable on the UI Thread.
                    pActivity.runOnUiThread(new Runnable() { @Override public final void run() {
                        // Execute the Runnable.
                        lRunnable.run(pActivity);
                    } });
                }
                // Empty the Runnables.
                this.getRunnables().clear();
            }
        }
    }

    /** Called to inform the ActivityBuffer that the Context has been lost. */
    public final void onContextLost() {
        // Synchronize along ourself.
        synchronized(this) {
            // Remove the Context reference.
            this.setActivity(null);
        }
    }

    /** Defines whether there's a safe Context available for the ActivityBuffer. */
    public final boolean isContextAvailable() {
        // Synchronize upon ourself.
        synchronized(this) {
            // Return the state of the Activity reference.
            return (this.getActivity() != null);
        }
    }

    /* Getters and Setters. */
    private final void setActivity(final Activity pActivity) {
        this.mActivity = pActivity;
    }

    private final Activity getActivity() {
        return this.mActivity;
    }

    private final List<IRunnable> getRunnables() {
        return this.mRunnables;
    }

}

Em termos de sua implementação, devemos ter o cuidado de aplicar os métodos do ciclo de vida para coincidir com o comportamento descrito acima por Pawan M :

public class BaseFragment extends Fragment {

    /* Member Variables. */
    private ActivityBuffer mActivityBuffer;

    public BaseFragment() {
        // Implement the Parent.
        super();
        // Allocate the ActivityBuffer.
        this.mActivityBuffer = new ActivityBuffer();
    }

    @Override
    public final void onAttach(final Context pContext) {
        // Handle as usual.
        super.onAttach(pContext);
        // Is the Context an Activity?
        if(pContext instanceof Activity) {
            // Cast Accordingly.
            final Activity lActivity = (Activity)pContext;
            // Inform the ActivityBuffer.
            this.getActivityBuffer().onContextGained(lActivity);
        }
    }

    @Deprecated @Override
    public final void onAttach(final Activity pActivity) {
        // Handle as usual.
        super.onAttach(pActivity);
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextGained(pActivity);
    }

    @Override
    public final void onDetach() {
        // Handle as usual.
        super.onDetach();
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextLost();
    }

    /* Getters. */
    public final ActivityBuffer getActivityBuffer() {
        return this.mActivityBuffer;
    }

}

Finalmente, em qualquer área dentro do seu Fragment que estenda o BaseFragment que você não é confiável sobre uma chamada para getActivity() , simplesmente faça uma chamada para this.getActivityBuffer().safely(...) e declare um ActivityBuffer.IRunnable para a tarefa. !

O conteúdo do seu void run(final Activity pActivity) é garantido para executar ao longo do thread de interface do usuário.

Eu sei que esta é uma pergunta antiga, mas eu acho que devo fornecer a minha resposta, porque o meu problema não foi resolvido por outros.

Primeiro de tudo: eu estava adicionando dinamicamente fragmentos usando fragmentTransactions. Segundo: meus fragmentos foram modificados usando o AsyncTasks (consultas do banco de dados em um servidor). Terceiro: meu fragmento não foi instanciado no início da atividade Quarto: usei uma instanciação de fragmento personalizada "crie ou carregue" para obter a variável de fragmento. Quarto: a atividade foi recriada por causa da mudança de orientação

O problema era que eu queria "remover" o fragmento por causa da resposta da consulta, mas o fragmento foi criado incorretamente antes. Eu não sei porque, provavelmente por causa do "commit" ser feito depois, o fragmento não foi adicionado ainda na hora de removê-lo. Portanto getActivity () estava retornando null.

Solução: 1) Eu tinha que verificar se estava tentando encontrar corretamente a primeira instância do fragmento antes de criar um novo. 2) Eu tive que colocar serRetainInstance (true) nesse fragmento para mantê-lo através da mudança de orientação (sem backstack necessário, portanto, não há problema) 3) Em vez de "recriar ou obter fragmento de idade" pouco antes de "removê-lo", eu coloquei diretamente o fragmento no início da atividade. Instanciando-o no início da atividade, em vez de "carregar" (ou instanciar) a variável de fragmento antes de removê-la, evitou problemas getActivity.

Parece que encontrei uma solução para o meu problema. Muito boas explicações são dadas here e here . Aqui está o meu exemplo:

pulic class MyActivity extends FragmentActivity{

private ViewPager pager; 
private TitlePageIndicator indicator;
private TabsAdapter adapter;
private Bundle savedInstanceState;

 @Override
public void onCreate(Bundle savedInstanceState) {

    .... 
    this.savedInstanceState = savedInstanceState;
    pager = (ViewPager) findViewById(R.id.pager);;
    indicator = (TitlePageIndicator) findViewById(R.id.indicator);
    adapter = new TabsAdapter(getSupportFragmentManager(), false);

    if (savedInstanceState == null){    
        adapter.addFragment(new FirstFragment());
        adapter.addFragment(new SecondFragment());
    }else{
        Integer  count  = savedInstanceState.getInt("tabsCount");
        String[] titles = savedInstanceState.getStringArray("titles");
        for (int i = 0; i < count; i++){
            adapter.addFragment(getFragment(i), titles[i]);
        }
    }


    indicator.notifyDataSetChanged();
    adapter.notifyDataSetChanged();

    // push first task
    FirstTask firstTask = new FirstTask(MyActivity.this);
    // set first fragment as listener
    firstTask.setTaskListener((TaskListener) getFragment(0));
    firstTask.execute();

}

private Fragment getFragment(int position){
     return savedInstanceState == null ? adapter.getItem(position) : getSupportFragmentManager().findFragmentByTag(getFragmentTag(position));
}

private String getFragmentTag(int position) {
    return "android:switcher:" + R.id.pager + ":" + position;
}

 @Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("tabsCount",      adapter.getCount());
    outState.putStringArray("titles", adapter.getTitles().toArray(new String[0]));
}

 indicator.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
        @Override
        public void onPageSelected(int position) {
            Fragment currentFragment = adapter.getItem(position);
            ((Taskable) currentFragment).executeTask();
        }

        @Override
        public void onPageScrolled(int i, float v, int i1) {}

        @Override
        public void onPageScrollStateChanged(int i) {}
 });

A idéia principal deste código é que, ao executar seu aplicativo normalmente, você crie novos fragmentos e passe-os para o adaptador. Quando você estiver retomando seu aplicativo, o gerenciador de fragmentos já possui a instância deste fragmento e você precisa obtê-lo do gerenciador de fragmento e passá-lo para o adaptador.

ATUALIZAR

Além disso, é uma boa prática ao usar fragmentos para verificar isAdded antes de getActivity () ser chamado. Isso ajuda a evitar uma exceção de ponteiro nulo quando o fragmento é desanexado da atividade. Por exemplo, uma atividade pode conter um fragmento que envia uma tarefa assíncrona. Quando a tarefa é concluída, o ouvinte onTaskComplete é chamado.

@Override
public void onTaskComplete(List<Feed> result) {

    progress.setVisibility(View.GONE);
    progress.setIndeterminate(false);
    list.setVisibility(View.VISIBLE);

    if (isAdded()) {

        adapter = new FeedAdapter(getActivity(), R.layout.feed_item, result);
        list.setAdapter(adapter);
        adapter.notifyDataSetChanged();
    }

}

Se abrirmos o fragmento, enviar uma tarefa e, em seguida, pressionar rapidamente para retornar a uma atividade anterior, quando a tarefa for concluída, ela tentará acessar a atividade em onPostExecute () chamando o método getActivity (). Se a atividade já estiver desanexada e essa verificação não estiver lá:

if (isAdded()) 

então o aplicativo trava.

Ok, eu sei que esta questão está realmente resolvida, mas decidi compartilhar minha solução para isso. Eu criei a classe pai abstrata para o meu Fragment :

public abstract class ABaseFragment extends Fragment{

    protected IActivityEnabledListener aeListener;

    protected interface IActivityEnabledListener{
        void onActivityEnabled(FragmentActivity activity);
    }

    protected void getAvailableActivity(IActivityEnabledListener listener){
        if (getActivity() == null){
            aeListener = listener;

        } else {
            listener.onActivityEnabled(getActivity());
        }
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) activity);
            aeListener = null;
        }
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) context);
            aeListener = null;
        }
    }
}

Como você pode ver, eu adicionei um ouvinte assim, sempre que eu precisar pegar Fragments Activity invés do padrão getActivity() , eu precisarei chamar

 getAvailableActivity(new IActivityEnabledListener() {
        @Override
        public void onActivityEnabled(FragmentActivity activity) {
            // Do manipulations with your activity
        }
    });

O melhor para se livrar disso é manter a referência de atividade quando onAttach é chamado e usar a referência de atividade sempre que necessário, por exemplo,

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    mContext = context;
}

@Override
public void onDetach() {
    super.onDetach();
    mContext = null;
}

Editado, desde que onAttach(Activity) foi depreciado e agora onAttach(Context) está sendo usado

Para adicionar mais informações para isso.

Eu recentemente atualizei minha instalação do Ubuntu 10.04 para o Ubuntu 10.04 LTS (Lucid Lynx) que, por sua vez, atualizou minha versão de Java para:

Java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode)

E agora o emulador (embora demore um pouco para começar) parece estar rodando mais rápido do que anteriormente.

Pode valer a pena que as pessoas atualizem sua JVM.