getapplicationcontext - how to get context android studio




O que é "Contexto" no Android? (19)

Analogia do Assistente de Chefe

Vamos ter uma pequena analogia antes de mergulhar fundo na tecnicidade do Contexto

Todo chefe tem um assistente ou alguém (garoto de recados) que faz coisas menos importantes e mais demoradas para ele. Por exemplo, se eles precisarem de um arquivo ou café, um assistente estará em funcionamento. O chefe não saberá o que está acontecendo no segundo plano, mas o arquivo ou a tarefa será entregue

Então aqui
Boss - Aplicativo para Android
Assistente - Contexto
Arquivo ou xícara de café - Recurso

O site oficial do desenvolvedor Android diz sobre o Context

Contexto é o seu ponto de acesso para recursos relacionados ao aplicativo

Vamos ver alguns desses recursos ou tarefas

  • Lançando uma atividade.

  • Obtendo o caminho absoluto para o diretório de cache específico do aplicativo no sistema de arquivos.

  • Determinar se a permissão dada é permitida para um processo específico e um ID do usuário em execução no sistema.

  • Verificando se você recebeu uma permissão específica.

E assim por diante.
Portanto, se um aplicativo Android quiser iniciar uma atividade, ele irá diretamente para o Context (Access Point), e a classe Context lhe devolverá os recursos (Intent, neste caso).

Como qualquer outra classe, a classe Context também possui campos e métodos.
Você pode explorar mais sobre o Context na documentação oficial, ele abrange praticamente tudo, métodos disponíveis, campos e até mesmo como usar campos com métodos.

Na programação do Android, o que exatamente é uma classe Context e para que é usada?

Eu li sobre isso no site do desenvolvedor , mas não consigo entender claramente.


Definição de Contexto

  • Contexto representa dados do ambiente
  • Ele fornece acesso a coisas como bancos de dados

Termos mais simples (exemplo 1)

  • Considere Person-X é o CEO de uma empresa de software start-up.

  • Há um arquiteto líder presente na empresa, este arquiteto líder faz todo o trabalho na empresa que envolve, como banco de dados, interface do usuário etc.

  • Agora o CEO contrata um novo desenvolvedor.

  • É o arquiteto que diz a responsabilidade do recém-contratado com base nas habilidades da nova pessoa que quer ele trabalhe em banco de dados ou UI etc.

Termos mais simples (exemplo 2)

  • É como o acesso da atividade do Android ao recurso do aplicativo.

  • É semelhante a quando você visita um hotel, você quer café da manhã, almoço e jantar nos horários adequados, certo?

  • Há muitas outras coisas que você gosta durante o tempo de permanência. Como você consegue essas coisas?

  • Você pede que a pessoa do serviço de quarto traga essas coisas para você.

  • Aqui a pessoa de serviço de quarto é o contexto considerando que você é a única atividade e o hotel para ser seu aplicativo, finalmente o café da manhã, almoço & jantar tem que ser os recursos.

Coisas que envolvem contexto são:

  1. Carregando um recurso.
  2. Lançando uma nova atividade.
  3. Criando exibições.
  4. obtenção de serviço do sistema.

Contexto é a classe base para Atividade , Serviço , Aplicativo , etc

Outra maneira de descrever isso: Considere o contexto como remoto de uma TV e canal na televisão são recursos, serviços, usando intenções, etc - - - Aqui remoto atua como um acesso para obter acesso a todos os recursos diferentes em primeiro plano.

  • Então, o Remote tem acesso a canais como recursos, serviços, usando intents etc ....

  • Da mesma forma ... Quem tem acesso remoto naturalmente tem acesso a todas as coisas, como recursos, serviços, usando intenções, etc.

Diferentes métodos pelos quais você pode obter contexto

  • getApplicationContext()
  • getContext()
  • getBaseContext()
  • ou this (quando na classe de atividade)

Exemplo:

TextView TV=new TextView(this);

this -> refere-se ao contexto da atividade atual.


Basta colocá-lo lá fora para iniciantes;

Então, primeiro compreenda o contexto da palavra:

Em inglês-lib. Isso significa:

"As circunstâncias que formam o cenário para um evento, declaração ou ideia, e em termos dos quais ela pode ser totalmente compreendida e avaliada."

"As partes de algo escrito ou falado que imediatamente precedem e seguem uma palavra ou passagem e esclarecem seu significado."

Agora, tenha o mesmo entendimento para o mundo da programação:

contexto do estado atual do aplicativo / objeto. Permite que objetos recém-criados entendam o que está acontecendo. Normalmente você o chama para obter informações sobre outra parte do seu programa (atividade, pacote / aplicativo)

Você pode obter o contexto invocando getApplicationContext() , getContext(), getBaseContext() ou this (quando na classe de atividade).

Para obter Contexto em Qualquer Lugar no aplicativo, use o seguinte código:

Crie uma nova classe AppContext dentro do seu aplicativo android

public class AppContext extends Application {

    private static Context context;

    public void onCreate(){
        super.onCreate();
        AppContext.context = getApplicationContext();
    }

    public static Context getAppContext() {
        return AppContext.context;
    }
}

Agora, toda vez que você quiser o contexto do aplicativo na classe que não seja de atividade, chame esse método e você terá o contexto do aplicativo.

Espero que esta ajuda;)


Colocando de forma simples, o Androids Context é uma bagunça que você não vai amar até parar de se preocupar.

Context Android s são:

  • Objetos de Deus.

  • Coisa que você quer passar em torno de toda a sua aplicação quando você está começando a desenvolver para o Android, mas vai evitar fazê-lo quando você chegar um pouco mais perto de programação, testes e Android em si.

    • Dependência pouco clara.

    • Fonte comum de vazamentos de memória.

    • PITA para testes.

  • Contexto real usado pelo sistema Android para despachar permissões, recursos, preferências, serviços, transmissões, estilos, mostrando diálogos e inflar o layout. E você precisa de Contextinstâncias diferentes para algumas coisas separadas (obviamente, você não pode mostrar um diálogo de um aplicativo ou contexto de serviço; layouts inflados de contextos de aplicativos e atividades podem ser diferentes).


Contexto é Instâncias da classe android.content.Context fornecem a conexão com o sistema Android que executa o aplicativo. Por exemplo, você pode verificar o tamanho da exibição do dispositivo atual por meio do Contexto.

Também dá acesso aos recursos do projeto. É a interface para informações globais sobre o ambiente de aplicativos.

A classe Context também fornece acesso a serviços Android, por exemplo, o gerenciador de alarmes para acionar eventos baseados no tempo.

Atividades e serviços estendem a classe Context. Portanto, eles podem ser usados ​​diretamente para acessar o contexto.


Contexto é o contexto do estado atual do aplicativo / objeto. Sua entidade representa vários dados do ambiente. O Context ajuda a atividade atual a interagir com o ambiente externo do Android, como arquivos locais, bancos de dados, carregadores de classes associados ao ambiente, serviços que incluem serviços no nível do sistema e muito mais.

Um Contexto é um identificador para o sistema. Ele fornece serviços como resolver recursos, obter acesso a bancos de dados e preferências e assim por diante. Um aplicativo para Android tem atividades. É como um identificador para o ambiente em que seu aplicativo está sendo executado atualmente. O objeto de atividade herda o objeto Context.

Diferentes métodos de chamada pelos quais você pode obter o contexto 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. ou this (quando na classe de atividade).


Contexto significa que o Android deve saber em qual atividade eu devo agir ou agir.

1 - Toast.makeText (contexto, "Inserir todos os detalhes", Toast.LENGTH_SHORT) .show (); é usado nisso. Contexto de contexto = ActivityName.this;

2 -startActivity (novo Intent (contexto, LoginActivity.class));

neste contexto, significa de qual atividade você quer ir para outra atividade. context ou ActivityName.this é mais rápido, getContext e getApplicatinContext.


Exemplo simples para entender o context no android:

Todo chefe tem um assistente para cuidar de todas as tarefas menos importantes e demoradas. Se um arquivo ou uma xícara de café for necessário, o assistente está em fuga. Alguns chefes mal sabem o que está acontecendo no escritório, então eles perguntam a seus assistentes sobre isso também. Eles fazem algum trabalho eles mesmos, mas para a maioria das outras coisas eles precisam da ajuda de seus assistentes.

Neste cenário,

Boss - é o aplicativo para Android

Assistente - é contexto

Arquivos / xícara de café - são recursos

Geralmente, chamamos de contexto quando precisamos obter informações sobre diferentes partes de nosso aplicativo, como Atividades, Aplicativos, etc.

Algumas operações (coisas em que o assistente é necessário) onde o contexto está envolvido:

Carregando recursos comuns Criando exibições dinâmicas Exibindo mensagens do Toast Iniciando Atividades etc. Diferentes maneiras de obter contexto:

getContext()

getBaseContext()

getApplicationContext()

this

O contexto é basicamente para o acesso a recursos e para obter os detalhes do ambiente do aplicativo (para o contexto do aplicativo) ou atividade (para o contexto de atividade) ou qualquer outro ...

Para evitar vazamento de memória, você deve usar o contexto de aplicação para todos os componentes que precisam de um objeto de contexto .... para mais clique here


Pense nisso como a VM que isolou o processo no qual o aplicativo ou serviço está sendo executado. O ambiente em silos tem acesso a várias informações de sistema subjacentes e a certos recursos permitidos. Você precisa desse contexto para chegar a esses serviços.


Um Context Android é uma Interface (no sentido geral, não no sentido de Java; em Java, o Context é, na verdade, uma classe abstrata!) Que permite acesso a recursos específicos de aplicativos e classe e informações sobre o ambiente de aplicativos.

Se o seu aplicativo Android for um aplicativo da web, seu contexto será algo semelhante ao ServletContext (não estou fazendo uma comparação exata aqui).

Suas atividades e serviços também estendem o Context , então eles herdam todos esses métodos para acessar as informações do ambiente em que o aplicativo está sendo executado.


Um Context é o que a maioria de nós chamaria de aplicativo . É feito pelo sistema Android e é capaz de fazer apenas o que um aplicativo é capaz de fazer. No Tomcat, um Contexto também é o que eu chamaria de aplicativo.

Existe um Contexto que contém muitas Atividades, cada Atividade pode ter muitas Visualizações.

Obviamente, alguns dirão que não cabe por causa disso ou daquilo e provavelmente estão certos, mas dizer que um Contexto é sua aplicação atual o ajudará a entender o que você está colocando nos parâmetros do método.


Source

O tema do contexto no Android parece ser confuso para muitos. As pessoas só sabem que o contexto é necessário muitas vezes para fazer coisas básicas no Android. As pessoas às vezes entram em pânico porque tentam executar alguma operação que requer o Contexto e não sabem como “obter” o Contexto correto. Vou tentar desmistificar a ideia de Contexto no Android. Um tratamento completo do problema está além do escopo deste post, mas tentarei fornecer uma visão geral para que você tenha uma noção do que é o Context e como usá-lo. Para entender o que é Context, vamos dar uma olhada no código-fonte:

https://github.com/android/platform_frameworks_base/blob/master/core/java/android/content/Context.java

O que exatamente é o contexto?

Bem, a documentação em si fornece uma explicação bastante direta: A classe Context é uma “Interface para informações globais sobre um ambiente de aplicativo”.

A classe Context em si é declarada como classe abstrata, cuja implementação é fornecida pelo sistema operacional Android. A documentação fornece ainda que Contexto “… permite o acesso a recursos e classes específicos do aplicativo, bem como chamadas para operações no nível do aplicativo, como atividades de lançamento, intenções de transmissão e recebimento, etc.”.

Você pode entender muito bem, agora, porque o nome é Contexto. É porque é só isso. O Contexto fornece o link ou gancho, se desejar, para uma Atividade, Serviço ou qualquer outro componente, vinculando-o ao sistema, permitindo acesso ao ambiente de aplicativo global. Em outras palavras: o Contexto fornece a resposta para a pergunta de componentes “onde diabos eu estou em relação ao aplicativo em geral e como acesso / comunico com o restante do aplicativo?” Se tudo isso parece um pouco confuso, um rápido Veja os métodos expostos pela classe Context fornece algumas pistas adicionais sobre sua verdadeira natureza.

Aqui está uma amostra aleatória desses métodos:

  1. getAssets()
  2. getResources()
  3. getPackageManager()
  4. getString()
  5. getSharedPrefsFile()

O que todos esses métodos têm em comum? Todos eles permitem que qualquer pessoa que tenha acesso ao Contexto possa acessar recursos de todo o aplicativo.

Contexto, em outras palavras, conecta o componente que tem uma referência a ele para o restante do ambiente de aplicativo. Os ativos (pense na pasta 'assets' do seu projeto), por exemplo, estão disponíveis em todo o aplicativo, desde que uma Atividade, Serviço ou qualquer outra pessoa saiba como acessar esses recursos. O mesmo vale para getResources() que permite fazer coisas como getResources().getColor() que irá enganchar você no recurso colors.xml (deixa pra lá que o aapt permite acesso a recursos via código java, que é um problema separado).

O resultado é que o Context é o que permite o acesso aos recursos do sistema e o que conecta os componentes ao "aplicativo maior". Vamos observar as subclasses de Context , as classes que fornecem a implementação da classe Context abstrata. Classe de Activity herda de ContextThemeWrapper , que herda de ContextWrapper , que herda do Context ContextWrapper classes são úteis para olhar para entender as coisas em um nível mais profundo, mas por enquanto é suficiente saber que ContextThemeWrapper e ContextWrapper são praticamente o que eles Eles implementam os elementos abstratos da classe Context "envolvendo" um contexto (o contexto real) e delegando essas funções àquele contexto.Um exemplo é útil - na classe ContextWrapper , o método abstrato getAssets da classe Context é implementado da seguinte forma:

@Override
    public AssetManager getAssets() {
        return mBase.getAssets();
    }

mBase é simplesmente um campo definido pelo construtor para um contexto específico. Portanto, um contexto é empacotado e o ContextWrapper delega sua implementação do método getAssets para esse contexto. Vamos voltar a examinar a classe Activity que, por fim, herda do Context para ver como tudo isso funciona.

Você provavelmente sabe o que é uma atividade, mas para rever - é basicamente 'uma única coisa que o usuário pode fazer. Ele cuida de fornecer uma janela na qual colocar a interface do usuário com a qual o usuário interage '. Desenvolvedores familiarizados com outras APIs e até mesmo com não desenvolvedores podem pensar neles como uma "tela". Isso é tecnicamente impreciso, mas não importa para nossos propósitos. Então, como Activity e Context interagem e o que exatamente está acontecendo em seu relacionamento de herança?

Novamente, é útil examinar exemplos específicos. Todos sabemos como lançar atividades. Desde que você tenha “o contexto” a partir do qual você está iniciando a atividade, basta chamar startActivity(intent) , onde o Intent descreve o contexto a partir do qual você está iniciando uma Activity e a Activity que gostaria de iniciar. Esta é a startActivity(this, SomeOtherActivity.class) familiar startActivity(this, SomeOtherActivity.class) .

E o que é this ? this é sua atividade porque a classe da Activity herda do Context . A informação completa é assim: Quando você chama startActivity , a classe Activity executa algo assim:

Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode);

Por isso, utiliza a execStartActivity da classe Instrumentation (na verdade, de uma classe interna em Instrumentation chamada ActivityResult ).

Neste ponto, estamos começando a dar uma olhada nos componentes internos do sistema.

É aqui que o SO realmente lida com tudo. Então, como a Instrumentação inicia a atividade exatamente? Bem, o parâmetro this no método execStartActivity acima é sua Activity, isto é, o Context, e a execStartActivity faz uso deste contexto.

Uma visão geral de 30.000 é a seguinte: a classe Instrumentation mantém as faixas de uma lista de atividades que está sendo monitorada para fazer seu trabalho. Essa lista é usada para coordenar todas as atividades e garantir que tudo corra bem no gerenciamento do fluxo de atividades.

Existem algumas operações que eu não examinei completamente em quais threads de encadeamento e problemas de processo. Por fim, o ActivityResult usa uma operação nativa - ActivityManagerNative.getDefault().startActivity() que usa o Context que você passou quando chamou startActivity . O contexto em que você passou é usado para ajudar na “resolução da intenção”, se necessário. A resolução intencional é o processo pelo qual o sistema pode determinar o destino da intenção, se não for fornecido. (Confira o guia aqui para mais detalhes).

E para que o Android faça isso, ele precisa acessar as informações fornecidas pelo Context . Especificamente, o sistema precisa acessar um ContentResolver para que ele possa “determinar o tipo MIME dos dados da intenção” startActivity sobre como o startActivity faz uso do contexto foi um pouco complicada e eu não entendo completamente os internos. O ponto principal era apenas ilustrar como os recursos de todo o aplicativo precisam ser acessados ​​para executar muitas das operações essenciais a um aplicativo. O Context é o que fornece acesso a esses recursos. Um exemplo mais simples pode ser o Views. você cria um modo de exibição personalizado estendendo RelativeLayout ou alguma outra classe de modo de View , você deve fornecer um construtor que leva um Context como um argumento.Quando você instanciar sua exibição personalizada passar no contexto.Por quê? Porque a exibição precisa ser capaz de ter acesso a temas, recursos e outros detalhes de configuração de visualização.A configuração de visualização é realmente um ótimo exemplo.Cada contexto tem vários parâmetros (campos em implementações de Context ) que são definidos pelo próprio SO para coisas como a dimensão ou densidade do display. É fácil entender por que essas informações são importantes para a configuração de modos de exibição, etc.

Uma palavra final: Por alguma razão, as pessoas novas no Android (e até mesmo as pessoas não tão novas) parecem esquecer completamente sobre programação orientada a objetos quando se trata de Android. Por alguma razão, as pessoas tentam dobrar seu desenvolvimento Android para paradigmas pré-concebidos ou comportamentos aprendidos.

O Android tem seu próprio paradigma e um certo padrão que é realmente consistente se deixar de lado suas noções pré-concebidas e simplesmente ler a documentação e o guia de desenvolvimento. Meu ponto real, no entanto, embora “conseguir o contexto certo” às vezes possa ser complicado, as pessoas entram em pânico injustificadamente porque se deparam com uma situação em que precisam do contexto e acham que não o têm. Mais uma vez, o Java é uma linguagem orientada a objetos com um design de herança.

Você só "tem" o contexto dentro de sua Atividade porque sua atividade em si herda de Contexto. Não há mágica para isso (exceto para todas as coisas que o sistema operacional faz sozinho para definir vários parâmetros e para “configurar” corretamente seu contexto). Portanto, deixando de lado os problemas de memória / desempenho (por exemplo, mantendo referências ao contexto quando você não precisa ou fazendo isso de uma maneira que tenha consequências negativas na memória, etc.), o Context é um objeto como qualquer outro e pode ser transmitido assim como qualquer POJO (Plain Old Java Object). Às vezes você pode precisar fazer coisas inteligentes para recuperar esse contexto, mas qualquer classe Java regular que se estenda a partir de nada diferente de Object pode ser escrita de uma maneira que tenha acesso ao contexto; Exponha simplesmente um método público que use um contexto e use-o nessa classe, conforme necessário. Isso não foi planejado como um tratamento exaustivo para os internos do Context ou do Android, mas espero que seja útil para desmistificar o Contexto um pouco.


Context é uma "interface" para as informações globais sobre um ambiente de aplicativo. Na prática, o Context é na verdade uma classe abstrata , cuja implementação é fornecida pelo sistema Android.

Ele permite o acesso a recursos e classes específicos do aplicativo, bem como chamadas para operações em nível de aplicativo, como atividades de lançamento, intenções de transmissão e recebimento, etc.

Na figura a seguir, você pode ver uma hierarquia de classes, onde Context é a classe raiz dessa hierarquia. Em particular, vale a pena enfatizar que Activity é um descendente de Context .


Contextsignifica componente (ou aplicação) em vários períodos de tempo. Se eu comer tantos alimentos entre 1 e 2 da tarde, meu contexto dessa hora será usado para acessar todos os métodos (ou recursos) usados ​​durante esse período. O conteúdo é um componente (aplicativo) para um determinado momento. Contextdos componentes do aplicativo continua mudando com base no ciclo de vida subjacente dos componentes ou aplicativos. Por exemplo, dentro do onCreate () de um Activity,

getBaseContext()- dá o contextdo Activityque está setado (criado) pelo construtor de atividade. getApplicationContext()- fornece a Contextconfiguração (criada) durante a criação da aplicação.

Nota: <application>detém todos os componentes do Android.

<application>
    <activity> .. </activity> 

    <service>  .. </service>

    <receiver> .. </receiver>

    <provider> .. </provider>
</application> 

Isso significa que, quando você chama getApplicationContext()de dentro de qualquer componente, você está chamando o contexto comum de todo o aplicativo.

Context continua sendo modificado pelo sistema com base no ciclo de vida dos componentes.


Contexto é uma interface para informações globais sobre um ambiente de aplicativo. É uma classe abstrata cuja implementação é fornecida pelo sistema Android .

Context permite o acesso a recursos e classes específicos do aplicativo, bem como chamadas para operações em nível de aplicativo, como launching activities, broadcasting and receiving intents, etc.

Aqui está um exemplo

 public class MyActivity extends Activity {

      public void Testing() {

      Context actContext = this; /*returns the Activity Context since   Activity extends Context.*/

      Context appContext = getApplicationContext();    /*returns the context of the single, global Application object of the current process. */

      Button BtnShowAct1 = (Button) findViewById(R.id.btnGoToAct1);
      Context BtnContext = BtnShowAct1.getContext();   /*returns the context of the View. */

Para mais detalhes, acesse Context


Em Java, dizemos que esta palavra - chave se refere ao estado do objeto atual do aplicativo.
Da mesma forma, em um suplente, temos Contextno Android Development.

Isso pode ser definido de forma explícita ou implícita,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Esse atributo declara com qual atividade esse layout está associado por padrão .


  • Context representa um identificador para obter dados do ambiente.
  • Context classe de Context é declarada como abstrata, cuja implementação é fornecida pelo sistema operacional Android.
  • Context é como controle remoto de uma TV e canal na televisão são recursos, serviços, etc.

O que você pode fazer com isso?

  • Carregando recurso.
  • Lançando uma nova atividade.
  • Criando exibições.
  • Obtendo o serviço do sistema.

Formas de obter contexto:

  • getApplicationContext()
  • getContext()
  • getBaseContext()




android-context