Qual é a diferença entre getContext()
, getApplicationContext()
, getBaseContext()
, e " this
"?
Embora essa seja uma pergunta simples, sou incapaz de entender a diferença básica entre eles. Por favor, dê alguns exemplos fáceis, se possível.
Qual é a diferença entre getContext()
, getApplicationContext()
, getBaseContext()
, e " this
"?
Embora essa seja uma pergunta simples, sou incapaz de entender a diferença básica entre eles. Por favor, dê alguns exemplos fáceis, se possível.
Respostas:
View.getContext()
: Retorna o contexto em que a visualização está sendo executada. Geralmente, a Atividade ativa no momento.
Activity.getApplicationContext()
: Retorna o contexto para o aplicativo inteiro (o processo em que todas as atividades estão sendo executadas). Use isso em vez do contexto atual da Atividade se precisar de um contexto vinculado ao ciclo de vida de todo o aplicativo, não apenas da Atividade atual.
ContextWrapper.getBaseContext()
: Se você precisar acessar um contexto de outro contexto, use um ContextWrapper. O Contexto referido de dentro desse ContextWrapper é acessado via getBaseContext ().
this
e getContext()
nem sempre são iguais, por exemplo, na classe Activity, você pode usar this
porque Activity
herda de, Context
mas o método getContext()
não está na Activity
classe. @mikedroid @KCRaju
A maioria das respostas já cobre getContext()
e getApplicationContext()
mas getBaseContext () raramente é explicado.
O método getBaseContext()
é relevante apenas quando você tem um ContextWrapper
. O Android fornece uma ContextWrapper
classe criada em torno de uma existente Context
usando:
ContextWrapper wrapper = new ContextWrapper(context);
O benefício de usar a ContextWrapper
é que ele permite "modificar o comportamento sem alterar o contexto original". Por exemplo, se você tiver uma atividade chamada myActivity
, poderá criar uma View
com um tema diferente de myActivity
:
ContextWrapper customTheme = new ContextWrapper(myActivity) {
@Override
public Resources.Theme getTheme() {
return someTheme;
}
}
View myView = new MyView(customTheme);
ContextWrapper
é realmente poderoso porque permite substituir a maioria das funções fornecidas, Context
incluindo código para acessar recursos (por exemplo openFileInput()
,getString()
), interagir com outros componentes (por exemplo sendBroadcast()
, registerReceiver()
), solicitar permissões (por exemplo checkCallingOrSelfPermission()
) e resolver locais de sistema de arquivos (por exemplo getFilesDir()
). ContextWrapper
é realmente útil para solucionar problemas específicos do dispositivo / versão ou para aplicar personalizações pontuais a componentes como Exibições que exigem um contexto.
O método getBaseContext () pode ser usado para acessar o Contexto "base" que o ContextWrapper
envolve. Você pode precisar acessar o contexto "base" se precisar, por exemplo, verificar se é umService
, Activity
ou Application
:
public class CustomToast {
public void makeText(Context context, int resId, int duration) {
while (context instanceof ContextWrapper) {
context = context.baseContext();
}
if (context instanceof Service)) {
throw new RuntimeException("Cannot call this from a service");
}
...
}
}
Ou se você precisar chamar a versão "desembrulhada" de um método:
class MyCustomWrapper extends ContextWrapper {
@Override
public Drawable getWallpaper() {
if (BuildInfo.DEBUG) {
return mDebugBackground;
} else {
return getBaseContext().getWallpaper();
}
}
}
ContextWrapper
é uma das piores decisões já tomadas pelos desenvolvedores do framework Android. Quando eles perceberam que criaram uma família inteira de Objetos Deus, em vez de fazer a coisa certa e refatorar o código para a Responsabilidade Única, eles adicionaram um truque feio que permitia mudar o comportamento do Contexto, aprofundando a árvore de herança. Engenharia de software ruim é a mais feia. Quanto a nós, desenvolvedores, IMHO ninguém deve usar getBaseContext()
ou ContextWrapper
. Se você faz - é um enorme "cheiro de código".
CustomToast
código completo . Obrigado :)))
getApplicationContext () - Retorna o contexto para todas as atividades em execução no aplicativo.
getBaseContext () - Se você quiser acessar o Contexto de outro contexto dentro do aplicativo, poderá acessar.
getContext () - Retorna a visualização de contexto apenas da atividade atual em execução.
A pergunta "o que é o contexto" é uma das perguntas mais difíceis do universo Android.
O contexto define métodos que acessam recursos do sistema, recuperam ativos estáticos do aplicativo, verificam permissões, executam manipulações da interface do usuário e muito mais. Em essência, Context
é um exemplo do antipadrão de Objeto de Deus na produção.
Quando se trata de que tipo de Context
uso devemos usar, isso se torna muito complicado, porque, exceto por ser objeto de Deus, a árvore hierárquica das Context
subclasses viola brutalmente o princípio da substituição de Liskov.
Esta postagem do blog tenta resumir a Context
aplicabilidade das classes em diferentes situações.
Deixe-me copiar a tabela principal dessa postagem para garantir a integridade:
+----------------------------+-------------+----------+---------+-----------------+-------------------+ | | Application | Activity | Service | ContentProvider | BroadcastReceiver | +----------------------------+-------------+----------+---------+-----------------+-------------------+ | Show a Dialog | NO | YES | NO | NO | NO | | Start an Activity | NO¹ | YES | NO¹ | NO¹ | NO¹ | | Layout Inflation | NO² | YES | NO² | NO² | NO² | | Start a Service | YES | YES | YES | YES | YES | | Bind to a Service | YES | YES | YES | YES | NO | | Send a Broadcast | YES | YES | YES | YES | YES | | Register BroadcastReceiver | YES | YES | YES | YES | NO³ | | Load Resource Values | YES | YES | YES | YES | YES | +----------------------------+-------------+----------+---------+-----------------+-------------------+
- Um aplicativo PODE iniciar uma Atividade a partir daqui, mas requer que uma nova tarefa seja criada. Isso pode se encaixar em casos de uso específicos, mas pode criar comportamentos não padronizados de back stack no seu aplicativo e geralmente não é recomendado ou considerado uma boa prática.
- Isso é legal, mas a inflação será feita com o tema padrão do sistema no qual você está executando, não com o definido no seu aplicativo.
- Permitido se o receptor for nulo, usado para obter o valor atual de uma transmissão persistente, no Android 4.2 e superior.
Context
fornece informações sobre o Actvity
ouApplication
componentes recém-criados .
Relevante Context
deve ser fornecido aos componentes recém-criados (seja contexto de aplicativo ou contexto de atividade)
Como Activity
é uma subclasse de Context
, pode-se usar this
para obter o contexto dessa atividade
getApplicationContext ()
isso é usado para o nível do aplicativo e refere-se a todas as atividades.
getContext () e getBaseContext ()
é provavelmente o mesmo. estes são referidos apenas à atividade atual que está ativa.
isto
é referir o objeto de classe atual sempre.
A Context
é: