ในการเขียนโปรแกรม Android Contextคลาสคืออะไรและใช้ทำอะไร?

ฉันอ่านเกี่ยวกับเว็บไซต์นักพัฒนาแต่ฉันไม่สามารถเข้าใจได้อย่างชัดเจน

วางไว้เพียง:

ดังที่ชื่อแนะนำเป็นบริบทของสถานะปัจจุบันของแอปพลิเคชัน / วัตถุ ช่วยให้วัตถุที่เพิ่งสร้างใหม่เข้าใจสิ่งที่เกิดขึ้น โดยทั่วไปคุณจะเรียกมันเพื่อรับข้อมูลเกี่ยวกับส่วนอื่นของโปรแกรมของคุณ (กิจกรรมและแพ็คเกจ / แอปพลิเคชัน)

คุณจะได้รับบริบทโดยเรียกgetApplicationContext(), getContext(), getBaseContext()หรือthis(เมื่ออยู่ในระดับที่ขยายจากContextเช่นแอพลิเคชัน, กิจกรรม, บริการและ IntentService ชั้นเรียน)

การใช้บริบทโดยทั่วไป:

• การสร้างวัตถุใหม่ : การสร้างมุมมองใหม่, อะแดปเตอร์, ผู้ฟัง:

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

• การเข้าถึงทรัพยากรทั่วไปมาตรฐาน : บริการเช่น LAYOUT_INFLATER_SERVICE, SharedPreferences:

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

• การเข้าถึงองค์ประกอบโดยนัย : เกี่ยวกับผู้ให้บริการเนื้อหาการเผยแพร่ความตั้งใจ

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

คำจำกัดความของบริบท

• บริบทแสดงถึงข้อมูลสภาพแวดล้อม
• มันให้การเข้าถึงสิ่งต่าง ๆ เช่นฐานข้อมูล

คำศัพท์ที่ง่ายขึ้น (ตัวอย่าง 1)

• พิจารณา Person-X เป็นซีอีโอของ บริษัท ซอฟต์แวร์เริ่มต้น

• มีหัวหน้าสถาปนิกอยู่ใน บริษัท นี้หัวหน้าสถาปนิกจะทำงานทั้งหมดใน บริษัท ที่เกี่ยวข้องเช่นฐานข้อมูล UI ฯลฯ

• ตอนนี้ CEO ได้ว่าจ้างนักพัฒนาใหม่

• เป็นสถาปนิกที่บอกความรับผิดชอบของผู้ว่าจ้างใหม่ตามทักษะของคนใหม่ว่าจะทำงานกับฐานข้อมูลหรือ UI เป็นต้น

คำศัพท์ที่ง่ายขึ้น (ตัวอย่าง 2)

• มันเหมือนกับการเข้าถึงกิจกรรม Android ไปยังทรัพยากรของแอป

• มันคล้ายกับเมื่อคุณไปที่โรงแรมคุณต้องการอาหารเช้ากลางวันและเย็นในเวลาที่เหมาะสมใช่ไหม

• มีสิ่งอื่น ๆ อีกมากมายที่คุณชอบในช่วงเวลาที่เข้าพัก คุณจะได้รับสิ่งเหล่านี้ได้อย่างไร

• คุณขอให้พนักงานรูมเซอร์วิสนำสิ่งเหล่านี้มาให้คุณ

• ที่นี่คนรูมเซอร์วิสเป็นบริบทที่พิจารณาว่าคุณเป็นกิจกรรมเดียวและโรงแรมเป็นแอปของคุณในที่สุดอาหารเช้าอาหารกลางวันและอาหารเย็นจะต้องเป็นแหล่งข้อมูล

สิ่งที่เกี่ยวข้องกับบริบทคือ:

1. กำลังโหลดทรัพยากร
2. เปิดตัวกิจกรรมใหม่
3. กำลังสร้างมุมมอง
4. การรับบริการระบบ

บริบทเป็นชั้นฐานสำหรับกิจกรรม , บริการ , แอพลิเคชันอื่น ๆ

อีกวิธีในการอธิบายสิ่งนี้: พิจารณาบริบทของรีโมตของทีวีและช่องในทีวีคือทรัพยากรบริการโดยใช้ intents เป็นต้น - - ที่นี่รีโมตทำหน้าที่เป็นการเข้าถึงเพื่อเข้าถึงทรัพยากรต่าง ๆ ทั้งหมดในเบื้องหน้า

• ดังนั้น Remote จึงสามารถเข้าถึงช่องทางต่างๆเช่นทรัพยากรบริการการใช้งาน intents เป็นต้น

• ในทำนองเดียวกัน ... ใครก็ตามที่เข้าถึงรีโมตตามธรรมชาติจะสามารถเข้าถึงทุกสิ่งเช่นทรัพยากรการบริการการใช้ intents เป็นต้น

วิธีการต่าง ๆ ที่คุณสามารถรับบริบท

• getApplicationContext()
• getContext()
• getBaseContext()
• หรือthis(เมื่ออยู่ในชั้นเรียนกิจกรรม)

ตัวอย่าง:

TextView tv = new TextView(this);

คำสำคัญthisหมายถึงบริบทของกิจกรรมปัจจุบัน

แหล่ง

หัวข้อของบริบทใน Android ดูเหมือนจะสร้างความสับสนให้กับหลายคน ผู้คนเพิ่งรู้ว่าบริบทเป็นสิ่งจำเป็นค่อนข้างบ่อยในการทำสิ่งพื้นฐานใน Android บางครั้งผู้คนก็ตื่นตระหนกเพราะพวกเขาพยายามทำการดำเนินการบางอย่างที่ต้องใช้บริบทและพวกเขาไม่รู้ว่าจะ“ รับ” บริบทที่ถูกต้องได้อย่างไร ฉันกำลังพยายามที่จะเข้าใจอย่างลึกซึ้งถึงแนวคิดของบริบทใน Android การแก้ไขปัญหาอย่างเต็มรูปแบบอยู่นอกเหนือขอบเขตของโพสต์นี้ แต่ฉันจะพยายามให้ภาพรวมทั่วไปเพื่อให้คุณเข้าใจว่าบริบทคืออะไรและจะใช้งานอย่างไร เพื่อทำความเข้าใจว่าบริบทคืออะไรลองดูที่ซอร์สโค้ด:

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

บริบทคืออะไร

ตัวเอกสารเองนั้นให้คำอธิบายที่ค่อนข้างตรงไปตรงมาคลาส Context นั้นเป็น“ ส่วนต่อประสานกับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอพพลิเคชัน”

คลาส Context นั้นถูกประกาศเป็นคลาสนามธรรมซึ่งมีการใช้งานโดย Android OS เอกสารอธิบายเพิ่มเติมว่าบริบท“ …อนุญาตให้เข้าถึงทรัพยากรและคลาสเฉพาะของแอปพลิเคชันรวมถึงการเรียกใช้สำหรับการดำเนินการระดับแอปพลิเคชันเช่นการเปิดตัวกิจกรรมการแพร่ภาพและการรับเจตนา ฯลฯ ”

คุณสามารถเข้าใจได้ดีมากตอนนี้ทำไมชื่อถึงเป็นบริบท เป็นเพราะมันแค่นั้น บริบทให้การเชื่อมโยงหรือเบ็ดหากคุณจะสำหรับกิจกรรมบริการหรือส่วนประกอบอื่น ๆ ดังนั้นการเชื่อมโยงไปยังระบบการเปิดใช้งานการเข้าถึงสภาพแวดล้อมการใช้งานทั่วโลก กล่าวอีกนัยหนึ่ง: บริบทให้คำตอบสำหรับคำถามเกี่ยวกับส่วนประกอบของ“ ฉันอยู่ที่ไหนเกี่ยวกับแอพโดยทั่วไปและฉันจะเข้าถึง / สื่อสารกับแอพที่เหลือได้อย่างไร” หากทั้งหมดนี้ดูเหมือนว่าจะสับสนเล็กน้อยการดูวิธีการที่เปิดเผยโดยคลาส Context อย่างรวดเร็วจะให้ข้อมูลเพิ่มเติมเกี่ยวกับธรรมชาติที่แท้จริงของมัน

นี่คือตัวอย่างแบบสุ่มของวิธีการเหล่านี้:

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

วิธีการทั้งหมดเหล่านี้มีอะไรที่เหมือนกัน? พวกเขาทั้งหมดเปิดใช้งานใครก็ตามที่สามารถเข้าถึงบริบทเพื่อให้สามารถเข้าถึงทรัพยากรทั้งแอปพลิเคชัน

บริบทกล่าวอีกนัยตะขอองค์ประกอบที่มีการอ้างอิงไปยังส่วนที่เหลือของสภาพแวดล้อมที่ใช้ ตัวอย่างเช่นสินทรัพย์ (คิดว่า '/ ทรัพย์สิน' ในโครงการของคุณ) มีอยู่ในแอปพลิเคชันโดยมีเงื่อนไขว่ากิจกรรมบริการหรืออะไรก็ตามที่รู้วิธีเข้าถึงทรัพยากรเหล่านั้น กันไปgetResources()ซึ่งจะช่วยให้ทำสิ่งต่าง ๆ เช่นgetResources().getColor()ที่จะขอให้คุณเข้าไปในcolors.xmlทรัพยากร (ไม่เป็นไรที่ aapt ช่วยให้เข้าถึงทรัพยากรผ่านรหัส java ซึ่งเป็นปัญหาที่แยกต่างหาก)

ผลที่สุดก็คือว่าContextเป็นสิ่งที่ช่วยให้การเข้าถึงทรัพยากรระบบและสิ่ง hooks ส่วนประกอบใน“แอปมากขึ้น". ดู Let 's ที่ subclasses ของContextชั้นเรียนที่ให้การดำเนินงานของนามธรรมContextระดับ. ชั้นที่เห็นได้ชัดที่สุดคือActivityระดับ. Activityสืบทอด จากContextThemeWrapperที่สืบทอดจากContextWrapperซึ่งสืบทอดมาจากContextตัวเอง. ชั้นเรียนเหล่านี้จะเป็นประโยชน์ในการมองไปที่จะเข้าใจสิ่งที่อยู่ในระดับที่ลึก แต่สำหรับตอนนี้ก็เพียงพอที่จะรู้ว่าContextThemeWrapperและContextWrapperจะสวยมากสิ่งที่พวกเขาเสียงเหมือน. พวกเขาใช้องค์ประกอบนามธรรมของContextเรียนโดยการ“ ห่อ” บริบท (บริบทจริง) และมอบหมายหน้าที่เหล่านั้นให้กับบริบทนั้นตัวอย่างมีประโยชน์ - ในContextWrapperชั้นวิธีนามธรรมgetAssetsจากContextชั้นเรียนมีการดำเนินการดังต่อไปนี้:

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

mBaseเป็นเพียงฟิลด์ที่กำหนดโดยตัวสร้างไปยังบริบทที่เฉพาะเจาะจง ดังนั้นบริบทจึงได้รับการห่อหุ้มและContextWrapperผู้ได้รับมอบหมายให้นำวิธีการ getAssets ไปใช้กับบริบทนั้น ลองกลับไปตรวจสอบActivityคลาสที่สืบทอดกันมาในที่สุดContextเพื่อดูว่ามันทำงานอย่างไร

คุณอาจรู้ว่ากิจกรรมคืออะไร แต่เพื่อตรวจสอบ - มันเป็น 'สิ่งเดียวที่ผู้ใช้สามารถทำได้ ดูแลหน้าต่างที่จะวาง UI ที่ผู้ใช้โต้ตอบด้วย ' นักพัฒนาที่คุ้นเคยกับ API อื่นและแม้กระทั่งผู้ที่ไม่ใช่นักพัฒนาอาจคิดว่ามันเป็นภาษาที่ "หน้าจอ" ไม่ถูกต้องทางเทคนิค แต่มันไม่สำคัญสำหรับวัตถุประสงค์ของเรา แล้วจะทำอย่างไรActivityและContextโต้ตอบกันอย่างไรและเกิดอะไรขึ้นในความสัมพันธ์ในการรับมรดกของพวกเขา?

อีกครั้งเป็นประโยชน์ในการดูตัวอย่างที่เฉพาะเจาะจง เราทุกคนรู้วิธีเปิดตัวกิจกรรม หากคุณมี“ บริบท” ที่คุณเริ่มต้นกิจกรรมคุณเพียงแค่โทรstartActivity(intent)โดยที่ Intent จะอธิบายบริบทที่คุณเริ่มต้นกิจกรรมและกิจกรรมที่คุณต้องการเริ่มต้น startActivity(this, SomeOtherActivity.class)นี้เป็นที่คุ้นเคย

แล้วอะไรthisล่ะ thisความเคลื่อนไหวของคุณเพราะระดับสืบทอดจากActivity Contextการตักเต็มรูปแบบเป็นเช่นนี้: เมื่อคุณโทรstartActivityในที่สุดActivityชั้นเรียนจะดำเนินการบางอย่างเช่นนี้:

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

ดังนั้นมันจึงใช้ประโยชน์execStartActivityจากInstrumentationคลาส (จริง ๆ แล้วจากคลาสภายในInstrumentationเรียกว่าActivityResult)

เมื่อมาถึงจุดนี้เราเริ่มมองที่ระบบภายใน

นี่คือที่ระบบปฏิบัติการจริงจัดการทุกอย่าง ดังนั้น Instrumentation จะเริ่มต้นกิจกรรมได้อย่างไร พารามิเตอร์thisในexecStartActivityวิธีการด้านบนคือกิจกรรมของคุณเช่นบริบทและการexecStartActivityใช้ประโยชน์จากบริบทนี้

ภาพรวม 30,000 รายการเป็นดังนี้: คลาส Instrumentation คอยติดตามรายการกิจกรรมที่ตรวจสอบเพื่อให้สามารถใช้งานได้ รายการนี้ใช้เพื่อประสานงานกิจกรรมทั้งหมดและตรวจสอบให้แน่ใจว่าทุกอย่างทำงานได้อย่างราบรื่นในการจัดการการไหลของกิจกรรม

มีการดำเนินการบางอย่างที่ฉันยังไม่ได้ตรวจสอบอย่างเต็มที่ว่าปัญหาของเธรดประสานงานและกระบวนการ ในท้ายที่สุดActivityResultจะใช้การดำเนินพื้นเมือง - ActivityManagerNative.getDefault().startActivity()ซึ่งใช้ที่คุณผ่านในเมื่อคุณเรียกว่าContext startActivityบริบทที่คุณส่งผ่านถูกใช้เพื่อช่วยใน“ การแก้ไขเจตนา” หากจำเป็น การแก้ไขด้วยเจตนา (Intent Resolution) เป็นกระบวนการที่ระบบสามารถกำหนดเป้าหมายของเจตนาได้หากไม่ได้กำหนดไว้ (ตรวจสอบคำแนะนำที่นี่เพื่อดูรายละเอียดเพิ่มเติม)

และในการสั่งซื้อสำหรับ Android Contextที่จะทำเช่นนี้ก็ต้องมีสิทธิ์เข้าถึงข้อมูลที่จัดทำโดย โดยเฉพาะอย่างยิ่งระบบจำเป็นต้องเข้าถึงเพื่อContentResolverให้สามารถ "กำหนดประเภทของข้อมูลเจตนาของ MIME" บิตทั้งหมดนี้เกี่ยวกับวิธีการstartActivityใช้บริบทนั้นซับซ้อนเล็กน้อยและฉันไม่เข้าใจ internals ด้วยตัวเองประเด็นหลักของฉัน เพื่อแสดงให้เห็นว่าจำเป็นต้องเข้าถึงทรัพยากรทั่วทั้งแอปพลิเคชันอย่างไรเพื่อดำเนินการต่างๆที่จำเป็นสำหรับแอปContextเป็นสิ่งที่ให้การเข้าถึงทรัพยากรเหล่านี้ตัวอย่างที่ง่ายกว่าอาจเป็น Views เราทุกคนรู้ว่าคุณสร้าง มุมมองที่กำหนดเองโดยการขยาย RelativeLayoutหรือViewชั้นอื่น ๆคุณต้องจัดให้มีคอนสตรัคเตอร์ที่ใช้Contextเป็นอาร์กิวเมนต์ เมื่อคุณสร้างอินสแตนซ์ของมุมมองที่กำหนดเองคุณจะผ่านในบริบท ทำไม? เนื่องจากมุมมองจำเป็นต้องสามารถเข้าถึงชุดรูปแบบทรัพยากรและรายละเอียดการกำหนดค่ามุมมองอื่น ๆ การกำหนดค่ามุมมองเป็นตัวอย่างที่ยอดเยี่ยม แต่ละบริบทมีพารามิเตอร์ต่าง ๆ (เขตข้อมูลในContextการใช้งานของ) ที่กำหนดโดยระบบปฏิบัติการของตัวเองสำหรับสิ่งต่าง ๆ เช่นมิติหรือความหนาแน่นของจอแสดงผล ง่ายที่จะดูว่าทำไมข้อมูลนี้มีความสำคัญต่อการตั้งค่า Views ฯลฯ

หนึ่งคำสุดท้าย: ด้วยเหตุผลบางอย่างที่ผู้ใช้ใหม่กับ Android (และแม้แต่คนที่ไม่ใหม่) ก็ดูเหมือนจะลืมเกี่ยวกับการเขียนโปรแกรมเชิงวัตถุอย่างสมบูรณ์เมื่อมันมาถึง Android ด้วยเหตุผลบางอย่างผู้คนพยายามงอการพัฒนา Android ของพวกเขาเพื่อกระบวนทัศน์ที่คิดล่วงหน้าหรือพฤติกรรมที่เรียนรู้

Android มีกระบวนทัศน์ของตัวเองและรูปแบบบางอย่างที่ค่อนข้างสอดคล้องกันหากปล่อยความคิดล่วงหน้าของคุณและอ่านเอกสารและคู่มือการพัฒนา อย่างไรก็ตามจุดที่แท้จริงของฉันในขณะที่“ ได้รับบริบทที่ถูกต้อง” นั้นบางครั้งอาจมีความยุ่งยากผู้คนตื่นตระหนกอย่างไม่เป็นธรรมเพราะพวกเขาพบสถานการณ์ที่พวกเขาต้องการบริบทและคิดว่าพวกเขาไม่มี อีกครั้ง Java เป็นภาษาเชิงวัตถุที่มีการออกแบบการสืบทอด

คุณ“ มี” บริบทภายในกิจกรรมของคุณเท่านั้นเพราะกิจกรรมของคุณสืบทอดมาจากบริบท ไม่มีเวทย์มนตร์ (ยกเว้นทุกสิ่งที่ระบบปฏิบัติการทำด้วยตัวเองเพื่อตั้งค่าพารามิเตอร์ต่าง ๆ และ "กำหนดค่า" บริบทของคุณอย่างถูกต้อง) ดังนั้นการวางปัญหาความจำ / ประสิทธิภาพไว้ข้างๆกัน (เช่นการอ้างถึงบริบทเมื่อคุณไม่ต้องการหรือทำมันในลักษณะที่มีผลกระทบด้านลบต่อหน่วยความจำ ฯลฯ ) บริบทคือวัตถุที่เหมือนกันและสามารถส่งผ่านได้ เช่นเดียวกับ POJO ใด ๆ (วัตถุ Java เก่าแบบธรรมดา) บางครั้งคุณอาจต้องทำสิ่งที่ฉลาดเพื่อดึงบริบทนั้น แต่คลาส Java ปกติใด ๆ ที่ขยายจากไม่มีสิ่งอื่นใดนอกจากตัววัตถุเองสามารถเขียนได้ในลักษณะที่สามารถเข้าถึงบริบทได้ เพียงเปิดเผยวิธีสาธารณะที่ใช้บริบทและจากนั้นใช้ในชั้นเรียนตามที่ต้องการ

บริบทเป็นตัวจัดการกับระบบ มันให้บริการเช่นการแก้ไขทรัพยากรการเข้าถึงฐานข้อมูลและการกำหนดลักษณะและอื่น ๆ แอพ Android มีกิจกรรม บริบทเป็นเหมือนตัวจัดการสภาพแวดล้อมที่แอปพลิเคชันของคุณกำลังทำงานอยู่วัตถุกิจกรรมสืบทอดวัตถุบริบท

สำหรับข้อมูลเพิ่มเติมโปรดดูในเบื้องต้นเกี่ยวกับการพัฒนาของ Android กับ Android สตูดิโอ - การสอน

Contextเป็น "ส่วนต่อประสาน" สำหรับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน ในทางปฏิบัติContextจริง ๆ แล้วเป็นคลาสนามธรรมซึ่งมีการใช้งานโดยระบบ Android

อนุญาตให้เข้าถึงทรัพยากรและคลาสเฉพาะของแอปพลิเคชันรวมถึงการเรียกใช้สำหรับการดำเนินการระดับแอปพลิเคชันเช่นการเปิดตัวกิจกรรมการแพร่ภาพและการรับเจตนา ฯลฯ

ในภาพต่อไปนี้คุณสามารถเห็นลำดับชั้นของคลาสโดยที่Contextคลาสรูทของลำดับชั้นนี้อยู่ที่ไหน โดยเฉพาะอย่างยิ่งมันคุ้มค่าเน้นว่าเป็นลูกหลานของActivityContext

อะไรContextกันแน่

ตามเอกสารอ้างอิง Android เป็นเอนทิตีที่แสดงถึงข้อมูลสภาพแวดล้อมที่หลากหลาย มันให้การเข้าถึงไฟล์ท้องถิ่นฐานข้อมูลคลาสรถตักที่เกี่ยวข้องกับสภาพแวดล้อมบริการ (รวมถึงบริการระดับระบบ) และอื่น ๆ ตลอดหนังสือเล่มนี้และในการเขียนโปรแกรมแบบวันต่อวันกับ Android คุณจะเห็นบริบทที่ส่งผ่านบ่อยครั้ง

จาก " Android ในทางปฏิบัติ ", p. 60

API Android หลายตัวต้องการ Contextพารามิเตอร์ as

หากคุณมองผ่าน Android API ต่าง ๆ คุณจะสังเกตเห็นว่าหลายคนใช้android.content.Contextวัตถุเป็นพารามิเตอร์ Contextนอกจากนี้คุณยังจะเห็นว่ากิจกรรมหรือบริการมักจะถูกนำมาใช้เป็น Contextงานนี้เพราะทั้งสองของชั้นเรียนเหล่านี้ขยายจาก

ตัวอย่างง่าย ๆ ที่จะเข้าใจcontextใน Android:

เจ้านายทุกคนมีผู้ช่วยดูแลทำภารกิจที่สำคัญและใช้เวลาน้อยกว่า หากจำเป็นต้องใช้ไฟล์หรือกาแฟหนึ่งถ้วยผู้ช่วยจะดำเนินการต่อไป ผู้บังคับบัญชาบางคนแทบไม่รู้ว่าเกิดอะไรขึ้นในสำนักงานดังนั้นพวกเขาจึงถามผู้ช่วยเกี่ยวกับเรื่องนี้ด้วย พวกเขาทำงานบางอย่างด้วยตัวเอง แต่สำหรับสิ่งอื่น ๆ ส่วนใหญ่พวกเขาต้องการความช่วยเหลือจากผู้ช่วย

ในสถานการณ์นี้

บอส - เป็นแอปพลิเคชั่น Android

ผู้ช่วย - คือบริบท

ไฟล์ / ถ้วยกาแฟ - เป็นแหล่งข้อมูล

โดยทั่วไปเราจะเรียกบริบทเมื่อต้องการรับข้อมูลเกี่ยวกับส่วนต่าง ๆ ของแอปพลิเคชันของเราเช่นกิจกรรมแอปพลิเคชันและอื่น ๆ

การดำเนินการบางอย่าง (สิ่งที่ต้องการผู้ช่วย) ที่เกี่ยวข้องกับบริบท:

• กำลังโหลดทรัพยากรทั่วไป
• การสร้างมุมมองแบบไดนามิก
• แสดงข้อความขนมปังปิ้ง
• การเปิดตัวกิจกรรม ฯลฯ

วิธีการรับบริบทที่แตกต่าง:

getContext()

getBaseContext()

getApplicationContext()

this

บริบท Android เป็นอินเทอร์เฟซ (ในความหมายทั่วไปไม่ได้อยู่ในความหมายของ Java ใน JavaContextเป็นจริงระดับนามธรรม!) ที่อนุญาตให้เข้าถึงทรัพยากรเฉพาะแอปพลิเคชันและคลาสและข้อมูลเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน

หากแอพ Android ของคุณเป็นเว็บแอปบริบทของคุณก็จะคล้าย ServletContext (ฉันไม่ได้ทำการเปรียบเทียบที่นี่เลย)

กิจกรรมและบริการของคุณยังขยายออกไปContextดังนั้นพวกเขาจึงสืบทอดวิธีการเหล่านั้นทั้งหมดเพื่อเข้าถึงข้อมูลสภาพแวดล้อมที่แอพกำลังทำงานอยู่

• Context แทนการจัดการเพื่อรับข้อมูลสภาพแวดล้อม
• Context ระดับของตัวเองถูกประกาศเป็นนามธรรมซึ่งการดำเนินการให้บริการโดย Android OS
• Context เปรียบเหมือนรีโมตทีวีและช่องในทีวีเป็นทรัพยากรบริการ ฯลฯ

คุณทำอะไรกับมันได้บ้าง

• กำลังโหลดทรัพยากร
• เปิดตัวกิจกรรมใหม่
• กำลังสร้างมุมมอง
• การรับบริการระบบ

วิธีรับบริบท:

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

เพียงแค่เอามันออกไปสำหรับมือใหม่;

ดังนั้นก่อนทำความเข้าใจบริบทของ Word:

ในภาษาอังกฤษ -Lib มันหมายถึง:

"สถานการณ์ที่ก่อให้เกิดการตั้งค่าสำหรับเหตุการณ์คำสั่งหรือความคิดและในแง่ที่สามารถเข้าใจและประเมินได้อย่างเต็มที่"

"ส่วนต่าง ๆ ของสิ่งที่เขียนหรือพูดที่นำหน้าและปฏิบัติตามคำหรือข้อความและอธิบายความหมายของมันในทันที"

ตอนนี้ใช้ความเข้าใจเดียวกันกับโลกของการเขียนโปรแกรม:

บริบทของสถานะปัจจุบันของแอปพลิเคชัน / วัตถุ ช่วยให้วัตถุที่เพิ่งสร้างใหม่เข้าใจสิ่งที่เกิดขึ้น โดยทั่วไปคุณจะเรียกมันเพื่อรับข้อมูลเกี่ยวกับส่วนอื่นของโปรแกรมของคุณ (กิจกรรมแพ็คเกจ / แอปพลิเคชัน)

คุณจะได้รับบริบทโดยเรียกgetApplicationContext(), getContext(), getBaseContext()หรือthis(เมื่ออยู่ในระดับกิจกรรม)

ในการรับบริบททุกที่ในแอปพลิเคชันให้ใช้รหัสต่อไปนี้:

สร้างคลาสใหม่AppContextภายในแอปพลิเคชัน 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;
    }
}

เมื่อใดก็ตามที่คุณต้องการบริบทแอปพลิเคชันในคลาสที่ไม่ใช่กิจกรรมให้เรียกใช้เมธอดนี้และคุณมีบริบทแอปพลิเคชัน

หวังว่าความช่วยเหลือนี้;)

คิดว่ามันเป็น VM ที่ได้ปิดกระบวนการแอปพลิเคชันหรือบริการที่กำลังทำงานอยู่สภาพแวดล้อม siled มีการเข้าถึงข้อมูลระบบพื้นฐานและทรัพยากรที่ได้รับอนุญาต คุณต้องการบริบทนั้นเพื่อรับบริการเหล่านั้น

บริบทเป็นการอ้างอิงไปยังวัตถุปัจจุบันเช่นนี้ บริบทยังอนุญาตให้เข้าถึงข้อมูลเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน

ห้องเรียน android.content.Contextให้การเชื่อมต่อกับระบบ Android และทรัพยากรของโครงการ เป็นอินเทอร์เฟซสำหรับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน

บริบทนี้ยังให้การเข้าถึงบริการ Android เช่นบริการตำแหน่ง

กิจกรรมและบริการขยายContextชั้นเรียน

บริบทเป็นอินสแตนซ์ของคลาส android.content.Context ให้การเชื่อมต่อกับระบบ Android ที่รันแอปพลิเคชัน ตัวอย่างเช่นคุณสามารถตรวจสอบขนาดของอุปกรณ์ปัจจุบันที่แสดงผ่านบริบท

นอกจากนี้ยังให้การเข้าถึงทรัพยากรของโครงการ เป็นอินเทอร์เฟซสำหรับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน

ชั้นบริบทยังให้การเข้าถึงบริการ Android เช่นผู้จัดการปลุกเพื่อเรียกเหตุการณ์ตามเวลา

กิจกรรมและบริการขยายคลาส Context ดังนั้นพวกเขาสามารถใช้โดยตรงในการเข้าถึงบริบท

บริบทเป็นส่วนต่อประสานกับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน เป็นคลาสนามธรรมซึ่งมีการใช้งานโดยAndroidระบบ

Context อนุญาตการเข้าถึงทรัพยากรและคลาสเฉพาะของแอปพลิเคชันรวมถึงการโทรสำหรับการทำงานระดับแอปพลิเคชันเช่น 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. */

สำหรับรายละเอียดเพิ่มเติมคุณสามารถเยี่ยมชมhttp://developer.android.com/reference/android/content/Context.html

บริบทนั้นใช้สำหรับการเข้าถึงทรัพยากรและรับรายละเอียดสภาพแวดล้อมของแอปพลิเคชัน (สำหรับบริบทแอปพลิเคชัน) หรือกิจกรรม (สำหรับบริบทของกิจกรรม) หรืออื่น ๆ ...

เพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำคุณควรใช้บริบทของแอปพลิเคชันสำหรับทุกองค์ประกอบที่ต้องการวัตถุบริบท .... สำหรับการคลิกเพิ่มเติมที่นี่

บริบทเป็นบริบทของสถานะปัจจุบันของแอปพลิเคชัน / วัตถุมันเป็นนิติบุคคลที่แสดงถึงข้อมูลสภาพแวดล้อมต่างๆ บริบทช่วยให้กิจกรรมปัจจุบันโต้ตอบกับสภาพแวดล้อมด้าน Android เช่นไฟล์ในเครื่องฐานข้อมูลตัวจัดการคลาสที่เกี่ยวข้องกับสภาพแวดล้อมบริการรวมถึงบริการระดับระบบและอื่น ๆ

บริบทเป็นตัวจัดการกับระบบ มันให้บริการเช่นการแก้ไขทรัพยากรการเข้าถึงฐานข้อมูลและการตั้งค่าและอื่น ๆ แอพ Android มีกิจกรรม มันเหมือนกับที่จับกับสภาพแวดล้อมที่แอปพลิเคชันของคุณกำลังทำงานอยู่วัตถุกิจกรรมสืบทอดวัตถุบริบท

วิธีการเรียกใช้ที่แตกต่างกันซึ่งคุณสามารถรับบริบท 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. หรือสิ่งนี้ (เมื่ออยู่ในคลาสกิจกรรม)

บริบทหมายถึง Android ทำความรู้จักกับกิจกรรมที่ฉันควรทำหรือดำเนินการ

1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); มันใช้ในสิ่งนี้ Context context = ActivityName.this;

2 -startActivity(new Intent(context,LoginActivity.class));

ในบริบทนี้หมายถึงกิจกรรมที่คุณต้องการไปที่กิจกรรมอื่น บริบทหรือ ActivityName.this เร็วกว่านี้คือ getContext และ getApplicatinContext

A Contextเป็นสิ่งที่พวกเราส่วนใหญ่เรียกว่าแอปพลิเคชันแอพลิเคชันมันทำโดยระบบ Android และสามารถทำสิ่งที่แอปพลิเคชันสามารถทำได้ ใน Tomcat บริบทเป็นสิ่งที่ฉันจะเรียกแอปพลิเคชันด้วย

มีบริบทเดียวที่มีกิจกรรมมากมายแต่ละกิจกรรมอาจมีหลายมุมมอง

เห็นได้ชัดว่าบางคนจะบอกว่ามันไม่เหมาะสมเพราะสิ่งนี้หรือพวกเขาอาจจะถูก แต่บอกว่าบริบทเป็นใบสมัครปัจจุบันของคุณจะช่วยให้คุณเข้าใจสิ่งที่คุณกำลังใส่ในพารามิเตอร์วิธีการ

บอสผู้ช่วยคล้ายคลึง

ช่วยให้มีการเปรียบเทียบขนาดเล็กก่อนที่จะดำน้ำลึกลงไปในด้านเทคนิคของบริบท

บอสทุกคนมีผู้ช่วยหรือใครสักคน (ทำธุระเด็ก) ที่ทำสิ่งที่สำคัญน้อยกว่าและเสียเวลามากขึ้นสำหรับเขา ตัวอย่างเช่นหากพวกเขาต้องการไฟล์หรือกาแฟผู้ช่วยก็จะเปิดขึ้น บอสจะไม่ทราบว่าเกิดอะไรขึ้นในพื้นหลัง แต่ไฟล์หรืองานจะถูกส่ง

So Here
Boss -
ผู้ช่วยแอปพลิเคชัน Android -
ไฟล์บริบทหรือถ้วยกาแฟ - ทรัพยากร

เว็บไซต์นักพัฒนา Android อย่างเป็นทางการพูดอะไรเกี่ยวกับบริบท

บริบทเป็นจุดเชื่อมต่อของคุณสำหรับทรัพยากรที่เกี่ยวข้องกับแอปพลิเคชัน

เรามาดูทรัพยากรหรืองานดังกล่าวกันบ้าง

• เปิดตัวกิจกรรม

• รับพา ธ สัมบูรณ์ไปยังไดเร็กทอรีแคชเฉพาะแอ็พพลิเคชันบนระบบไฟล์

• การพิจารณาว่าสิทธิ์ที่ได้รับอนุญาตสำหรับกระบวนการเฉพาะและ ID ผู้ใช้ที่ทำงานในระบบหรือไม่

• ตรวจสอบว่าคุณได้รับอนุญาตเฉพาะ

และอื่น ๆ
ดังนั้นหากแอปพลิเคชัน Android ต้องการเริ่มกิจกรรมมันจะตรงไปที่Context (Access Point) และContextคลาสให้ทรัพยากรกลับคืนมา (เจตนาในกรณีนี้)

เช่นเดียวกับคลาสอื่น ๆ ที่Contextมีเขตข้อมูลและวิธีการ
คุณสามารถสำรวจเพิ่มเติมเกี่ยวกับContextเอกสารอย่างเป็นทางการซึ่งครอบคลุมทุกอย่างวิธีการที่ใช้ได้ฟิลด์และแม้แต่วิธีใช้ฟิลด์ด้วยวิธีการต่างๆ

อินสแตนซ์ของคลาส android.content.Context จัดเตรียมการเชื่อมต่อกับระบบ Android ที่รันแอปพลิเคชัน ตัวอย่างเช่นคุณสามารถตรวจสอบขนาดของอุปกรณ์ปัจจุบันที่แสดงผ่านบริบท

นอกจากนี้ยังให้การเข้าถึงทรัพยากรของโครงการ เป็นอินเทอร์เฟซสำหรับข้อมูลทั่วโลกเกี่ยวกับสภาพแวดล้อมของแอปพลิเคชัน

ชั้นบริบทยังให้การเข้าถึงบริการ Android เช่นผู้จัดการปลุกเพื่อเรียกเหตุการณ์ตามเวลา

กิจกรรมและบริการขยายคลาส Context ดังนั้นพวกเขาสามารถใช้โดยตรงในการเข้าถึงบริบท

หากคุณต้องการเชื่อมต่อบริบทกับคลาสที่คุ้นเคยอื่น ๆ ใน Android โปรดจำไว้ว่าโครงสร้างนี้:

บริบท <ContextWrapper <แอปพลิเคชัน

บริบท <ContextWrapper <ContextThemeWrapper <กิจกรรม

บริบท <ContextWrapper <ContextThemeWrapper <กิจกรรม <ListActivity

บริบท <ContextWrapper <บริการ

บริบท <ContextWrapper <บริการ <IntentService

ดังนั้นคลาสเหล่านั้นทั้งหมดจึงเป็นบริบทของตนเอง คุณสามารถใช้บริการและListActivityเป็นบริบทได้หากต้องการ แต่ถ้าคุณมองอย่างใกล้ชิดคลาสบางคลาสจะสืบทอดธีมเช่นกัน ในกิจกรรมหรือชิ้นส่วนคุณต้องการให้มีการนำไปใช้กับมุมมองของคุณ แต่ไม่สนใจว่าจะเป็นService class เป็นต้น

ฉันอธิบายความแตกต่างในบริบทที่นี่

การใส่แอนดรอยด์Contextเป็นเรื่องง่ายที่คุณจะไม่รักจนกว่าคุณจะหยุดกังวล

Android Contextคือ:

• พระเจ้าวัตถุ

• สิ่งที่คุณต้องการส่งผ่านแอปพลิเคชันทั้งหมดของคุณเมื่อคุณเริ่มพัฒนาสำหรับ Android แต่จะหลีกเลี่ยงเมื่อคุณเข้าใกล้การเขียนโปรแกรมการทดสอบและ Android เอง

  • ไม่ชัดเจน

  • แหล่งที่มาทั่วไปของหน่วยความจำรั่ว

  • PITA สำหรับการทดสอบ

• บริบทจริงที่ใช้โดยระบบ Android เพื่อแจกจ่ายสิทธิ์ทรัพยากรการกำหนดลักษณะบริการการออกอากาศสไตล์การแสดงกล่องโต้ตอบและเค้าโครงพองตัว และคุณต้องการContextอินสแตนซ์ที่แตกต่างกันสำหรับบางสิ่งที่แยกจากกัน (เห็นได้ชัดว่าคุณไม่สามารถแสดงกล่องโต้ตอบจากแอปพลิเคชันหรือบริบทบริการรูปแบบที่ขยายเกินจริงจากแอปพลิเคชันและบริบทกิจกรรมอาจแตกต่างกัน)

บริบทเป็น API เฉพาะของ Android สำหรับแต่ละSandboxของแอป ที่ให้ข้อมูลส่วนตัวของแอปเข้าถึงเช่นทรัพยากรฐานข้อมูลไดเรกทอรีส่วนตัวการตั้งค่าการตั้งค่า ...

Privatedata ส่วนใหญ่จะเหมือนกันสำหรับกิจกรรม / บริการ / รายการออกอากาศทั้งหมดของแอปพลิเคชันเดียว

เนื่องจากแอปพลิเคชันกิจกรรมบริการจะใช้อินเทอร์เฟซบริบทซึ่งสามารถใช้ในกรณีที่การเรียก api ต้องการพารามิเตอร์ Context

Contextหมายถึงส่วนประกอบ (หรือแอปพลิเคชัน) ในช่วงเวลาต่างๆ ถ้าฉันกินอาหารมากมายระหว่าง 1 ถึง 2 น. บริบทของเวลานั้นจะถูกใช้เพื่อเข้าถึงวิธีการทั้งหมด (หรือทรัพยากร) ที่ฉันใช้ในช่วงเวลานั้น เนื้อหาเป็นองค์ประกอบ (แอปพลิเคชั่น) ในบางช่วงเวลา Contextของส่วนประกอบของแอปพลิเคชั่นจะเปลี่ยนไปตามวงจรชีวิตของส่วนประกอบหรือแอปพลิเคชัน ยกตัวอย่างเช่นภายใน onCreate () ของActivity,

getBaseContext()- ให้contextของActivityที่เป็นชุด (สร้าง) โดยสร้างของกิจกรรม getApplicationContext()- ให้การContextตั้งค่า (สร้าง) ระหว่างการสร้างแอปพลิเคชัน

หมายเหตุ: <application>ถือส่วนประกอบ Android ทั้งหมด

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

หมายความว่าเมื่อคุณโทรgetApplicationContext()จากภายในองค์ประกอบใด ๆ ก็ตามคุณกำลังเรียกบริบททั่วไปของแอปพลิเคชันทั้งหมด

Context ยังคงมีการแก้ไขโดยระบบตามวงจรชีวิตของส่วนประกอบ

นึกถึงบริบทเป็นกล่องที่มีทรัพยากรต่างกันเช่นสตริงสีและแบบอักษร หากคุณต้องการทรัพยากรคุณเปิดไปที่ช่องนี้ เมื่อคุณหมุนหน้าจอกล่องนี้จะเปลี่ยนเนื่องจากการวางแนวเปลี่ยนเป็นแนวนอน

 Contextหมายถึงปัจจุบัน Contextใช้เพื่อดำเนินการสำหรับหน้าจอปัจจุบัน อดีต
  1. getApplicationContext ()
  2. getContext ()

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

คำอธิบายที่ยอดเยี่ยม! เพื่อเติมเต็มทั้งหมดข้างต้นฉันพบสิ่งนี้จาก MindOrks ที่เป็นประโยชน์มากแม้จะแสดงกรณีการใช้งานขั้นพื้นฐานบางอย่างเพื่อให้ใจของคุณดำเนินต่อไป:

ทำความเข้าใจบริบทในแอปพลิเคชัน Android

ใน Java เราพูดคำสำคัญนี้อ้างถึงสถานะของวัตถุปัจจุบันของแอปพลิเคชัน
ในทำนองเดียวกันเรามีContextในการพัฒนา Android

สิ่งนี้สามารถกำหนดได้อย่างชัดเจนหรือโดยปริยาย

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

คุณลักษณะนี้ประกาศซึ่งกิจกรรมรูปแบบนี้มีความเกี่ยวข้องกับโดยค่าเริ่มต้น