mainactivity - understand android context




Che cos'è "Contesto" su Android? (20)

Boss Assistant Analogy

Lasciamo una piccola analogia prima di immergerci in profondità nella tecnicità di Context

Ogni boss ha un assistente o qualcuno (fattorino) che fa cose meno importanti e che richiedono più tempo per lui. Ad esempio, se hanno bisogno di un file o di un caffè, un assistente sarà di corsa. Boss non saprà cosa sta succedendo in background ma il file o l'attività saranno consegnati

Ecco
Boss - Applicazione Android
Assistente - Contesto
File o tazza di caffè - Risorsa

Che sito ufficiale di sviluppatori Android dice di Context

Il contesto è il punto di accesso per le risorse relative alle applicazioni

Vediamo alcune di tali risorse o attività

  • Avvio di un'attività.

  • Ottenere il percorso assoluto per la directory della cache specifica dell'applicazione sul filesystem.

  • Determinare se l'autorizzazione concessa è consentita per un particolare processo e ID utente in esecuzione nel sistema.

  • Verifica se ti è stata concessa una particolare autorizzazione.

E così via.
Quindi, se un'applicazione Android vuole avviare un'attività, passa direttamente a Context (Access Point), e la classe Context gli restituisce le risorse (In questo caso, Intent).

Come ogni altra classe, anche la classe Context ha campi e metodi.
Puoi esplorare di più su Context nella documentazione ufficiale, copre praticamente tutto, metodi disponibili, campi e persino come utilizzare i campi con i metodi.

https://code.i-harness.com

Nella programmazione Android, cos'è esattamente una classe Context e a cosa serve?

L'ho letto sul sito degli sviluppatori , ma non riesco a capirlo chiaramente.


Definizione del contesto

  • Il contesto rappresenta i dati dell'ambiente
  • Fornisce l'accesso a cose come i database

Termini più semplici (esempio 1)

  • Considera Person-X è il CEO di una società di software di start-up.

  • Nell'azienda è presente un architetto di punta, questo lead architect svolge tutto il lavoro in azienda che comprende database, interfaccia utente, ecc.

  • Ora il CEO assume un nuovo sviluppatore.

  • È l'Architetto che racconta la responsabilità della persona appena assunta in base alle capacità della nuova persona che se lavorerà al Database o all'interfaccia utente ecc.

Termini più semplici (esempio 2)

  • È come l'accesso all'attività di Android alla risorsa dell'app.

  • È simile a quando si visita un hotel, si desidera colazione, pranzo e cena nei tempi adeguati, giusto?

  • Ci sono molte altre cose che ti piacciono durante il soggiorno. Come ottieni queste cose?

  • Chiedi alla persona del servizio in camera di portare queste cose per te.

  • Qui la persona del servizio in camera è il contesto che considera la singola attività e l'hotel come app, infine la colazione, il pranzo e la cena devono essere le risorse.

Le cose che coinvolgono il contesto sono:

  1. Caricamento di una risorsa.
  2. Avvio di una nuova attività.
  3. Creazione di viste.
  4. ottenere il servizio di sistema.

Il contesto è la classe base per Attività , Servizio , Applicazione , ecc

Un altro modo per descriverlo: Considerare il contesto come remoto di una TV e canali nella televisione sono risorse, servizi, utilizzo di intenti ecc. - - - Qui il telecomando funge da accesso per ottenere l'accesso a tutte le diverse risorse in primo piano.

  • Quindi, Remote ha accesso a canali come risorse, servizi, utilizzo di intenti, ecc ....

  • Allo stesso modo ... Chiunque abbia accesso al remoto ha naturalmente accesso a tutte le cose come risorse, servizi, utilizzo di intenti ecc

Diversi metodi con cui è possibile ottenere il contesto

  • getApplicationContext()
  • getContext()
  • getBaseContext()
  • o this (quando nella classe di attività)

Esempio:

TextView TV=new TextView(this);

this -> si riferisce al contesto dell'attività corrente.


Consideralo come la VM che ha disattivato il processo in cui l'app o il servizio è in esecuzione. L'ambiente silente ha accesso a una serie di informazioni di sistema sottostanti e ad alcune risorse consentite. Hai bisogno di quel contesto per ottenere quei servizi.


Contesto è un riferimento all'oggetto corrente come questo. Anche il contesto consente l'accesso alle informazioni sull'ambiente dell'applicazione.


Il contesto è Istanze della classe android.content.Context fornisce la connessione al sistema Android che esegue l'applicazione. Ad esempio, è possibile controllare le dimensioni della visualizzazione corrente del dispositivo tramite il contesto.

Dà inoltre accesso alle risorse del progetto. È l'interfaccia per le informazioni globali sull'ambiente dell'applicazione.

La classe Context fornisce anche l'accesso ai servizi Android, ad esempio il gestore degli allarmi per attivare eventi basati sul tempo.

Attività e servizi estendono la classe Context. Pertanto possono essere utilizzati direttamente per accedere al contesto.


Il contesto è fondamentalmente per l'accesso alle risorse e ottenere i dettagli dell'ambiente dell'applicazione (per il contesto dell'applicazione) o dell'attività (per il contesto di attività) o qualsiasi altro ...

Per evitare perdite di memoria, dovresti utilizzare il contesto dell'applicazione per ogni componente che necessita di un oggetto di contesto .... per ulteriori informazioni clicca here


Interfaccia con informazioni globali su un ambiente applicativo. Questa è una classe astratta la cui implementazione è fornita dal sistema Android. Permette l'accesso a risorse e classi specifiche dell'applicazione, nonché up-call per operazioni a livello di applicazione come attività di lancio, trasmissione e ricezione di intenti, ecc.


La classe android.content.Context fornisce la connessione al sistema Android e le risorse del progetto. È l'interfaccia per le informazioni globali sull'ambiente dell'applicazione.

Il contesto fornisce anche l'accesso ai servizi Android, ad esempio il servizio di localizzazione.

Attività e servizi estendono la classe Context .


Mettendo semplice, Androids Context è un disastro che non amerai finché non ti fermerai a preoccuparti.

I Context Android sono:

  • Dio-oggetti.

  • Cosa vuoi che passi intorno a tutte le tue applicazioni quando inizi a sviluppare per Android, ma eviterai di farlo quando ti avvicini un po 'alla programmazione, al testing e ad Android stesso.

    • Dipendenza non chiara

    • Fonte comune di perdite di memoria.

    • PITA per i test.

  • Contesto effettivo utilizzato dal sistema Android per inviare autorizzazioni, risorse, preferenze, servizi, trasmissioni, stili, visualizzazione di finestre di dialogo e layout di gonfiaggio. E hai bisogno di diverse istanze di Context per alcune cose separate (ovviamente, non puoi mostrare una finestra di dialogo da un contesto di applicazione o servizio; i layout gonfiati dai contesti di applicazioni e attività possono essere diversi).


Mettiamola semplicemente:

Come suggerisce il nome, è il contesto dello stato corrente dell'applicazione / oggetto. Permette agli oggetti appena creati di capire cosa sta succedendo. Normalmente lo chiami per ottenere informazioni su un'altra parte del tuo programma (attività e pacchetto / applicazione).

È possibile ottenere il contesto richiamando getApplicationContext() , getContext() , getBaseContext() o this (quando in una classe che si estende da Context , come le classi Application, Activity, Service e IntentService).

Usi tipici del contesto:

  • Creazione di nuovi oggetti : creazione di nuove viste, adattatori, ascoltatori:

    TextView tv = new TextView(getContext());
    ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
    
  • Accesso alle risorse comuni standard : servizi come LAYOUT_INFLATER_SERVICE, SharedPreferences:

    context.getSystemService(LAYOUT_INFLATER_SERVICE)
    getApplicationContext().getSharedPreferences(*name*, *mode*);
    
  • Accesso implicito ai componenti : per quanto riguarda i fornitori di contenuti, le trasmissioni, l'intento

    getApplicationContext().getContentResolver().query(uri, ...);
    

Semplice esempio per capire il context in Android:

Ogni capo ha un assistente da seguire, per svolgere tutte le attività meno importanti e dispendiose in termini di tempo. Se è necessario un file o una tazza di caffè, l'assistente è in fuga. Alcuni capi sanno a malapena cosa sta succedendo in ufficio, così chiedono ai loro assistenti anche questo. Fanno un po 'di lavoro da soli, ma per la maggior parte delle altre cose hanno bisogno dell'aiuto dei loro assistenti.

In questo scenario,

Boss - è l'applicazione Android

Assistente - è contesto

File / tazza di caffè - sono risorse

Generalmente chiamiamo contesto quando abbiamo bisogno di ottenere informazioni su diverse parti della nostra applicazione come Attività, Applicazioni, ecc.

Alcune operazioni (cose in cui è necessario l'assistente) in cui è coinvolto il contesto:

Caricamento di risorse comuni Creazione di viste dinamiche Visualizzazione di messaggi Toast Lancio di attività ecc. Diversi modi di ottenere il contesto:

getContext()

getBaseContext()

getApplicationContext()

this

Un Context Android è un'interfaccia (in senso generale, non in senso Java, in Java, Context è in realtà una classe astratta!) Che consente l'accesso a risorse specifiche dell'applicazione e classe e informazioni sull'ambiente dell'applicazione.

Se la tua app per Android era un'app Web, il tuo contesto sarebbe simile a ServletContext (non sto facendo un confronto esatto qui).

Le tue attività e i tuoi servizi estendono anche il Context , quindi ereditano tutti quei metodi per accedere alle informazioni sull'ambiente in cui è in esecuzione l'app.


Un contesto è un handle per il sistema; fornisce servizi come la risoluzione delle risorse, l'accesso ai database e alle preferenze e così via. Un'app per Android ha attività. Il contesto è come un handle per l'ambiente in cui è attualmente in esecuzione l'applicazione. L'oggetto activity eredita l'oggetto Context.

Per ulteriori informazioni, guarda in Introduzione allo sviluppo Android con Android Studio - Tutorial .


Source

L'argomento del contesto in Android sembra essere fonte di confusione per molti. Le persone sanno solo che il contesto è necessario abbastanza spesso per fare cose di base in Android. A volte le persone si fanno prendere dal panico perché cercano di eseguire alcune operazioni che richiedono il contesto e non sanno come "ottenere" il giusto contesto. Ho intenzione di provare a demistificare l'idea di Context in Android. Un trattamento completo del problema va oltre lo scopo di questo post, ma cercherò di dare una panoramica generale in modo da avere un'idea di cosa sia il contesto e come usarlo. Per capire cos'è il contesto, diamo un'occhiata al codice sorgente:

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

Cos'è esattamente Context?

Bene, la documentazione stessa fornisce una spiegazione piuttosto semplice: la classe Context è una "Interfaccia alle informazioni globali su un ambiente applicativo".

La classe Context stessa è dichiarata come classe astratta, la cui implementazione è fornita dal sistema operativo Android. La documentazione fornisce inoltre che Context "... consente l'accesso a risorse e classi specifiche dell'applicazione, nonché up-call per operazioni a livello di applicazione come attività di lancio, trasmissione e ricezione di intenti, ecc.".

Puoi capire molto bene, ora, perché il nome è Context. È perché è solo quello. Il contesto fornisce il collegamento o l'hook, se lo si desidera, per un'attività, un servizio o qualsiasi altro componente, quindi collegandolo al sistema, consentendo l'accesso all'ambiente dell'applicazione globale. In altre parole: il contesto fornisce la risposta alla domanda sui componenti di "dove diavolo sono in relazione all'app in generale e in che modo posso accedere / comunicare con il resto dell'app?" Se tutto ciò sembra un po 'confuso, un rapido guarda i metodi esposti dalla classe Context fornisce ulteriori indizi sulla sua vera natura.

Ecco un campionamento casuale di questi metodi:

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

Cosa hanno in comune tutti questi metodi? Tutti consentono a chiunque abbia accesso al contesto di poter accedere a risorse a livello di applicazione.

Il contesto, in altre parole, aggancia il componente che ha un riferimento ad esso nel resto dell'ambiente dell'applicazione. Le risorse (si consideri la cartella '/ assets' nel progetto), ad esempio, sono disponibili in tutta l'applicazione, a condizione che un'attività, un servizio o qualsiasi altro sappia come accedere a tali risorse. Lo stesso vale per getResources() che permette di fare cose come getResources().getColor() che ti colors.xml risorsa colors.xml (non colors.xml consente l'accesso alle risorse tramite il codice java, questo è un problema separato).

Il risultato è che Context è ciò che abilita l'accesso alle risorse di sistema e il suo ciò che aggancia i componenti alla "app più grande". Diamo un'occhiata alle sottoclassi di Context , le classi che forniscono l'implementazione della classe Context astratta. Classe di Activity Activity eredita da ContextThemeWrapper , che eredita da ContextWrapper , che eredita dal Context ContextThemeWrapper classi sono utili per capire le cose a un livello più profondo, ma per ora è sufficiente sapere che ContextThemeWrapper e ContextWrapper sono più o meno ciò che come implementano gli elementi astratti della classe Context "avvolgendo" un contesto (il contesto reale) e delegando tali funzioni a quel contesto.Un esempio è utile: nella classe ContextWrapper , il metodo astratto getAssets dalla classe Context è implementato come segue:

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

mBase è semplicemente un campo impostato dal costruttore in un contesto specifico. Quindi, un contesto viene spostato e ContextWrapper delega la sua implementazione del metodo getAssets a quel contesto. Torniamo ad esaminare la classe di Activity che eredita definitivamente dal Context per vedere come funziona tutto questo.

Probabilmente sai cos'è un'attività, ma per fare una recensione - è fondamentalmente "una singola cosa che l'utente può fare. Si occupa di fornire una finestra in cui posizionare l'interfaccia utente con cui l'utente interagisce ". Gli sviluppatori che hanno familiarità con altre API e persino con i non sviluppatori potrebbero pensarla vernacolarmente come uno "schermo". Questo è tecnicamente inaccurato, ma non importa ai nostri scopi. Quindi, come interagiscono Activity e Context e cosa sta succedendo esattamente nella loro relazione di ereditarietà?

Ancora una volta, è utile guardare esempi specifici. Sappiamo tutti come avviare Attività. A condizione che tu abbia "il contesto" da cui stai iniziando l'attività, chiami semplicemente startActivity(intent) , dove l'Intent descrive il contesto da cui stai avviando un'attività e l'attività che desideri avviare. Questa è la familiare startActivity(this, SomeOtherActivity.class) .

E cos'è this ? this è la tua attività perché la classe Activity eredita dal Context . Lo scoop completo è come questo: quando chiami startActivity , in definitiva la classe Activity esegue qualcosa del genere:

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

Quindi utilizza execStartActivity dalla classe Instrumentation (in realtà da una classe interna in Instrumentation denominata ActivityResult ).

A questo punto, stiamo iniziando a dare un'occhiata agli interni del sistema.

Questo è dove il sistema operativo in realtà gestisce tutto. Quindi, come fa la strumentazione ad avviare l'attività esattamente? Bene, il parametro this nel metodo execStartActivity sopra è la tua attività, cioè il contesto, e execStartActivity fa uso di questo contesto.

Una panoramica di 30.000 è questa: la classe Instrumentation tiene traccia di un elenco di Attività che sta monitorando per fare il suo lavoro. Questo elenco viene utilizzato per coordinare tutte le attività e assicurarsi che tutto funzioni senza intoppi nella gestione del flusso di attività.

Ci sono alcune operazioni che non ho completamente esaminato in quale thread di coordinate e problemi di processo. In definitiva, ActivityResult utilizza un'operazione nativa - ActivityManagerNative.getDefault().startActivity() che utilizza il Context passato quando hai chiamato startActivity . Il contesto che hai passato è usato per aiutare nella "risoluzione dell'intento", se necessario. La risoluzione intenzionale è il processo mediante il quale il sistema può determinare l'obiettivo dell'intento se non viene fornito. (Controlla qui la guida per maggiori dettagli).

E per fare in modo che Android lo faccia, ha bisogno di accedere alle informazioni fornite da Context . Nello specifico, il sistema deve accedere a ContentResolver modo che possa "determinare il tipo MIME dei dati dell'intento" .Questo po 'su come startActivity fa uso del contesto era un po' complicato e non capisco perfettamente l'interno. il punto principale era solo per illustrare come è necessario accedere alle risorse a livello di applicazione per eseguire molte delle operazioni essenziali per un'app. Il Context è ciò che fornisce l'accesso a queste risorse. Un esempio più semplice potrebbe essere Views. si crea una vista personalizzata estendendo RelativeLayout o qualche altra classe View , è necessario fornire un costruttore che accetta un argomento come argomento Quando si crea un'istanza della vista personalizzata che si passa nel contesto Perché? Perché la vista deve essere in grado di avere accesso a temi, risorse e altri dettagli di configurazione della vista La configurazione della vista è in realtà un ottimo esempio: ogni contesto ha vari parametri (campi nelle implementazioni di Context ) impostati dal sistema operativo stesso per cose come la dimensione o la densità del display. È facile capire perché questa informazione è importante per l'impostazione di Visualizzazioni, ecc.

Un'ultima parola: per qualche ragione le persone nuove ad Android (e anche le persone non così nuove) sembrano completamente dimenticarsi della programmazione orientata agli oggetti quando si tratta di Android. Per qualche ragione, le persone cercano di piegare il loro sviluppo Android a paradigmi pre-concepiti o comportamenti appresi.

Android ha il suo paradigma e un certo schema che è in realtà abbastanza coerente se lascia andare le tue nozioni pre-concepite e leggi semplicemente la documentazione e la guida di sviluppo. Il mio vero punto, tuttavia, mentre "ottenere il contesto giusto" a volte può essere complicato, le persone in preda al panico in modo ingiustificato perché si imbattono in una situazione in cui hanno bisogno del contesto e pensano di non averlo. Ancora una volta, Java è un linguaggio orientato agli oggetti con un progetto di ereditarietà.

Hai "solo" il contesto all'interno della tua attività perché la tua attività eredita dal contesto. Non c'è magia ad esso (tranne per tutte le cose che il sistema operativo fa da sé per impostare vari parametri e per "configurare" correttamente il contesto). Quindi, mettendo da parte i problemi di memoria / prestazioni (es. Tenendo riferimenti al contesto quando non ne hai bisogno o facendolo in un modo che ha conseguenze negative sulla memoria, ecc.), Context è un oggetto come un altro e può essere passato in giro proprio come qualsiasi POJO (Plain Old Java Object). A volte potrebbe essere necessario fare cose intelligenti per recuperare quel contesto, ma qualsiasi classe Java standard che si estende da nient'altro che Object stesso può essere scritta in un modo che abbia accesso al contesto; semplicemente esporre un metodo pubblico che prende un contesto e poi lo usa in quella classe, se necessario. Questo non era inteso come un trattamento esaustivo su Context o Android internals, ma spero che sia utile per demistificare un po 'il contesto.


Contextsignifica componente (o applicazione) in vari periodi di tempo. Se mangio così tanto cibo tra l'1 e le 2 del pomeriggio, il mio contesto di quel tempo viene usato per accedere a tutti i metodi (o risorse) che uso in quel periodo. Il contenuto è un componente (applicazione) per un particolare momento. Contextdei componenti dell'applicazione continua a cambiare in base al ciclo di vita sottostante dei componenti o dell'applicazione. Ad esempio, all'interno di onCreate () di a Activity,

getBaseContext()- dà il contextdi Activityciò che è impostato (creato) dal costruttore di attività. getApplicationContext()- fornisce il Contextsetup (creato) durante la creazione dell'applicazione.

Nota: <application>contiene tutti i componenti Android.

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

Significa che quando chiamate getApplicationContext()da qualsiasi componente, chiamate il contesto comune dell'intera applicazione.

Context continua a essere modificato dal sistema in base al ciclo di vita dei componenti.


Contextsignifica corrente. Contextutilizzare per fare operazione per la schermata corrente. ex.
1. getApplicationContext ()
2. getContext ()

Toast.makeText(getApplicationContext(), "hello", Toast.LENGTH_SHORT).show();

Il contesto è un'interfaccia per le informazioni globali su un ambiente applicativo. È una classe astratta la cui implementazione è fornita dal sistema Android .

Context consente l'accesso a risorse e classi specifiche dell'applicazione, nonché chiamate per operazioni a livello di applicazione come launching activities, broadcasting and receiving intents, etc.

Ecco un esempio

 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. */

Per maggiori dettagli è possibile visitare Context


È una classe astratta la cui implementazione è fornita dal sistema Android. Il contesto consente l'accesso a risorse e classi specifiche dell'applicazione, nonché chiamate per operazioni a livello di applicazione come attività di lancio, trasmissione e ricezione di intenti, ecc.


Il contesto è l'API specifica di Android per ogni Sandbox dell'app che fornisce dati privati ​​delle app di accesso come risorse, database, filedirectories privati, preferenze, impostazioni ...

La maggior parte dei privatedata è la stessa per tutte le attività / servizi / elenchi di trasmissione di un'applicazione.

Poiché Application, Activity, Service implementano l'interfaccia Context possono essere utilizzati dove una chiamata API richiede un parametro Context


Questo attributo dichiara a quale attività questo layout è associato per impostazione predefinita .







android-context