Vraag Wat is 'Context' op Android?


Wat is een Android-programmering? Context class en waar wordt het voor gebruikt?

Ik heb erover gelezen op de ontwikkelaarssite, maar ik begrijp het niet duidelijk.


1576
2017-08-26 06:12


oorsprong


antwoorden:


Eenvoudig gezegd:

Zoals de naam al doet vermoeden, is dit de context van de huidige status van de toepassing / het object. Hiermee kunnen nieuw gemaakte objecten begrijpen wat er is gebeurd. Je noemt het meestal om informatie te krijgen over een ander deel van je programma (activiteit en pakket / applicatie).

Je kunt de context krijgen door aan te roepen getApplicationContext(), getContext(), getBaseContext() of this (wanneer in een klas die zich uitstrekt van Context, zoals de klassen Application, Activity, Service en IntentService).

Typische toepassingen van context:

  • Nieuwe objecten maken: Nieuwe weergaven, adapters, luisteraars maken:

    TextView tv = new TextView(getContext());
    ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
    
  • Toegang tot standaard gemeenschappelijke bronnen: Diensten zoals LAYOUT_INFLATER_SERVICE, SharedPreferences:

    context.getSystemService(LAYOUT_INFLATER_SERVICE)
    getApplicationContext().getSharedPreferences(*name*, *mode*);
    
  • Toegang tot componenten impliciet: Betreffende inhoudaanbieders, uitzendingen, intentie

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

1239
2017-08-26 06:32



Definitie van Context ::

  • Context vertegenwoordigt omgevingsgegevens
  • Het biedt toegang tot dingen zoals databases

Eenvoudigere voorwaarden ::

  • Overweeg of Person-X de CEO is van een startend softwarebedrijf.

  • Er is een lead architect aanwezig in het bedrijf, deze lead architect doet al het werk in het bedrijf dat betrekking heeft op, zoals database, UI enz.

  • Nu neemt de CEO een nieuwe ontwikkelaar in dienst.

  • Het is de architect die de verantwoordelijkheid van de nieuw gehuurde vertelt persoon op basis van de vaardigheden van de nieuwe persoon die of hij wil werken aan Database of UI etc.

Eenvoudigere voorwaarden ::

  • Het lijkt op de toegang van Android-activiteit tot de bron van de app.

  • Het is vergelijkbaar met wanneer je een hotel bezoekt, je wilt ontbijt, lunch en eten in de geschikte tijden, toch?

  • Er zijn veel andere dingen die je leuk vindt tijdens de tijd van het verblijf. Hoe doe je deze dingen krijgen?

  • U vraagt ​​de persoon in de roomservice om deze dingen voor u te brengen.

  • Hier is de persoon in de roomservice de context, aangezien je de enkele activiteit en het hotel om uw app te zijn, eindelijk het ontbijt, lunch en diner moet de middelen zijn.


Dingen die context betreffen zijn:

  1. Een bron laden.
  2. Een nieuwe activiteit starten.
  3. Weergaven maken.
  4. het verkrijgen van systeemservice.

Context is de basisklasse voor Activiteit, Service, Toepassing .... enz

Een andere manier om dit te beschrijven: Beschouw de context als op afstand van een tv en kanaal in de televisie zijn bronnen, services, gebruik van intenties etc - - Hier werkt op afstand als toegang om toegang te krijgen tot alle verschillende bronnen op de voorgrond.

  • Remote heeft dus toegang tot kanalen zoals bronnen, services, intenties etc.
  • Evenzo ..... Degene die toegang heeft tot remote heeft op natuurlijke wijze toegang tot alle dingen zoals middelen, diensten, gebruik van intenties enz

Verschillende methoden waarmee je context kunt krijgen

  • getApplicationContext()
  • getContext()
  • getBaseContext()
  • of this (wanneer in de activiteitsklasse)

Voorbeeld:

TextView TV=new TextView(this);

this -> verwijst naar de context van de huidige activiteit.


408
2017-08-20 05:25



Bron


Het onderwerp Context in Android lijkt voor velen verwarrend. Mensen weten gewoon dat Context vrij vaak nodig is om basiszaken in Android te doen. Mensen raken soms in paniek omdat ze proberen een bepaalde bewerking uit te voeren waarvoor de context vereist is en ze niet weten hoe ze de juiste context kunnen 'vinden'. Ik ga proberen het idee van Context in Android te demystificeren. Een volledige behandeling van het probleem valt buiten het bestek van dit bericht, maar ik zal proberen een algemeen overzicht te geven zodat u een idee hebt van wat Context is en hoe u het kunt gebruiken. Om te begrijpen wat Context is, laten we de broncode bekijken:

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

Wat is precies Context? 

Welnu, de documentatie zelf biedt een tamelijk eenvoudige uitleg: de Context-klasse is een "Interface voor globale informatie over een applicatie-omgeving".

De Context-klasse zelf wordt gedeclareerd als abstracte klasse, waarvan de implementatie wordt verzorgd door het Android-besturingssysteem. De documentatie geeft verder aan dat Context "... toegang geeft tot applicatiespecifieke bronnen en klassen, evenals up-calls voor bewerkingen op applicatieniveau zoals startactiviteiten, uitzend- en ontvangstintenties, enz."

Je kunt heel goed begrijpen waarom de naam Context is. Het is omdat het precies dat is. De context biedt de koppeling of haak, als u dat wilt, voor een activiteit, service of een andere component, waardoor deze wordt gekoppeld aan het systeem, waardoor toegang tot de globale toepassingsomgeving mogelijk wordt. Met andere woorden: de context biedt het antwoord op de componentenvraag "waar ben ik in hemelsnaam in het algemeen in relatie tot de app en hoe krijg ik toegang tot / communicatie met de rest van de app?" Als dit alles een beetje verwarrend lijkt, een snelle kijk naar de methoden die worden blootgesteld door de klasse Context biedt enkele verdere aanwijzingen over de ware aard ervan.

Hier is een willekeurige steekproef van die methoden:

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

Wat hebben al deze methoden gemeen? Ze zorgen er allemaal voor dat iedereen die toegang heeft tot de context toegang heeft tot toepassingsbrede bronnen.

Context haakt met andere woorden de component die ernaar verwijst naar de rest van de toepassingsomgeving. De assets (denk '/ assets'-map in uw project) zijn bijvoorbeeld overal in de applicatie beschikbaar, op voorwaarde dat een activiteit, service of hoe dan ook toegang heeft tot die bronnen. Hetzelfde geldt voor getResources() waarmee je dingen kunt doen zoals getResources().getColor() die je in de colors.xml bron (nevermind dat aapt toegang tot bronnen via Java-code mogelijk maakt, dat is een apart probleem).

Het resultaat is dat Context is wat toegang tot systeembronnen en zijn wat haken componenten in de "grotere app" maakt. Laten we naar de subklassen kijken van Context, de klassen die de implementatie van het abstract verzorgen Context klasse. De meest voor de hand liggende klasse is de Activity klasse. Activityerft van ContextThemeWrapper, die erft van ContextWrapper, die erft van Context zelf. Die lessen zijn nuttig om naar te kijken om dingen op een dieper niveau te begrijpen, maar voor nu is het voldoende om dat te weten ContextThemeWrapper en ContextWrapper zijn zo ongeveer hoe ze klinken. Ze implementeren de abstracte elementen van de Context klasse zelf door een context (de feitelijke context) te "inpakken" en die functies naar die context te delegeren.  Een voorbeeld is nuttig - in de ContextWrapper klasse, de abstracte methode getAssets van de Context klasse is als volgt geïmplementeerd:

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

mBase is gewoon een veld ingesteld door de constructor voor een specifieke context. Dus een context is ingepakt en de ContextWrapper delegeert de implementatie van de methode getAssets naar die context. Laten we teruggaan naar het onderzoeken van de Activity klasse die er uiteindelijk van erven Context om te zien hoe dit allemaal werkt.

Je weet waarschijnlijk wat een activiteit is, maar om te beoordelen - het is in feite 'één ding dat de gebruiker kan doen. Het zorgt voor een venster waarin de gebruikersinterface kan worden geplaatst waar de gebruiker interactie mee heeft '. Ontwikkelaars die bekend zijn met andere API's en zelfs niet-ontwikkelaars kunnen dit lokaal beschouwen als een 'scherm'. Dat is technisch onnauwkeurig, maar het maakt niet uit voor onze doeleinden. Dus hoe gaat het Activity en Context interactie en wat gaat er precies in hun erfrechtelijke relatie?

Nogmaals, het is nuttig om naar specifieke voorbeelden te kijken. We weten allemaal hoe we activiteiten moeten starten. Op voorwaarde dat je "de context" hebt vanaf waar je bent, ben je gewoon aan het bellen startActivity(intent), waar de Intent de context beschrijft van waaruit u een activiteit start en de activiteit die u wilt starten. Dit is het bekende startActivity(this, SomeOtherActivity.class).

En wat is this? this is jouw activiteit omdat het Activity klasse erft van Context. De volledige primeur is als volgt: als je belt startActivity, uiteindelijk de Activity klasse voert zoiets als dit uit:

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

Dus het gebruikt de execStartActivity van de Instrumentation klasse (eigenlijk van een innerlijke klasse in Instrumentation riep ActivityResult).

Op dit moment beginnen we een kijkje te nemen in de systeeminternals.

Dit is waar OS eigenlijk alles behandelt. Hoe begint Instrumentation precies met de activiteit? Welnu, de param this in de execStartActivity bovenstaande methode is uw Activiteit, d.w.z. de Context, en de execStartActivity maakt gebruik van deze context.

Een overzicht van 30.000 is dit: de klasse Instrumentation houdt tracks bij van een lijst met activiteiten die worden bewaakt om zijn werk te doen. Deze lijst wordt gebruikt om alle activiteiten te coördineren en ervoor te zorgen dat alles soepel verloopt bij het beheren van de activiteitenstroom.

Er zijn sommige bewerkingen die ik niet volledig heb onderzocht welke problemen met de coördinatordraad en het proces. Uiteindelijk is de ActivityResult gebruikt een native-bewerking - ActivityManagerNative.getDefault().startActivity() welke de Context dat je bent gepasseerd toen je belde startActivity. De context die je hebt doorgegeven, wordt gebruikt om, indien nodig, te assisteren bij "intentieresolutie". Oplossingsresolutie is het proces waarmee het systeem het doel van de intentie kan bepalen als het niet wordt geleverd. (Bekijk de gids hier voor meer details).

En voor Android om dit te doen, heeft het toegang nodig tot informatie die wordt geleverd door Context. In het bijzonder moet het systeem toegang hebben tot a ContentResolver zodat het "het MIME-type van de gegevens van de intentie kan bepalen". Dit hele stuk over hoe startActivity maakt gebruik van de context een beetje ingewikkeld en ik begrijp de interne onderdelen zelf niet volledig. Mijn belangrijkste punt was alleen maar om te illustreren hoe toepassingsbrede bronnen moeten worden benaderd om veel van de bewerkingen uit te voeren die essentieel zijn voor een app. Context is wat toegang tot deze bronnen biedt.  Een eenvoudiger voorbeeld zijn Views. We weten allemaal wat u een aangepaste weergave maakt door deze uit te breiden RelativeLayout of een ander View klasse, moet je een constructor geven die een Context als een argument. Wanneer u uw aangepaste weergave instaat, geeft u deze in de context door.  Waarom? Omdat de weergave toegang moet hebben tot thema's, bronnen en andere configuratiedetails weergeven. Bekijk configuratie is eigenlijk een geweldig voorbeeld. Elke context heeft verschillende parameters (velden in ContextImplementaties) die door het besturingssysteem zelf zijn ingesteld voor zaken als de dimensie of dichtheid van het scherm. Het is gemakkelijk te begrijpen waarom deze informatie belangrijk is voor het instellen van Views, etc.

Nog een laatste woord:  Om een ​​of andere reden lijken mensen die nieuw zijn voor Android (en zelfs mensen die niet zo nieuw zijn) het objectgeoriënteerde programmeren volledig te vergeten als het op Android aankomt. Om een ​​of andere reden proberen mensen hun Android-ontwikkeling te buigen naar vooraf bedachte paradigma's of geleerd gedrag.

Android heeft zijn eigen paradigma en een bepaald patroon dat eigenlijk vrij consistent is als je je vooropgezette ideeën loslaat en eenvoudig de documentatie en de dev gids leest. Mijn echte punt, hoewel "het krijgen van de juiste context" soms lastig kan zijn, mensen zijn ten onrechte in paniek omdat ze in een situatie belanden waarin ze de context nodig hebben en denken dat ze het niet hebben. Nogmaals, Java is een objectgeoriënteerde taal met een inheritance-ontwerp.

U "heeft" alleen de context binnen uw Activiteit omdat uw activiteit zelf erft van Context. Er is geen magie aan (behalve de spullen die het besturingssysteem zelf doet om verschillende parameters in te stellen en om je context correct te "configureren"). Dus, geheugen- / prestatieproblemen opzij zetten (bijv. Referenties naar context houden als dat niet nodig is of het op een manier doen die negatieve gevolgen heeft voor het geheugen, enz.), Context is een object als elk ander en het kan worden doorgegeven net als elke andere POJO (gewoon oud Java-object). Soms moet je misschien slimme dingen doen om die context op te halen, maar elke gewone Java-klasse die zich uitstrekt van niets anders dan Object zelf, kan op een manier worden geschreven die toegang heeft tot de context; stel simpelweg een openbare methode bloot die een context inneemt en gebruik hem dan waar nodig in die klasse. Dit was niet bedoeld als een uitputtende behandeling op Context- of Android-internals, maar ik hoop dat het nuttig is om Context een klein beetje te ontraadselen.


255
2018-04-30 13:44



Een context is een handvat voor het systeem; het biedt diensten zoals het oplossen van bronnen, het verkrijgen van toegang tot databases en voorkeuren, enzovoort. Context is als een handvat voor de omgeving waarin uw toepassing momenteel wordt uitgevoerd. Het activiteitsobject neemt het Context-object over.

Kijk voor meer informatie Introductie tot Android-ontwikkeling met Android Studio - Handleiding.


100
2017-08-26 06:33



Zolang je toch gaat denken, denk groots.

Interface voor globale informatie over een applicatieomgeving. Dit is een abstracte klasse waarvan de implementatie wordt verzorgd door het Android-systeem.

Het biedt toegang tot applicatiespecifieke bronnen en klassen, evenals up-calls voor activiteiten op applicatieniveau zoals startactiviteiten, uitzend- en ontvangstintenties, enz.

Activity diagram


64
2017-12-28 08:05



ANDROID EN CONTEXT

Als je door de verschillende Android API's kijkt, zul je merk op dat velen van hen een android.content.Context object als een parameter. Je zult ook zien dat een activiteit of een dienst meestal wordt gebruikt als een Context. Dit werkt omdat beide klassen zich uitstrekken van Context.

Wat is Context precies?

Volgens de Android-referentiedocumentatie is het een entiteit die verschillende omgevingsgegevens vertegenwoordigt. Het biedt toegang tot lokaal bestanden, databases, klasse-loaders die aan de omgeving zijn gekoppeld, services, inclusief services op systeemniveau, en meer. In dit hele boek en in uw dag-tot- dagcodering met Android, zult u de Context vaak zien passeren. Van: "Android in de praktijk" -boek.


57
2018-04-28 10:14



Een Android Context is een Interface die toegang geeft tot applicatiespecifieke bronnen en klasse en informatie over de applicatieomgeving.

Als je Android-app een webapp was,   jouw context zou iets zijn   vergelijkbaar met ServletContext (ik maak hier geen exacte vergelijking)

Uw activiteiten en services breiden ook de context uit om al deze methoden te erven om toegang te krijgen tot de milieu-informatie waarin de app wordt uitgevoerd.


36
2017-08-26 06:40



Eenvoudig voorbeeld om te begrijpen context in android:

Elke baas heeft een assistent om voor te zorgen, om alle minder belangrijke en tijdrovende taken uit te voeren. Als een bestand of een kop koffie nodig is, is de assistent op de vlucht. Sommige bazen weten amper wat er op kantoor gebeurt, dus ze vragen hun assistenten hierover ook. Ze doen zelf wat werk, maar voor de meeste andere dingen hebben ze hulp van hun assistenten nodig.

In dit scenario,

Baas - is de Android-applicatie

Assistent - is context

Bestanden / kop koffie - zijn middelen

We noemen meestal context wanneer we informatie nodig hebben over verschillende delen van onze applicatie, zoals activiteiten, toepassingen, enzovoort.

Sommige bewerkingen (dingen waar assistent nodig is) waarbij de context is betrokken:

Algemene bronnen laden Dynamische weergaven maken Toast-berichten weergeven Activiteiten lanceren etc. Verschillende manieren om context te krijgen:

getContext()

getBaseContext()

getApplicationContext()

this

26
2018-05-02 12:37



Gewoon het daar uitbrengen voor nieuwkomers;

Dus begrijp eerst Word Context:

In het Engels-lib. het betekent:

"De omstandigheden die de basis vormen voor een gebeurtenis, verklaring of   idee, en in termen waarvan het volledig kan worden begrepen en beoordeeld. "

"De delen van iets geschreven of gesproken dat onmiddellijk voorafgaat aan en   volg een woord of passage en verduidelijk de betekenis ervan. "

Neem nu hetzelfde begrip in het programmeren van de wereld:

context van de huidige status van de toepassing / het object. Hiermee kunnen nieuw gemaakte objecten begrijpen wat er is gebeurd. Je noemt het meestal om informatie te krijgen over een ander deel van je programma (activiteit, pakket / applicatie)

Je kunt de context krijgen door aan te roepen getApplicationContext(), getContext(), getBaseContext() of this (wanneer in de activiteitsklasse).

Als u Context Anywhere in de toepassing wilt gebruiken, volgt u de volgende code:

Maak een nieuwe klas AppContext in je Android-applicatie

public class AppContext extends Application {

    private static Context context;

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

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

Als u nu een toepassingscontext wilt in een niet-activiteitsklasse, kunt u deze methode aanroepen en hebt u een toepassingscontext.

Hoop dat dit helpt ;)


15
2018-05-09 03:23