Context means component (or application) in various time-period. If I do eat so many food between 1 to 2 pm then my context of that time is used to access all methods (or resources) that I use during that time. Content is an component (application) for particular time. Context of components of application keeps changing based on the underlying lifecycle of the components or application. For instance, inside the onCreate() of an Activity ,

getBaseContext() -- gives the context of the Activity that is set (created) by the constructor of activity. getApplicationContext() -- gives the Context setup (created) during the creation of application.

Note: <application> holds all Android Components.

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

It means, when you call getApplicationContext() from inside whatever component, you are calling the common context of the whole application.

Context keeps being modified by the system based on the lifecycle of components.

इसे बस रखो:

जैसा कि नाम से पता चलता है, यह एप्लिकेशन / ऑब्जेक्ट की वर्तमान स्थिति का संदर्भ है। यह नव निर्मित वस्तुओं को समझने देता है कि क्या हो रहा है। आम तौर पर आप इसे अपने प्रोग्राम (गतिविधि और पैकेज / एप्लिकेशन) के किसी अन्य भाग के बारे में जानकारी प्राप्त करने के लिए कहते हैं।

आप getApplicationContext() , getContext() , getBaseContext() या this (जब कक्षा से विस्तारित होता है, जैसे एप्लिकेशन, गतिविधि, सेवा और IntentService कक्षाओं) को आमंत्रित करके संदर्भ प्राप्त कर सकते हैं।

संदर्भ के विशिष्ट उपयोग:

• नई वस्तुओं का निर्माण: नए विचार, एडेप्टर, श्रोताओं का निर्माण:

  TextView tv = new TextView(getContext());
  ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
  

• मानक सामान्य संसाधनों तक पहुंच : LAYOUT_INFLATER_SERVICE जैसी सेवाएं, साझा किए गए संदर्भ:

  context.getSystemService(LAYOUT_INFLATER_SERVICE)
  getApplicationContext().getSharedPreferences(*name*, *mode*);
  

• घटकों को पूरी तरह से एक्सेस करना : सामग्री प्रदाताओं, प्रसारण, मंशा के संबंध में

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

संदर्भ कक्षा के उदाहरण है android.content.Context एंड्रॉइड सिस्टम से कनेक्शन प्रदान करता है जो एप्लिकेशन को निष्पादित करता है। उदाहरण के लिए, आप संदर्भ के माध्यम से वर्तमान डिवाइस डिस्प्ले के आकार की जांच कर सकते हैं।

यह परियोजना के संसाधनों तक पहुंच प्रदान करता है। यह एप्लिकेशन पर्यावरण के बारे में वैश्विक जानकारी के लिए इंटरफ़ेस है।

कॉन्टेक्स्ट क्लास एंड्रॉइड सेवाओं तक पहुंच प्रदान करता है, उदाहरण के लिए, समय आधारित घटनाओं को ट्रिगर करने के लिए अलार्म मैनेजर।

क्रियाएँ और सेवाएं संदर्भ वर्ग का विस्तार करती हैं। इसलिए उन्हें सीधे संदर्भ तक पहुंचने के लिए उपयोग किया जा सकता है।

क्लास android.content.Context एंड्रॉइड सिस्टम और प्रोजेक्ट के संसाधनों से कनेक्शन प्रदान करता है। यह एप्लिकेशन पर्यावरण के बारे में वैश्विक जानकारी के लिए इंटरफ़ेस है।

कॉन्टेक्स्ट एंड्रॉइड सर्विसेज, जैसे स्थान सेवा तक पहुंच प्रदान करता है।

क्रियाएँ और सेवाएं Context वर्ग का विस्तार करती हैं।

एक Context वह है जो हम में से अधिकांश एप्लिकेशन को कॉल करेंगे। यह एंड्रॉइड सिस्टम द्वारा बनाया गया है और केवल वही करने में सक्षम है जो एक एप्लिकेशन सक्षम है। टॉमकैट में, एक संदर्भ भी है जिसे मैं एक एप्लिकेशन कहूंगा।

एक संदर्भ है जिसमें कई गतिविधियां हैं, प्रत्येक गतिविधि में कई दृश्य हो सकते हैं।

जाहिर है, कुछ लोग कहेंगे कि यह इस या उसके कारण फिट नहीं है और वे शायद सही हैं, लेकिन कह रहे हैं कि एक संदर्भ आपका वर्तमान अनुप्रयोग आपको समझने में मदद करेगा कि आप विधि पैरामीटर में क्या डाल रहे हैं।

एक अनुप्रयोग पर्यावरण के बारे में वैश्विक जानकारी के लिए इंटरफ़ेस। यह एक अमूर्त वर्ग है जिसका कार्यान्वयन एंड्रॉइड सिस्टम द्वारा प्रदान किया जाता है। यह एप्लिकेशन-विशिष्ट संसाधनों और कक्षाओं तक पहुंच के साथ-साथ एप्लिकेशन-स्तरीय संचालन के लिए अप-कॉल जैसे गतिविधियों को लॉन्च करने, प्रसारित करने और इरादों को प्राप्त करने आदि की अनुमति देता है।

जब तक आप सोचने जा रहे हैं, तब तक बड़ा सोचें।

एक अनुप्रयोग पर्यावरण के बारे में वैश्विक जानकारी के लिए इंटरफ़ेस। यह एक अमूर्त वर्ग है जिसका कार्यान्वयन एंड्रॉइड सिस्टम द्वारा प्रदान किया जाता है।

यह एप्लिकेशन-विशिष्ट संसाधनों और कक्षाओं तक पहुंच के साथ-साथ एप्लिकेशन-स्तरीय संचालन के लिए अप-कॉल जैसे गतिविधियों को लॉन्च करने, प्रसारित करने और इरादों को प्राप्त करने आदि की अनुमति देता है।

संदर्भ वर्तमान वस्तु का संदर्भ है। इसके अलावा संदर्भ अनुप्रयोग पर्यावरण के बारे में जानकारी तक पहुंच की अनुमति देता है।

संदर्भ प्रत्येक ऐप- Sandbox लिए एंड्रॉइड विशिष्ट एपीआई है जो एक्सेस ऐप निजी डेटा जैसे संसाधन, डेटाबेस, निजी दायित्वों, प्राथमिकताओं, सेटिंग्स प्रदान करता है ...

Most of the privatedata are the same for all activities/services/broadcastlisteners of one application.

Since Application, Activity, Service implement the Context interface they can be used where an api call needs a Context parameter

Context in Android is an interface to global information about an application environment. This is an abstract class whose implementation is provided by the Android system. It allows access to application-specific resources and classes, as well as up-calls for application-level operations such as launching activities, broadcasting and receiving intents, etc.

संदर्भ एप्लिकेशन / ऑब्जेक्ट की वर्तमान स्थिति का संदर्भ है। यह एक ऐसी इकाई है जो विभिन्न पर्यावरण डेटा का प्रतिनिधित्व करती है। संदर्भ वर्तमान गतिविधि को बाहरी तरफ एंड्रॉइड पर्यावरण जैसे स्थानीय फाइलों, डेटाबेस, पर्यावरण से जुड़े वर्ग लोडर, सिस्टम-स्तरीय सेवाओं सहित सेवाओं आदि के साथ बातचीत करने में मदद करता है।

एक संदर्भ प्रणाली के लिए एक हैंडल है। यह संसाधनों को हल करने, डेटाबेस और प्राथमिकताओं तक पहुंच प्राप्त करने जैसी सेवाओं को प्रदान करता है, और इसी तरह। एक एंड्रॉइड ऐप में गतिविधियां हैं। यह आपके एप्लिकेशन में वर्तमान में चल रहे वातावरण के लिए एक हैंडल की तरह है। गतिविधि ऑब्जेक्ट कॉन्टेक्स्ट ऑब्जेक्ट को प्राप्त करता है।

विभिन्न invoking विधियों जिसके द्वारा आप संदर्भ प्राप्त कर सकते हैं 1. getAplicationContext (), 2. getContext (), 3. getBaseContext () 4. या यह (जब गतिविधि वर्ग में)।

एंड्रॉइड में context को समझने के लिए सरल उदाहरण:

सभी मालिकों का ध्यान रखने के लिए सहायक होता है, सभी कम महत्वपूर्ण और समय लेने वाले कार्यों को करने के लिए। अगर एक फाइल या एक कप कॉफी की जरूरत है, तो सहायक चल रहा है। कुछ मालिकों को मुश्किल से पता है कि कार्यालय में क्या चल रहा है, इसलिए वे इसके बारे में अपने सहायकों से भी पूछते हैं। वे स्वयं कुछ काम करते हैं लेकिन ज्यादातर अन्य चीजों के लिए उन्हें अपने सहायकों की मदद की ज़रूरत होती है।

इस परिदृश्य में,

बॉस - एंड्रॉइड एप्लिकेशन है

सहायक - संदर्भ है

कॉफी / कॉफी का कप - संसाधन हैं

हम आम तौर पर संदर्भ कहते हैं जब हमें अपने आवेदन के विभिन्न हिस्सों जैसे गतिविधियों, अनुप्रयोगों आदि के बारे में जानकारी प्राप्त करने की आवश्यकता होती है।

कुछ परिचालन (चीजें जहां सहायक की आवश्यकता होती है) जहां संदर्भ शामिल है:

सामान्य संसाधन लोड करना गतिशील विचार बनाना टोस्ट संदेश प्रदर्शित करना क्रियाकलापों को लॉन्च करना आदि संदर्भ प्राप्त करने के विभिन्न तरीके:

getContext()

getBaseContext()

getApplicationContext()

this

This attribute declares which activity this layout is associated with by default .

संदर्भ मूल रूप से संसाधन पहुंच के लिए है और एप्लिकेशन के पर्यावरण विवरण (एप्लिकेशन संदर्भ के लिए) या गतिविधि (गतिविधि संदर्भ के लिए) या किसी अन्य ...

मेमोरी रिसाव से बचने के लिए आपको प्रत्येक घटक के लिए एप्लिकेशन संदर्भ का उपयोग करना चाहिए जिसके लिए संदर्भ ऑब्जेक्ट की आवश्यकता है .... और अधिक के लिए here क्लिक here

Boss Assistant Analogy

Lets have a small analogy before diving deep in the technicality of Context

Every Boss has an assistant or someone( errand boy) who does less important and more time consuming things for him. For example if they need a file or coffee then an assistant will be on run. Boss will not know what is going on in the background but the file or the task will be delivered

So Here
Boss - Android Application
Assistant - Context
File or cup of coffee - Resource

What official Android Developper site says about Context

Context is your accesss point for application related resources

Lets see some of such resources or tasks

• Launching an activity.

• Getting absolute path to the application specific cache directory on the filesystem.

• Determining whether the given permission is allowed for a particular process and user ID running in the system.

• Checking whether you have been granted a particular permission.

और इसी तरह।
So if Android application wants to start an activity, it goes straight to Context (Access Point), and the Context class gives him back the resources(Intent in this case).

Like any other class Context class too has fields and methods.
You can explore more about Context in official documentation, it covers pretty much everything, available methods, fields and even how to use fields with methods.

बस इसे नए लोगों के लिए बाहर रखो;

तो सबसे पहले शब्द संदर्भ समझें:

अंग्रेजी-lib में। इसका मतलब:

"ऐसी परिस्थितियां जो किसी घटना, कथन या विचार के लिए सेटिंग बनाती हैं, और जिनके संदर्भ में इसे पूरी तरह समझा जा सकता है और मूल्यांकन किया जा सकता है।"

"लिखित या बोले गए कुछ हिस्सों जो तुरंत पहले या किसी शब्द या मार्ग का पालन करते हैं और इसका अर्थ स्पष्ट करते हैं।"

अब प्रोग्रामिंग दुनिया में एक ही समझ लें:

आवेदन / वस्तु की वर्तमान स्थिति का संदर्भ। यह नव निर्मित वस्तुओं को समझने देता है कि क्या हो रहा है। आम तौर पर आप इसे अपने प्रोग्राम के किसी अन्य भाग (गतिविधि, पैकेज / एप्लिकेशन) के बारे में जानकारी प्राप्त करने के लिए कहते हैं।

आप getApplicationContext() , getContext(), getBaseContext() या this (गतिविधि वर्ग में) को आमंत्रित करके संदर्भ प्राप्त कर सकते हैं।

आवेदन कोड में कहीं भी संदर्भ प्राप्त करने के लिए कोड का पालन करें:

अपने एंड्रॉइड एप्लिकेशन के अंदर नई कक्षा AppContext बनाएँ

public class AppContext extends Application {

    private static Context context;

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

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

अब जब भी आप गैर-गतिविधि वर्ग में अनुप्रयोग संदर्भ चाहते हैं, तो इस विधि को कॉल करें और आपके पास एप्लिकेशन संदर्भ है।

उममीद है कि इससे मदद मिलेगी ;)

Source

एंड्रॉइड में संदर्भ का विषय कई लोगों के लिए भ्रमित प्रतीत होता है। लोग सिर्फ यह जानते हैं कि एंड्रॉइड में मूल बातें करने के लिए अक्सर संदर्भ की आवश्यकता होती है। लोग कभी-कभी घबराते हैं क्योंकि वे कुछ ऑपरेशन करने की कोशिश करते हैं जिसके लिए संदर्भ की आवश्यकता होती है और वे नहीं जानते कि सही संदर्भ कैसे प्राप्त करें। मैं एंड्रॉइड में संदर्भ के विचार को नष्ट करने की कोशिश करने जा रहा हूं। इस मुद्दे का पूरा उपचार इस पोस्ट के दायरे से बाहर है, लेकिन मैं एक सामान्य अवलोकन देने की कोशिश करूंगा ताकि आपको समझ हो कि संदर्भ क्या है और इसका उपयोग कैसे किया जाए। यह समझने के लिए कि संदर्भ क्या है, आइए सोर्स कोड देखें:

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

संदर्भ वास्तव में क्या है?

खैर, प्रलेखन स्वयं एक सरल सीधा स्पष्टीकरण प्रदान करता है: संदर्भ वर्ग एक "अनुप्रयोग पर्यावरण के बारे में वैश्विक जानकारी के लिए इंटरफ़ेस" है।

संदर्भ वर्ग को खुद को अमूर्त वर्ग के रूप में घोषित किया जाता है, जिसका कार्यान्वयन एंड्रॉइड ओएस द्वारा प्रदान किया जाता है। प्रलेखन आगे प्रदान करता है कि संदर्भ "... अनुप्रयोग-विशिष्ट संसाधनों और कक्षाओं तक पहुंच की अनुमति देता है, साथ ही साथ एप्लिकेशन-स्तरीय संचालन के लिए अप-कॉल जैसे गतिविधियों को लॉन्च करना, प्रसारण करना और इरादे प्राप्त करना इत्यादि।"

आप बहुत अच्छी तरह से समझ सकते हैं, अब नाम क्यों संदर्भ है। ऐसा इसलिए है क्योंकि यह बस यही है। कॉन्टेक्स्ट लिंक या हुक प्रदान करता है, यदि आप एक गतिविधि, सेवा या किसी अन्य घटक के लिए, इस प्रकार सिस्टम को जोड़कर, वैश्विक अनुप्रयोग वातावरण तक पहुंच सक्षम कर सकते हैं। दूसरे शब्दों में: संदर्भ घटकों के प्रश्न का उत्तर प्रदान करता है "जहां मैं आम तौर पर ऐप के संबंध में हूं और मैं बाकी ऐप के साथ कैसे पहुंच / संचार कर सकता हूं?" यदि यह सब कुछ भ्रमित लगता है, तो जल्दी संदर्भ वर्ग द्वारा उजागर विधियों को देखें, इसकी वास्तविक प्रकृति के बारे में कुछ और संकेत मिलते हैं।

यहां उन तरीकों का एक यादृच्छिक नमूनाकरण है:

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

इन सभी तरीकों में क्या समान है? वे सभी सक्षम हैं जो किसी भी व्यक्ति को संदर्भ-प्रसार संसाधनों तक पहुंचने में सक्षम होने के लिए संदर्भ तक पहुंच है।

संदर्भ, दूसरे शब्दों में, उस घटक को हुक करता है जिसका शेष अनुप्रयोग वातावरण के संदर्भ में इसका संदर्भ है। संपत्ति (आपके प्रोजेक्ट में सोचें '/ संपत्ति' फ़ोल्डर), उदाहरण के लिए, एप्लिकेशन में उपलब्ध हैं, बशर्ते कि एक गतिविधि, सेवा या जो कुछ भी उन संसाधनों तक पहुंचने के बारे में जानता हो। getResources() लिए भी जाता है जो getResources() करने की अनुमति देता है getResources().getColor() जो आपको getResources().getColor() संसाधन में हुक देगा (कभी नहीं मानें कि एएपी जावा कोड के माध्यम से संसाधनों तक पहुंच को सक्षम बनाता है, यह एक अलग मुद्दा है)।

उपरोक्त यह है कि Context सिस्टम संसाधनों तक पहुंच को सक्षम बनाता है और यह "अधिक ऐप" में घटकों को हुक करता है। आइए Context के उप-वर्गों को देखें, जो कक्षाएं सार Context वर्ग के क्रियान्वयन को प्रदान करती हैं। सबसे स्पष्ट वर्ग है Activity वर्ग। Activity ContextThemeWrapper से प्राप्त ContextThemeWrapper , जो ContextWrapper से प्राप्त ContextWrapper , जो Context से विरासत में होती है। वे कक्षाएं गहरे स्तर पर चीजों को समझने के लिए उपयोगी होती हैं, लेकिन अब यह जानना पर्याप्त है कि ContextThemeWrapper और ContextWrapper वे बहुत अधिक हैं ध्वनि की तरह। वे Context वर्ग के सार तत्वों को एक संदर्भ (वास्तविक संदर्भ) द्वारा "लपेटकर" और उन कार्यों को उस संदर्भ में प्रस्तुत करके लागू करते हैं। एक उदाहरण उपयोगी है - ContextWrapper वर्ग में, सार विधि को Context वर्ग से प्राप्त करें निम्नानुसार कार्यान्वित किया गया है:

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

mBase बस एक विशिष्ट संदर्भ के लिए निर्माता द्वारा सेट एक फ़ील्ड है। तो एक संदर्भ लपेटा गया है और ContextWrapper उस संदर्भ में getAssets विधि के कार्यान्वयन को प्रतिनिधि करता है। चलिए Activity कक्षा की जांच करने के लिए वापस आते हैं जो आखिरकार Context से विरासत में आता है यह देखने के लिए कि यह सब कैसे काम करता है।

आप शायद जानते हैं कि एक गतिविधि क्या है, लेकिन समीक्षा करने के लिए - यह मूल रूप से 'एक चीज है जिसे उपयोगकर्ता कर सकता है। यह उस खिड़की को प्रदान करने का ख्याल रखता है जिसमें यूआई को रखा जाए जिसे उपयोगकर्ता 'के साथ इंटरैक्ट करता है। अन्य एपीआई और यहां तक ​​कि गैर डेवलपर्स से परिचित डेवलपर्स इसे "स्क्रीन" के रूप में स्थानीय रूप से सोच सकते हैं। यह तकनीकी रूप से गलत है, लेकिन इससे हमारे उद्देश्यों के लिए कोई फर्क नहीं पड़ता। तो Activity और Context कैसे बातचीत करते हैं और उनके विरासत संबंधों में वास्तव में क्या चल रहा है?

फिर, विशिष्ट उदाहरणों को देखने में मददगार है। हम सभी जानते हैं कि गतिविधियों को कैसे लॉन्च करें। बशर्ते आपके पास "संदर्भ" है जिसमें से आप गतिविधि शुरू कर रहे हैं, आप बस प्रारंभ गतिविधि startActivity(intent) , जहां startActivity(intent) उस संदर्भ का वर्णन करता है जिसमें से आप एक गतिविधि शुरू कर रहे हैं और जिस गतिविधि को आप शुरू करना चाहते हैं। यह परिचित startActivity(this, SomeOtherActivity.class) ।

और यह क्या है this आपकी गतिविधि है क्योंकि Activity वर्ग Context से विरासत में आता है। पूर्ण स्कूप इस तरह है: जब आप startActivity Activity कहते हैं, अंततः Activity वर्ग इस तरह कुछ निष्पादित करता है:

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

इसलिए यह Instrumentation क्लास (वास्तव में ActivityResult में एक आंतरिक वर्ग से ActivityResult के execStartActivity से execStartActivity का उपयोग करता है।

इस बिंदु पर, हम सिस्टम आंतरिक पर एक झांक पाने शुरू कर रहे हैं।

यह वह जगह है जहां ओएस वास्तव में सब कुछ संभालता है। तो इंस्ट्रुमेंटेशन गतिविधि को वास्तव में कैसे शुरू करता है? खैर, उपरोक्त execStartActivity विधि में this param आपकी गतिविधि है, यानी संदर्भ, और execStartActivity इस संदर्भ का उपयोग करता है।

एक 30,000 सिंहावलोकन यह है: इंस्ट्रुमेंटेशन क्लास क्रियाकलापों की एक सूची का ट्रैक रखता है जो इसकी निगरानी करने के लिए निगरानी कर रहा है। इस सूची का उपयोग सभी गतिविधियों को समन्वयित करने के लिए किया जाता है और सुनिश्चित करें कि गतिविधियों के प्रवाह के प्रबंधन में सब कुछ सुचारू रूप से चलता है।

कुछ ऐसे ऑपरेशन हैं जिन्हें मैंने पूरी तरह से नहीं देखा है जो थ्रेड और प्रक्रिया के मुद्दों को समन्वयित करते हैं। आखिरकार, ActivityResult एक देशी ऑपरेशन का उपयोग करता है - ActivityManagerNative.getDefault().startActivity() जो आपके द्वारा ActivityManagerNative.getDefault().startActivity() की गई Context का उपयोग करता है जिसे आपने ActivityManagerNative.getDefault().startActivity() कहा था। आपके द्वारा पारित संदर्भ का उपयोग आवश्यक होने पर "इरादा समाधान" में सहायता के लिए किया जाता है। इरादा संकल्प वह प्रक्रिया है जिसके द्वारा सिस्टम इरादे के लक्ष्य को निर्धारित कर सकता है यदि यह आपूर्ति नहीं की जाती है। (अधिक जानकारी के लिए यहां गाइड देखें)।

और एंड्रॉइड ऐसा करने के लिए, इसे Context द्वारा प्रदान की जाने वाली जानकारी तक पहुंच की आवश्यकता है। विशेष रूप से, सिस्टम को ContentResolver तक पहुंचने की आवश्यकता होती है, इसलिए यह "इरादे के डेटा के एमआईएमई प्रकार को निर्धारित कर सकता है"। इस बारे में पूरी बात यह है कि startActivity संदर्भ का उपयोग कैसे करती है, यह थोड़ा जटिल था और मैं खुद को आंतरिक रूप से पूरी तरह से समझ नहीं पा रहा हूं। मुख्य बिंदु यह स्पष्ट करने के लिए था कि ऐप के लिए आवश्यक कई संचालन करने के लिए एप्लिकेशन-व्यापी संसाधनों को कैसे एक्सेस किया जाना चाहिए। Context इन संसाधनों तक पहुंच प्रदान करता है। एक सरल उदाहरण दृश्य हो सकता है। हम सभी जानते हैं कि क्या आप RelativeLayout या कुछ अन्य View क्लास को बढ़ाकर कस्टम व्यू बनाते हैं, आपको एक कन्स्ट्रक्टर प्रदान करना होगा जो एक Context रूप में Context लेता है। जब आप अपना कस्टम व्यू चालू करते हैं तो आप संदर्भ में पास करते हैं। क्यों? क्योंकि दृश्य को देखने में सक्षम होना चाहिए थीम, संसाधन, और अन्य तक पहुंच कॉन्फ़िगरेशन विवरण देखें। कॉन्फ़िगरेशन वास्तव में एक शानदार उदाहरण है। प्रत्येक संदर्भ में विभिन्न पैरामीटर ( Context के कार्यान्वयन में फ़ील्ड) हैं जो ओएस द्वारा स्वयं सेट किए गए हैं प्रदर्शन के आयाम या घनत्व जैसी चीजें। यह देखना आसान है कि दृश्यों को स्थापित करने के लिए यह जानकारी महत्वपूर्ण क्यों है।

एक अंतिम शब्द: किसी कारण से एंड्रॉइड के लिए नए लोग (और यहां तक ​​कि लोग इतने नए नहीं) ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के बारे में पूरी तरह से भूल जाते हैं जब यह एंड्रॉइड की बात आती है। किसी कारण से, लोग पूर्व-अनुमानित प्रतिमानों या सीखे व्यवहारों के लिए अपने एंड्रॉइड विकास को झुकाव करने का प्रयास करते हैं।

एंड्रॉइड का अपना प्रतिमान और एक निश्चित पैटर्न है जो वास्तव में काफी संगत है यदि आपके पूर्व-अनुमानित विचारों को छोड़ दें और केवल दस्तावेज़ और देव मार्गदर्शिका पढ़ें। मेरा असली बिंदु, हालांकि, "सही संदर्भ प्राप्त करने" के दौरान कभी-कभी मुश्किल हो सकती है, लोग अनजाने में घबराते हैं क्योंकि वे ऐसी स्थिति में भाग लेते हैं जहां उन्हें संदर्भ की आवश्यकता होती है और लगता है कि उनके पास यह नहीं है। एक बार फिर, जावा एक ऑब्जेक्ट उन्मुख भाषा है जिसमें विरासत डिज़ाइन है।

आप केवल अपनी गतिविधि के अंदर संदर्भ "है" क्योंकि आपकी गतिविधि स्वयं संदर्भ से प्राप्त होती है। इसके लिए कोई जादू नहीं है (ओएस द्वारा किए गए सभी सामानों को छोड़कर ओएस अपने आप को विभिन्न पैरामीटर सेट करने और अपने संदर्भ को सही तरीके से "कॉन्फ़िगर" करने के लिए करता है)। इसलिए, मेमोरी / प्रदर्शन मुद्दों को एक तरफ डालना (उदाहरण के लिए जब संदर्भ की आवश्यकता नहीं होती है या उस पर ऐसा करने की आवश्यकता नहीं होती है, तो स्मृति पर नकारात्मक परिणाम होते हैं), संदर्भ किसी अन्य की तरह एक वस्तु है और इसे चारों ओर पारित किया जा सकता है किसी भी POJO (सादा ओल्ड जावा ऑब्जेक्ट) की तरह। कभी-कभी आपको उस संदर्भ को पुनर्प्राप्त करने के लिए चालाक चीजें करने की आवश्यकता हो सकती है, लेकिन ऑब्जेक्ट के अलावा कुछ भी नहीं होने वाली किसी भी नियमित जावा क्लास को ऐसे तरीके से लिखा जा सकता है जिस पर संदर्भ तक पहुंच हो; बस एक सार्वजनिक विधि का पर्दाफाश करें जो एक संदर्भ लेता है और फिर आवश्यकतानुसार उस वर्ग में इसका उपयोग करता है। यह संदर्भ या एंड्रॉइड इंटर्नल्स पर एक संपूर्ण उपचार के रूप में नहीं था, लेकिन मुझे उम्मीद है कि यह संदर्भ को कम करने में मददगार होगा।

एंड्रॉइड और CONTEXT यदि आप विभिन्न एंड्रॉइड एपीआई देखते हैं, तो आप देखेंगे कि उनमें से कई एक android.content.Context ऑब्जेक्ट को पैरामीटर के रूप में लेते हैं। आप यह भी देखेंगे कि एक गतिविधि या सेवा आमतौर पर संदर्भ के रूप में उपयोग की जाती है। यह काम करता है क्योंकि इन दोनों वर्गों में संदर्भ से विस्तार किया गया है।

वास्तव में संदर्भ क्या है? एंड्रॉइड संदर्भ दस्तावेज के अनुसार, यह एक ऐसी इकाई है जो विभिन्न पर्यावरण डेटा का प्रतिनिधित्व करती है। यह स्थानीय फाइलों, डेटाबेस, पर्यावरण से जुड़े वर्ग लोडर, सिस्टम-स्तरीय सेवाओं सहित सेवाओं और अन्य तक पहुंच प्रदान करता है। इस पुस्तक के दौरान, और एंड्रॉइड के साथ आपके दिन-प्रति-दिन कोडिंग में, आप संदर्भ को अक्सर पास में देखेंगे। से: "एंड्रॉइड इन प्रैक्टिस" पुस्तक।

Context means current. Context use to do operation for current screen. पूर्व।
1. getApplicationContext()
2. getContext()

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

Context is context of current state of the application/object. Its an entity that represents various environment data. Context helps the current activity to interact with out side Android Environment like local files, databases, class loaders associated to the environment, services including system-level services, and more.

A Context is a handle to the system. It provides services like resolving resources, obtaining access to databases and preferences, and so on. An android app has activities. It's like a handle to the environment your application is currently running in. The activity object inherits the Context object. Examples for uses of context :

1. Creating New objects: Creating new views, adapters, listeners

   TextView tv = new TextView(getContext());
   ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
   

2. Accessing Standard Common Resources: Services like LAYOUT_INFLATER_SERVICE, SharedPreferences:

   context.getSystemService(LAYOUT_INFLATER_SERVICE) 
   getApplicationContext().getSharedPreferences(*name*, *mode*);
   

3. Accessing Components Implicitly: Regarding content providers, broadcasts, intent

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

Difference between Activity Context and Application Context :

They are both instances of Context , but the application instance is tied to the lifecycle of the application, while the Activity instance is tied to the lifecycle of an Activity. Thus, they have access to different information about the application environment.

If you read the docs at getApplicationContext it notes that you should only use this if you need a context whose lifecycle is separate from the current context.

But in general, use the activity context unless you have a good reason not to.

Need of Context :

The documentation says that every view needs the context to access the right resources (eg the theme, strings etc.).

But why in the constructor and not through setContentView(View)?

1.Because the resources must be accessible while the view is being constructed (the constructor will need some resources to fully initialise the view).

2.This allows the flexibility of using a context that is different from the one of the current activity (imagine a view that uses some other string resources and not the ones from the current activity).

3.The designers of the Android SDK seem to have chosen that the context must be set only once and then stay the same throughout the lifetime of the view. Why context is not determined automatically at construction point?

1.Because there exists no static variable that would tell you the current global context of your application. The method getApplicationContext() is the closest to this, but it's not static, so you need an instance of the Activity object to call it.

2.The Java language provides an option to look through the call stack and find whether the View has been constructed in a Context class. But what if there are many? Or what if there are none? This method is very expensive and error prone. So the designers of the API decided that a context must be manually provided.

संदर्भ एक अनुप्रयोग पर्यावरण के बारे में वैश्विक जानकारी के लिए एक इंटरफ़ेस है। यह एक अमूर्त वर्ग है जिसका कार्यान्वयन Android सिस्टम द्वारा प्रदान किया जाता है।

Context एप्लिकेशन-विशिष्ट संसाधनों और कक्षाओं तक पहुंच की अनुमति देता है, साथ ही साथ एप्लिकेशन-स्तरीय संचालन की मांग करता है जैसे launching activities, broadcasting and receiving intents, etc. को launching activities, broadcasting and receiving intents, etc.

उदाहरण यहाँ है

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

अधिक जानकारी के लिए आप Context जा सकते हैं

एक एंड्रॉइड Context एक Interface जो एप्लिकेशन विशिष्ट संसाधनों और कक्षा और एप्लिकेशन वातावरण के बारे में जानकारी तक पहुंच की अनुमति देता है।

यदि आपका एंड्रॉइड ऐप एक वेब ऐप था, तो आपका संदर्भ ServletContext के समान कुछ होगा (मैं यहां सटीक तुलना नहीं कर रहा हूं)

आपकी गतिविधियां और सेवाएं कॉन्टेक्स्ट को विस्तारित करती हैं ताकि वे उन सभी विधियों को प्राप्त कर सकें जिनके लिए ऐप चल रहा है, उस पर्यावरण की जानकारी तक पहुंचने के लिए।

यदि आप एंड्रॉइड में अन्य परिचित कक्षाओं के साथ संदर्भ कनेक्ट करना चाहते हैं, तो इस संरचना को ध्यान में रखें:

संदर्भ <ContextWrapper <अनुप्रयोग

संदर्भ <ContextWrapper <ContextThemeWrapper <गतिविधि

संदर्भ <ContextWrapper <ContextThemeWrapper <गतिविधि <ListActivity

संदर्भ <ContextWrapper <सेवा

संदर्भ <ContextWrapper <सेवा <IntentService

तो, उन सभी वर्गों के संदर्भ में संदर्भ हैं। यदि आप चाहें तो आप संदर्भ में सेवा और सूची सक्रियता को कास्ट कर सकते हैं। लेकिन यदि आप बारीकी से देखते हैं, तो कुछ वर्गों में विषय भी मिलता है। गतिविधि या टुकड़े में, आप उन्हें अपने विचारों पर लागू करना चाहते हैं, लेकिन उदाहरण के लिए, सेवा वर्ग की परवाह नहीं करते हैं।

मैं here संदर्भों में अंतर की व्याख्या करता हूं।

• संदर्भ पर्यावरण डेटा प्राप्त करने के लिए एक हैंडल का प्रतिनिधित्व करता है।
• संदर्भ वर्ग को सार के रूप में घोषित किया जाता है, जिसका कार्यान्वयन एंड्रॉइड ओएस द्वारा प्रदान किया जाता है।
• संदर्भ टीवी में टीवी और चैनल के रिमोट की तरह है संसाधन, सेवाएं इत्यादि हैं।

तुम्हारे द्वारा इससे क्या किया जा सकता है ?

• संसाधन लोड हो रहा है।
• एक नई गतिविधि शुरू करना।
• विचार बनाना
• सिस्टम सेवा प्राप्त करना

संदर्भ प्राप्त करने के तरीके:

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