Qual é a diferença entre os vários métodos para obter um contexto?

Em vários bits do código Android, eu já vi:

 public class MyActivity extends Activity {
    public void method() {
       mContext = this;    // since Activity extends Context
       mContext = getApplicationContext();
       mContext = getBaseContext();
    }
 }

No entanto, não consigo encontrar nenhuma explicação decente sobre qual é preferível e em que circunstâncias deve ser usada.

Seria muito apreciada a orientação sobre a documentação e orientações sobre o que poderia quebrar se a escolhida errada.

Concordo que a documentação é escassa no que diz respeito aos contextos no Android, mas você pode reunir alguns fatos de várias fontes.

Esta postagem no blog oficial dos desenvolvedores do Google Android foi escrita principalmente para ajudar a corrigir vazamentos de memória, mas fornece algumas boas informações sobre contextos:

Em um aplicativo Android normal, você geralmente tem dois tipos de Contexto, Atividade e Aplicativo.

Ler o artigo um pouco mais detalha a diferença entre os dois e quando você pode considerar usar o aplicativo Context ( Activity.getApplicationContext()) em vez de usar o contexto de Atividade this). Basicamente, o contexto do Aplicativo está associado ao Aplicativo e sempre será o mesmo durante todo o ciclo de vida do seu aplicativo, onde o contexto da Atividade está associado à atividade e pode ser destruído várias vezes, pois a atividade é destruída durante as alterações na orientação da tela e tal.

Não encontrei nada sobre quando usar o getBaseContext () além de uma postagem de Dianne Hackborn, uma das engenheiras do Google que trabalha no Android SDK:

Não use getBaseContext (), apenas use o contexto que você possui.

Isso foi de uma postagem no grupo de notícias de desenvolvedores do Android . Você também pode fazer sua pergunta lá, porque várias pessoas que trabalham no Android monitoram esse grupo de notícias e respondem a perguntas.

Portanto, no geral, parece preferível usar o contexto global de aplicativos sempre que possível.

Aqui está o que eu encontrei sobre o uso de context:

1) No Activitypróprio, use thispara aumentar layouts e menus, registrar menus de contexto, instanciar widgets, iniciar outras atividades, criar novo Intentdentro de um Activity, instanciar preferências ou outros métodos disponíveis no Activity.

Inflar layout:

View mView = this.getLayoutInflater().inflate(R.layout.myLayout, myViewGroup);

Inflar menu:

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);
    this.getMenuInflater().inflate(R.menu.mymenu, menu);
    return true;
}

Registrar menu de contexto:

this.registerForContextMenu(myView);

Instanciar widget:

TextView myTextView = (TextView) this.findViewById(R.id.myTextView);

Iniciar um Activity:

Intent mIntent = new Intent(this, MyActivity.class);
this.startActivity(mIntent);

Instanciar preferências:

SharedPreferences mSharedPreferences = this.getPreferenceManager().getSharedPreferences();

2) Para a classe de todo o aplicativo, use getApplicationContext()como este contexto existe para a vida útil do aplicativo.

Recupere o nome do pacote Android atual:

public class MyApplication extends Application {    
    public static String getPackageName() {
        String packageName = null;
        try {
            PackageInfo mPackageInfo = getApplicationContext().getPackageManager().getPackageInfo(getApplicationContext().getPackageName(), 0);
            packageName = mPackageInfo.packageName;
        } catch (NameNotFoundException e) {
            // Log error here.
        }
        return packageName;
    }
}

Vincule uma classe para todo o aplicativo:

Intent mIntent = new Intent(this, MyPersistent.class);
MyServiceConnection mServiceConnection = new MyServiceConnection();
if (mServiceConnection != null) {
    getApplicationContext().bindService(mIntent, mServiceConnection, Context.BIND_AUTO_CREATE);
}

3) Para ouvintes e outros tipos de classes do Android (por exemplo, ContentObserver), use uma substituição de contexto como:

mContext = this;    // Example 1
mContext = context; // Example 2

onde thisou contexté o contexto de uma classe (atividade etc.).

Activity substituição de contexto:

public class MyActivity extends Activity {
    private Context mContext;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);        
        mContext = this;
    }
}

Substituição de contexto do ouvinte:

public class MyLocationListener implements LocationListener {
    private Context mContext;
    public MyLocationListener(Context context) {
        mContext = context;
    }
}

ContentObserver substituição de contexto:

public class MyContentObserver extends ContentObserver {
    private Context mContext;
    public MyContentObserver(Handler handler, Context context) {
        super(handler);
        mContext = context;
    }
}

4) Para BroadcastReceiver(incluindo receptor embutido / embutido), use o próprio contexto do receptor.

Externo BroadcastReceiver:

public class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        final String action = intent.getAction();
        if (action.equals(Intent.ACTION_SCREEN_OFF)) {
            sendReceiverAction(context, true);
        }
        private static void sendReceiverAction(Context context, boolean state) {
            Intent mIntent = new Intent(context.getClass().getName() + "." + context.getString(R.string.receiver_action));
            mIntent.putExtra("extra", state);
            context.sendBroadcast(mIntent, null);
        }
    }
}

Inline / Incorporado BroadcastReceiver:

public class MyActivity extends Activity {
    private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final boolean connected = intent.getBooleanExtra(context.getString(R.string.connected), false);
            if (connected) {
                // Do something.
            }
        }
    };
}

5) Para Serviços, use o próprio contexto do serviço.

public class MyService extends Service {
    private BroadcastReceiver mBroadcastReceiver;
    @Override
    public void onCreate() {
        super.onCreate();
        registerReceiver();
    }
    private void registerReceiver() {
        IntentFilter mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(Intent.ACTION_SCREEN_OFF);
        this.mBroadcastReceiver = new MyBroadcastReceiver();
        this.registerReceiver(this.mBroadcastReceiver, mIntentFilter);
    } 
}

6) Para brindes, use geralmente getApplicationContext(), mas sempre que possível, use o contexto transmitido de uma atividade, serviço etc.

Use o contexto do aplicativo:

Toast mToast = Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG);
mToast.show();

Use o contexto passado de uma fonte:

public static void showLongToast(Context context, String message) {
    if (context != null && message != null) {
        Toast mToast = Toast.makeText(context, message, Toast.LENGTH_LONG);
        mToast.show();
    }
}

E por último, não use getBaseContext()como recomendado pelos desenvolvedores de estrutura do Android.

ATUALIZAÇÃO: adicione exemplos de Contextuso.

Eu li esse tópico há alguns dias, me perguntando a mesma pergunta. Minha decisão depois de ler isso foi simples: sempre use applicationContext.

No entanto, encontrei um problema com isso, passei algumas horas para encontrá-lo e alguns segundos para resolvê-lo ... (alterando uma palavra ...)

Estou usando um LayoutInflater para inflar uma exibição que contém um Spinner.

Então, aqui estão duas possibilidades:

1)

    LayoutInflater layoutInflater = LayoutInflater.from(this.getApplicationContext());

2)

    LayoutInflater layoutInflater = LayoutInflater.from(this.getBaseContext());

Então, eu estou fazendo algo parecido com isto:

    // managing views part
    View view = ContactViewer.mLayoutInflater.inflate(R.layout.aViewContainingASpinner, theParentView, false);
    Spinner spinner = (Spinner) view.findViewById(R.id.theSpinnerId);
    String[] myStringArray = new String[] {"sweet","love"};

    // managing adapter part
    // The context used here don't have any importance -- both work.
    ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this.getApplicationContext(), myStringArray, android.R.layout.simple_spinner_item);
    adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
    spinner.setAdapter(adapter);

    theParentView.addView(view);

O que eu notei: se você instanciar seu linearLayout com o applicationContext, ao clicar no botão giratório em sua atividade, você terá uma exceção não capturada, vinda da máquina virtual da dalvik (não do seu código, é por isso que gastei muito de tempo para descobrir onde estava o meu erro ...).

Se você usar o baseContext, tudo bem, o menu de contexto será aberto e você poderá escolher entre suas opções.

Então, aqui está a minha conclusão: suponho (não o testei mais) que o baseContext é necessário ao lidar com o contextMenu em sua Atividade ...

O teste foi feito com a API 8 e testado em um HTC Desire, android 2.3.3.

Espero que meu comentário não o tenha aborrecido até agora e desejo tudo de bom. Happy coding ;-)

Primeiro, concordo que devemos usar o appcontext sempre que possível. então "isso" em atividade. eu nunca tive necessidade de basecontext.

Nos meus testes, na maioria dos casos, eles podem ser trocados. Na maioria dos casos, o motivo pelo qual você deseja conhecer um contexto é acessar arquivos, preferências, banco de dados etc. Esses dados são refletidos como arquivos na pasta de dados particulares do seu aplicativo (/ data / data /). Não importa qual contexto você use, eles serão mapeados para a mesma pasta / arquivos, para que você esteja bem.

Foi o que eu observei. Talvez haja casos em que você deve distingui-los.

Em alguns casos, você pode usar o contexto de atividade sobre o contexto do aplicativo ao executar algo em um encadeamento. Quando o encadeamento conclui a execução e você precisa retornar o resultado à atividade do chamador, você precisa desse contexto com um manipulador.

((YourActivity) context).yourCallbackMethod(yourResultFromThread, ...);

Em palavras simples

getApplicationContext()como o nome do método sugere, seu aplicativo estará ciente dos detalhes gerais do aplicativo, que você pode acessar de qualquer lugar no aplicativo. Assim, você pode fazer uso disso na vinculação de serviço, no registro de transmissão etc. Application contextpermanecerá ativo até a saída do aplicativo.

getActivity()ou thistornará seu aplicativo ciente da tela atual, visível também os detalhes no nível do aplicativo fornecidos por application context. Portanto, tudo o que você deseja saber sobre a tela atual Window ActionBar Fragementmangerestá disponível neste contexto. Basicamente e Activityestender Context. Esse contexto permanecerá ativo até que o componente atual (atividade) esteja ativo

A confusão decorre do fato de que existem inúmeras maneiras de acessar o Contexto, sem (na superfície) diferenças discerníveis. Abaixo estão quatro das maneiras mais comuns pelas quais você pode acessar o Contexto em uma Atividade.

getContext()
getBaseContext()
getApplicationContext()
getActionBar().getThemedContext() //new

O que é um contexto? Pessoalmente, gosto de pensar no Contexto como o estado do seu aplicativo a qualquer momento. O Contexto do aplicativo representa uma configuração global ou básica do seu aplicativo e uma Atividade ou Serviço pode ser construído sobre ele e representa uma instância de configuração do seu Aplicativo ou um estado transitivo para ele.

Se você consultar a fonte android.content.Context, verá que Context é uma classe abstrata e os comentários na classe são os seguintes:

Interface com informações globais sobre um ambiente de aplicativo. Esta é uma classe abstrata cuja implementação é fornecida pelo sistema Android. Ele permite o acesso a application-specificrecursos e classes, bem como chamadas para application-leveloperações como iniciar atividades, transmitir e receber intenções, etc. O que retiro disso é que o Context fornece uma implementação comum para acessar o nível do aplicativo e o nível do sistema Recursos. Os recursos no nível do aplicativo podem estar acessando coisas como recursos [getResources()]ou ativos de String [getAssets()]e recurso no nível do sistema é qualquer coisa com a qual você acessaContext.getSystemService().

De fato, dê uma olhada nos comentários sobre os métodos e eles parecem reforçar essa noção:

getSystemService(): Retorne o identificador para um system-levelserviço pelo nome. A classe do objeto retornado varia de acordo com o nome solicitado. getResources(): Retorne uma instância de recursos para o pacote do seu aplicativo. getAssets(): Retorne uma instância de recursos para o pacote do seu aplicativo. Vale a pena ressaltar que na classe abstrata Context, todos os métodos acima são abstratos! Somente uma instância de getSystemService (Class) possui uma implementação e isso chama um método abstrato. Isso significa que a implementação deve ser fornecida principalmente pelas classes de implementação, que incluem:

ContextWrapper
Application
Activity
Service
IntentService

Observando a documentação da API, a hierarquia das classes é semelhante a esta:

Contexto

| - ContextWrapper

| - - Aplicação

| - - ContextThemeWrapper

| - - - - Atividade

| - - Serviço

| - - - IntentService

Como sabemos que Contextele próprio não está fornecendo nenhum insight, descemos a árvore, observamos ContextWrappere percebemos que também não há muito. Como o Aplicativo se estende ContextWrapper, não há muito o que analisar por lá, pois ele não substitui a implementação fornecida pelo ContextWrapper. Isso significa que a implementação do Contexto é fornecida pelo SO e oculta do API. Você pode dar uma olhada na implementação concreta do Context, olhando a fonte da classe ContextImpl.

Eu só usei isso e getBaseContextquando brindar de um onClick(noob muito verde para Java e android). Eu uso isso quando meu clicker está diretamente na atividade e preciso usá-lo getBaseContextem um clicker interno anônimo. Acho que esse é o truque getBaseContext, talvez esteja retornando o contexto da atividade na qual a classe interna está se escondendo.