Nella programmazione Android, che cos'è esattamente una Contextclasse ea cosa serve?
Ne ho letto sul sito dello sviluppatore , ma non riesco a capirlo chiaramente.
Risposte:
Per dirla semplicemente:
Come suggerisce il nome, è il contesto dello stato corrente dell'applicazione / oggetto. Permette agli oggetti appena creati di capire cosa sta succedendo. In genere lo si chiama per ottenere informazioni su un'altra parte del programma (attività e pacchetto / applicazione).
È possibile ottenere il contesto invocando getApplicationContext(), getContext(), getBaseContext()o this(quando in una classe che si estende da Context, ad esempio l'applicazione, Attività, classi di servizio e IntentService).
Usi tipici del contesto:
Creazione di nuovi oggetti : Creazione di nuove viste, adattatori, listener:
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 : informazioni su provider di contenuti, trasmissioni, intenti
getApplicationContext().getContentResolver().query(uri, ...);context.getSystemService(LAYOUT_INFLATER_SERVICE), dove e come viene contextdefinito?
Considerare Person-X è il CEO di una società di software start-up.
C'è un architetto capo presente nell'azienda, questo architetto capo fa tutto il lavoro che coinvolge come database, interfaccia utente ecc.
Ora il CEO assume un nuovo sviluppatore.
È l'architetto che racconta la responsabilità della persona appena assunta in base alle competenze della persona nuova che se lavorerà su database o UI ecc.
È come l'accesso dell'attività Android alla risorsa dell'app.
È simile a quando visiti un hotel, vuoi colazione, pranzo e cena negli orari adeguati, giusto?
Ci sono molte altre cose che ti piacciono durante il soggiorno. Come ottieni queste cose?
Chiedi al tecnico del servizio in camera di portare queste cose per te.
Qui la persona del servizio in camera è il contesto considerando che sei l'unica attività e l'hotel ad essere la tua app, infine la colazione, il pranzo e la cena devono essere le risorse.
Le cose che coinvolgono il contesto sono:
Un altro modo per descriverlo: considerare il contesto come remoto di una TV e dei canali televisivi sono risorse, servizi, 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, usando intenti ecc ....
Allo stesso modo ... Chiunque abbia accesso al telecomando 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()this(quando nella classe di attività)Esempio:
TextView tv = new TextView(this);La parola chiave si thisriferisce al contesto dell'attività corrente.
getApplicationContext(), getContext(), getBaseContext()....., consultare questo -> ( stackoverflow.com/a/10641257 )
SomeActivityName.this. IN una discussione per un'istanza, si thisriferisce alla discussione e non all'attività
L'argomento del contesto in Android sembra confondere molti. Le persone sanno solo che il contesto è necessario abbastanza spesso per fare le cose di base in Android. Le persone a volte vanno nel panico perché provano a fare alcune operazioni che richiedono il contesto e non sanno come "ottenere" il contesto giusto. Proverò a demistificare l'idea di Context in Android. Un trattamento completo del problema va oltre lo scopo di questo post, ma proverò a fornire una panoramica generale in modo da avere un'idea di cosa sia il contesto e come utilizzarlo. Per capire cos'è il contesto, diamo un'occhiata al codice sorgente:
Che cos'è esattamente il contesto?
Bene, la documentazione stessa fornisce una spiegazione piuttosto semplice: la classe Context è una "Interfaccia con informazioni globali su un ambiente applicativo".
La stessa classe Context viene dichiarata come classe astratta, la cui implementazione è fornita dal sistema operativo Android. La documentazione prevede inoltre che il contesto "... consente l'accesso a risorse e classi specifiche dell'applicazione, nonché inviti a operazioni a livello di applicazione come l'avvio di attività, la trasmissione e la ricezione di intenti, ecc.".
Ora puoi capire molto bene perché il nome è Context. È perché è proprio questo. Il contesto fornisce il collegamento o hook, se lo si desidera, per un'attività, un servizio o qualsiasi altro componente, collegandolo in tal modo al sistema, consentendo l'accesso all'ambiente di 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 come posso accedere / comunicare con il resto dell'app?" Se tutto ciò sembra un po 'confuso, una rapida occhiata ai metodi esposti dalla classe Context fornisce ulteriori indizi sulla sua vera natura.
Ecco un campionamento casuale di questi metodi:
getAssets() getResources()getPackageManager()getString()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 al resto dell'ambiente dell'applicazione. Le risorse (pensa alla cartella "/ assets" nel tuo progetto), ad esempio, sono disponibili in tutta l'applicazione, a condizione che un'attività, un servizio o qualunque cosa sappia accedere a tali risorse. Lo stesso vale per il getResources()quale consente di fare cose del genere getResources().getColor()che ti agganceranno alla colors.xmlrisorsa (non importa che aapt abiliti l'accesso alle risorse tramite il codice Java, questo è un problema separato).
Il risultato è che Contextè ciò che consente l'accesso alle risorse di sistema e ciò che aggancia i componenti alla "maggiore app". Diamo un'occhiata alle sottoclassi delle Contextclassi che forniscono l'implementazione della Contextclasse astratta . La classe più ovvia è la Activityclasse. ActivityEredita da ContextThemeWrapper, che eredita da ContextWrapper, che eredita da Contextse stesso. Queste classi sono utili per guardare per capire le cose a un livello più profondo, ma per ora è sufficiente saperlo ContextThemeWrappere ContextWrappersono praticamente ciò che sembrano. Implementano gli elementi astratti del Contextclassificarsi "avvolgendo" un contesto (il contesto reale) e delegando tali funzioni a quel contesto. Un esempio è utile - nelContextWrapperclasse, il metodo astratto getAssetsdalla Contextclasse viene 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 i ContextWrapperdelegati della relativa implementazione del metodo getAssets in quel contesto. Torniamo a esaminare la Activityclasse che alla fine eredita Contextper vedere come funziona tutto questo.
Probabilmente sai cos'è un'attività, ma per rivederla - fondamentalmente è 'una sola 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 dimestichezza con altre API e persino i non sviluppatori potrebbero pensarlo in modo volgare come uno "schermo". È tecnicamente inaccurato, ma non importa per i nostri scopi. Quindi, come fare Activitye Contextinteragiscono e che cosa esattamente sta succedendo nella loro relazione di ereditarietà?
Ancora una volta, è utile guardare esempi specifici. Sappiamo tutti come avviare le attività. A condizione che tu abbia "il contesto" da cui stai iniziando l'attività, chiami semplicemente startActivity(intent), dove l'intento descrive il contesto da cui stai iniziando un'attività e l'attività che desideri iniziare. Questo è il familiare startActivity(this, SomeOtherActivity.class).
E cos'è this? thisè la tua attività perché la Activityclasse eredita da Context. Lo scoop completo è così: quando chiami startActivity, alla fine la Activityclasse esegue qualcosa del genere:
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);Quindi utilizza il execStartActivitydalla Instrumentationclasse (in realtà da una classe interna in Instrumentationchiamata ActivityResult).
A questo punto, stiamo iniziando a dare una sbirciatina agli interni del sistema.
Qui è dove il sistema operativo gestisce effettivamente tutto. Quindi, in che modo la strumentazione avvia esattamente l'attività? Bene, il parametro thisnel execStartActivitymetodo sopra è la tua attività, cioè il contesto, e execStartActivityfa uso di questo contesto.
Una panoramica di 30.000 è questa: la classe di Strumentazione 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 esaminato a fondo in cui coordinare i problemi e elaborare i problemi. Alla fine, ActivityResultusa un'operazione nativa - ActivityManagerNative.getDefault().startActivity()che usa quella Contextche hai passato quando hai chiamato startActivity. Il contesto in cui è passato viene utilizzato per aiutare nella "risoluzione di intenti", se necessario. La risoluzione dell'intento è il processo mediante il quale il sistema può determinare la destinazione dell'intento se non viene fornita. (Consulta la guida qui per maggiori dettagli).
E affinché Android possa fare ciò, deve accedere alle informazioni fornite da Context. In particolare, il sistema deve accedere a un ContentResolvermodo per poter "determinare il tipo MIME dei dati dell'intento". Tutto questo su come startActivityutilizzare il contesto è stato un po 'complicato e non capisco da solo gli interni. Il mio punto principale era solo per illustrare come accedere alle risorse a livello di applicazione per eseguire molte delle operazioni essenziali per un'app. Contextè ciò che fornisce l'accesso a queste risorse. Un esempio più semplice potrebbe essere Views. Sappiamo tutti cosa si crea un visualizzazione personalizzata estendendo RelativeLayouto un'altra Viewclasse, è necessario fornire un costruttore che accetta aContextcome argomento. Quando si crea un'istanza della visualizzazione personalizzata, si passa nel contesto. Perché? Perché la vista deve poter accedere a temi, risorse e altri dettagli di configurazione della vista. Visualizza configurazione è in realtà un ottimo esempio. Ogni contesto ha vari parametri (campi nelle Contextimplementazioni) che sono impostati dal sistema operativo stesso per cose come la dimensione o la densità del display. È facile capire perché queste informazioni sono importanti per l'impostazione di Visualizzazioni, ecc.
Un'ultima parola: per qualche ragione le persone che non conoscono Android (e anche quelle non così nuove) sembrano dimenticare completamente la programmazione orientata agli oggetti quando si tratta di Android. Per qualche ragione, le persone cercano di piegare il proprio sviluppo Android a paradigmi preconcetti o comportamenti appresi.
Android ha il suo paradigma e un certo modello che è in realtà abbastanza coerente se lasci andare le tue nozioni preconcette e leggi semplicemente la documentazione e la guida agli sviluppatori. Il mio vero punto, tuttavia, mentre "ottenere il giusto contesto" a volte può essere complicato, le persone si fanno prendere dal panico ingiustificatamente 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 design ereditario.
"Hai" solo il contesto all'interno della tua attività perché la tua stessa attività eredita dal contesto. Non c'è magia ad esso (tranne per tutte le cose che il sistema operativo fa da solo per impostare vari parametri e "configurare" correttamente il tuo contesto). Quindi, mettendo da parte i problemi di memoria / prestazioni (ad es. Trattenere riferimenti al contesto quando non è necessario o farlo in un modo che ha conseguenze negative sulla memoria, ecc.), Il contesto è 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 normale classe Java che si estende da nient'altro che l'Oggetto stesso può essere scritta in un modo che abbia accesso al contesto; esporre semplicemente un metodo pubblico che prende un contesto e quindi usarlo in quella classe secondo necessità.
Un contesto è un handle per il sistema; fornisce servizi come la risoluzione di risorse, l'accesso a database e preferenze e così via. Un'app per Android ha attività. Il contesto è come un handle per l'ambiente in cui l'applicazione è attualmente in esecuzione. L'oggetto attività eredita l'oggetto Contesto.
Per ulteriori informazioni, consulta Introduzione allo sviluppo di Android con Android Studio - Tutorial .
Contextè una "interfaccia" per le informazioni globali su un ambiente applicativo. In pratica, Contextè in realtà 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 l'avvio di attività, la trasmissione e la ricezione di intenti, ecc.
Nell'immagine seguente, puoi vedere una gerarchia di classi, dove si Contexttrova la classe radice di questa gerarchia. In particolare, vale la pena sottolineare che Activityè un discendente diContext .
Che cosa è Contextesattamente?
Secondo la documentazione di riferimento di Android, è un'entità che rappresenta vari dati ambientali. Fornisce accesso a file locali, database, caricatori di classi associati all'ambiente, servizi (inclusi servizi a livello di sistema) e altro. Nel corso di questo libro e nella tua codifica quotidiana con Android, vedrai il contesto passare di frequente.
Dal libro " Android in Practice ", p. 60.
Diverse API Android richiedono un Contextparametro as
Se guardi attraverso le varie API Android, noterai che molti di loro accettano un android.content.Contextoggetto come parametro. Vedrai anche che un'attività o un servizio viene generalmente utilizzato come
Context. Questo funziona perché entrambe queste classi si estendono da Context.
Semplice esempio da capire contextin Android:
Ogni capo ha un assistente di cui occuparsi, per svolgere tutte le attività meno importanti e che richiedono tempo. Se è necessario un file o una tazza di caffè, un assistente è in fuga. Alcuni capi a malapena sanno cosa sta succedendo in ufficio, quindi chiedono anche ai loro assistenti riguardo a questo. Lavorano 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:
Diversi modi per ottenere il contesto:
getContext()
getBaseContext()
getApplicationContext()
thisUn Android Context è un interfaccia (in senso generale, non nel senso di Java, in Java,Context è in realtà una classe astratta!) Che permette l'accesso a risorse specifiche di applicazione e di classe e informazioni su ambiente applicativo.
Se la tua app Android fosse un'app Web, il tuo contesto sarebbe simile a ServletContext (non sto facendo un confronto esatto qui).
Anche le tue attività e servizi si estendono Context, quindi ereditano tutti quei metodi per accedere alle informazioni sull'ambiente in cui l'app è in esecuzione.
Context rappresenta un handle per ottenere dati sull'ambiente.Context la classe stessa viene dichiarata astratta, la cui implementazione è fornita dal sistema operativo Android.Context è come il telecomando di una TV e i canali nella televisione sono risorse, servizi, ecc.
Cosa puoi farci?
Modi per ottenere il contesto:
getApplicationContext()getContext()getBaseContext()
Mettendolo lì solo per i neofiti;
Quindi prima comprendi il contesto di Word:
In inglese-lib. significa:
"Le circostanze che formano lo scenario per un evento, una dichiarazione o un'idea e in termini di cui può essere pienamente compreso e valutato."
"Le parti di qualcosa scritto o parlato che precedono e seguono immediatamente una parola o un passaggio e ne chiariscono il significato."
Ora porta la stessa comprensione al mondo della programmazione:
contesto dello stato corrente dell'applicazione / oggetto. Permette agli oggetti appena creati di capire cosa sta succedendo. In genere lo si chiama per ottenere informazioni su un'altra parte del programma (attività, pacchetto / applicazione)
È possibile ottenere il contesto invocando getApplicationContext(), getContext(), getBaseContext()o this(quando nella classe di attività).
Per ottenere un contesto ovunque nell'applicazione, utilizzare il seguente codice:
Crea una nuova classe AppContextnella tua applicazione 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;
}
}Ora, ogni volta che vuoi un contesto applicativo in una classe non di attività, chiama questo metodo e hai un contesto applicativo.
Spero che questo aiuto;)
La classe android.content.Contextfornisce 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 ampliano la Contextclasse.
Il contesto è Istanze della classe android.content.Context fornisce la connessione al sistema Android che esegue l'applicazione. Ad esempio, è possibile verificare le dimensioni della visualizzazione del dispositivo corrente tramite il contesto.
Dà anche accesso alle risorse del progetto. È l'interfaccia per le informazioni globali sull'ambiente dell'applicazione.
La classe Context fornisce inoltre 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 è un'interfaccia per le informazioni globali su un ambiente applicativo. È una classe astratta la cui implementazione è fornita dal Androidsistema.
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 puoi visitare http://developer.android.com/reference/android/content/Context.html
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 dell'attività) o qualsiasi altro ...
Per evitare perdite di memoria, è necessario utilizzare il contesto dell'applicazione per tutti i componenti che richiedono un oggetto di contesto .... per ulteriori informazioni, fare clic qui
Il contesto è il contesto dello stato corrente dell'applicazione / oggetto. È un'entità che rappresenta vari dati di ambiente. Il contesto aiuta l'attività corrente a interagire con l'ambiente Android esterno come file locali, database, caricatori di classi associati all'ambiente, servizi inclusi i servizi a livello di sistema e altro ancora.
Un contesto è un handle per il sistema. Fornisce servizi come la risoluzione di risorse, l'ottenimento di accesso a database e preferenze e così via. Un'app Android ha attività. È come un handle per l'ambiente in cui l'applicazione è attualmente in esecuzione. L'oggetto attività eredita l'oggetto Context.
Diversi metodi di invocazione tramite i quali è possibile ottenere il contesto 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. o questo (quando si è nella classe di attività).
Contesto significa che Android viene a sapere in quale attività devo andare o in cui agire.
1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show();
utilizzato in questo.
Context context = ActivityName.this;
2 -startActivity(new Intent(context,LoginActivity.class));
in questo contesto significa da quale attività vuoi andare ad altre attività. contesto o ActivityName.questo è più veloce, getContext e getApplicatinContext.
A Contextè ciò che la maggior parte di noi chiamerebbe Applicazione . È realizzato dal sistema Android ed è in grado di fare solo ciò che un'applicazione è in grado di fare. In Tomcat, un contesto è anche ciò che definirei un'applicazione.
C'è un contesto che contiene molte attività, ogni attività può avere molte viste.
Ovviamente, alcuni diranno che non si adatta a causa di questo o quello e probabilmente hanno ragione, ma dire che un contesto è la tua attuale applicazione ti aiuterà a capire cosa stai inserendo nei parametri del metodo.
Diamo una piccola analogia prima di immergerci nel tecnicismo del contesto
Ogni capo ha un assistente o qualcuno (fattorino) che fa cose meno importanti e che richiede più tempo per lui. Ad esempio, se hanno bisogno di un file o di un caffè, un assistente sarà in fuga. Boss non saprà cosa sta succedendo in background ma il file o l'attività verranno consegnati
So Here
Boss -
Assistente applicazione Android -
File di contesto o tazza di caffè - Risorsa
Il contesto è il punto di accesso per le risorse relative all'applicazione
Vediamo alcune di tali risorse o attività
Avvio di un'attività.
Ottenere il percorso assoluto per la directory cache specifica dell'applicazione sul filesystem.
Determinare se l'autorizzazione fornita è consentita per un determinato processo e ID utente in esecuzione nel sistema.
Verifica se ti è stata concessa un'autorizzazione particolare.
E così via.
Quindi, se un'applicazione Android vuole iniziare un'attività, va direttamente a Context(Access Point) e la Contextclasse gli restituisce le risorse (Intento in questo caso).
Come qualsiasi altra classe Context, anche la classe ha campi e metodi.
Puoi esplorare di più Contextnella documentazione ufficiale, copre praticamente tutto, i metodi disponibili, i campi e persino come usare i campi con i metodi.
Le istanze della classe android.content.Context forniscono la connessione al sistema Android che esegue l'applicazione. Ad esempio, è possibile verificare le dimensioni della visualizzazione del dispositivo corrente tramite il contesto.
Dà anche accesso alle risorse del progetto. È l'interfaccia per le informazioni globali sull'ambiente dell'applicazione.
La classe Context fornisce inoltre 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.
Se desideri connettere il contesto con altre classi familiari in Android, tieni presente questa struttura:
Contesto <ContextWrapper <Applicazione
Context <ContextWrapper <ContextThemeWrapper <Attività
Context <ContextWrapper <ContextThemeWrapper <Attività <ListActivity
Contesto <ContextWrapper <Servizio
Contesto <ContextWrapper <Servizio <IntentService
Quindi, tutte quelle classi sono contesti a modo loro. È possibile lanciare servizio e ListActivity al contesto , se lo si desidera. Ma se guardi da vicino, alcune delle classi ereditano anche il tema. Nell'attività o nel frammento, desideri che i temi vengano applicati alle tue viste, ma non ti interessa la classe di servizio , ad esempio.
Spiego qui la differenza nei contesti .
In parole povere, Androids Contextè un casino che non ti piacerà finché non smetti di preoccuparti.
Gli Android Contextsono:
Dio-oggetti.
Cosa che vuoi trasferire su tutta la tua applicazione quando inizi a sviluppare per Android, ma eviterai di farlo quando ti avvicini un po 'di più alla programmazione, ai test e allo stesso Android.
Dipendenza poco 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, mostrando finestre di dialogo e gonfiando il layout. E hai bisogno di Contextistanze diverse per alcune cose separate (ovviamente, non puoi mostrare una finestra di dialogo dal contesto di un'applicazione o di un servizio; i layout gonfiati dai contesti di applicazione e attività possono differire).
Il contesto è l'API specifica di Android per ciascuna sandbox di ogni app che fornisce l'accesso ai dati privati dell'app come risorse, database, directory di file private, preferenze, impostazioni ...
La maggior parte dei privatedata è la stessa per tutte le attività / servizi / liste di trasmissione di un'applicazione.
Poiché Application, Activity, Service implementano l'interfaccia Context, possono essere utilizzati laddove una chiamata api necessita di un parametro Context
Contextsignifica componente (o applicazione) in vari periodi di tempo. Se mangio così tanto cibo tra le 13:00 e le 14:00, il mio contesto di quel periodo viene utilizzato per accedere a tutti i metodi (o risorse) che utilizzo durante quel periodo. Il contenuto è un componente (applicazione) per un determinato 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 un Activity,
getBaseContext()- dà contextilActivity quello impostato (creato) dal costruttore dell'attività.
getApplicationContext()- fornisce l' Contextinstallazione (creata) 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 chiami getApplicationContext()dall'interno di qualunque componente, stai chiamando il contesto comune dell'intera applicazione.
Context continua a essere modificato dal sistema in base al ciclo di vita dei componenti.
Pensa al contesto come una scatola con diverse risorse: stringa, colori e caratteri. Se hai bisogno di una risorsa, passa a questa casella. Quando si ruota lo schermo, questa casella cambia perché l'orientamento cambia in orizzontale.
Contextsignifica corrente.
Contextutilizzare per eseguire operazioni per la schermata corrente. ex.
1. getApplicationContext ()
2. getContext ()
Toast.makeText(getApplicationContext(), "hello", Toast.LENGTH_SHORT).show();Grandi spiegazioni! Per completare tutto quanto sopra, ho trovato questo di MindOrks molto utile, mostra anche alcuni casi d'uso di base per far andare la tua mente:
In Java, diciamo che questa parola chiave si riferisce allo stato dell'oggetto corrente dell'applicazione.
Allo stesso modo, in alternativa abbiamo Contextnello sviluppo Android.
Questo può essere definito in modo esplicito o implicito,
Context con = this;
getApplicationContext();
getBaseContext();
getContext();thisfunziona solo nelle attività. Il contesto non è un'alternativa a "questo": il contesto viene utilizzato per accedere alle funzionalità di sistema e molto altro. Stai semplificando troppo il contesto e ti manca il punto principale.
Questo attributo dichiara a quale attività questo layout è associato per impostazione predefinita .