วงจรชีวิตของกิจกรรม

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

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

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

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

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

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

สำหรับข้อมูลเกี่ยวกับการจัดการวงจร รวมถึงคำแนะนำเกี่ยวกับ โปรดดูแนวทางปฏิบัติที่ดีที่สุดที่ การจัดการวงจรด้วยคอมโพเนนต์ Lifecycle-Aware และบันทึกสถานะ UI เพื่อเรียนรู้วิธีสถาปนิกแอปที่มีคุณภาพและคุณภาพเวอร์ชันที่ใช้งานจริงโดยใช้กิจกรรมใน ร่วมกับองค์ประกอบทางสถาปัตยกรรม โปรดดู คำแนะนำเกี่ยวกับสถาปัตยกรรมแอป

แนวคิดของวงจรกิจกรรม

หากต้องการไปยังส่วนต่างๆ ของการเปลี่ยนระหว่างระยะต่างๆ ของวงจรกิจกรรม คลาส Activity มีชุด Callback หลัก 6 รายการ ได้แก่ onCreate(), onStart(), onResume(), onPause(), onStop() และ onDestroy() ระบบจะเรียกใช้ Callback แต่ละรายการเหล่านี้เมื่อกิจกรรมเข้าสู่สถานะใหม่

รูปที่ 1 แสดงภาพของกระบวนทัศน์นี้

รูปที่ 1 ประสบการณ์ที่เรียบง่าย ภาพวงจรของกิจกรรม

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

หากผู้ใช้กลับไปที่กิจกรรม กลับมาทำงานอีกครั้งจากจุดที่ผู้ใช้ปิดค้างไว้ โดยมีข้อยกเว้นบางประการต่อไปนี้ ถูกจำกัดจาก เริ่มกิจกรรมเมื่อทำงานในเบื้องหลัง

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

ทั้งนี้ขึ้นอยู่กับความซับซ้อนของกิจกรรมของคุณ คุณอาจไม่ต้อง ดำเนินการตามวงจรทั้งหมด อย่างไรก็ตาม คุณควร ทำความเข้าใจแต่ละแบบ และใช้คำเหล่านั้นที่ทำให้แอปของคุณทำงาน ในแบบที่ผู้ใช้คาดหวัง

Callback ของวงจร

ส่วนนี้จะแสดงข้อมูลแนวคิดและการติดตั้งใช้งานเกี่ยวกับ เมธอด Callback ที่ใช้ในวงจรกิจกรรม

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

onCreate()

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

ตัวอย่างเช่น การใช้ onCreate() อาจเชื่อมโยงข้อมูลกับรายการ หรือเชื่อมโยงกิจกรรมกับ ViewModel, และสร้างอินสแตนซ์ตัวแปรขอบเขตคลาสบางรายการ เมธอดนี้จะได้รับค่า พารามิเตอร์ savedInstanceState ซึ่งก็คือ Bundle ซึ่งมีสถานะที่บันทึกไว้ก่อนหน้านี้ของกิจกรรม หากกิจกรรมมี ไม่เคยมีอยู่มาก่อน ค่าของออบเจ็กต์ Bundle เป็นค่าว่าง

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

ตัวอย่างต่อไปนี้ของเมธอด onCreate() แสดงการตั้งค่าพื้นฐานของกิจกรรม เช่น การประกาศอินเทอร์เฟซผู้ใช้ (กำหนดไว้ในไฟล์รูปแบบ XML) การกำหนดตัวแปรสมาชิก และการกำหนดค่า UI บางส่วน ในตัวอย่างนี้ ไฟล์เลย์เอาต์ XML จะส่ง รหัสทรัพยากร R.layout.main_activity ของไฟล์ไปยัง setContentView()

Kotlin

lateinit var textView: TextView

// Some transient state for the activity instance.
var gameState: String? = null

override fun onCreate(savedInstanceState: Bundle?) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState)

    // Recover the instance state.
    gameState = savedInstanceState?.getString(GAME_STATE_KEY)

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity)

    // Initialize member TextView so it is available later.
    textView = findViewById(R.id.text_view)
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    textView.text = savedInstanceState?.getString(TEXT_VIEW_KEY)
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
override fun onSaveInstanceState(outState: Bundle?) {
    outState?.run {
        putString(GAME_STATE_KEY, gameState)
        putString(TEXT_VIEW_KEY, textView.text.toString())
    }
    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState)
}

Java

TextView textView;

// Some transient state for the activity instance.
String gameState;

@Override
public void onCreate(Bundle savedInstanceState) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState);

    // Recover the instance state.
    if (savedInstanceState != null) {
        gameState = savedInstanceState.getString(GAME_STATE_KEY);
    }

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity);

    // Initialize member TextView so it is available later.
    textView = (TextView) findViewById(R.id.text_view);
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    textView.setText(savedInstanceState.getString(TEXT_VIEW_KEY));
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
@Override
public void onSaveInstanceState(Bundle outState) {
    outState.putString(GAME_STATE_KEY, gameState);
    outState.putString(TEXT_VIEW_KEY, textView.getText());

    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState);
}

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

กิจกรรมของคุณไม่คงอยู่ในส่วน "สร้างแล้ว" หลังจากดำเนินการเมธอด onCreate() เสร็จแล้ว กิจกรรมจะเข้าสู่ Started และระบบเรียก onStart() และ onResume() เมธอดได้ในทันที การสืบทอด

onStart()

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

เมื่อกิจกรรมย้ายไปที่สถานะ "เริ่มต้น" คอมโพเนนต์ที่รับรู้ถึงวงจรชีวิตใดๆ จะเชื่อมโยง ให้กับวงจรของกิจกรรม ON_START

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

onResume()

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

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

เมื่อเกิดเหตุการณ์รบกวน กิจกรรมจะเข้าสู่พารามิเตอร์ pause และระบบจะเรียกใช้ onPause() Callback

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

นี่คือตัวอย่างของคอมโพเนนต์ที่คำนึงถึงวงจรที่เข้าถึงกล้องเมื่อ คอมโพเนนต์ได้รับเหตุการณ์ ON_RESUME:

Kotlin

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun initializeCamera() {
        if (camera == null) {
            getCamera()
        }
    }
    ...
}

Java

public class CameraComponent implements LifecycleObserver {

    ...

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void initializeCamera() {
        if (camera == null) {
            getCamera();
        }
    }
    ...
}

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

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

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

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

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

ข้อมูลโค้ดก่อนหน้านี้จะใส่โค้ดการเริ่มต้นกล้องไว้ใน คอมโพเนนต์ที่รับรู้ทุกวงจร คุณสามารถวางโค้ดนี้ลงในกิจกรรมได้โดยตรงแทน Lifecycle Callback เช่น onStart() และ onStop() แต่เราไม่แนะนำให้ทำเช่นนี้ การเพิ่มตรรกะนี้ ไปยังคอมโพเนนต์อิสระที่คำนึงถึงอายุการใช้งานช่วยให้คุณใช้คอมโพเนนต์ซ้ำได้ ในหลายกิจกรรมโดยไม่ต้องทำโค้ดซ้ำ หากต้องการดูวิธีสร้างคอมโพเนนต์ที่รับรู้ทุกวงจร โปรดดู การจัดการวงจรด้วยคอมโพเนนต์ Lifecycle-Aware

onPause()

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

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

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

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

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

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

ตัวอย่างต่อไปนี้ของ LifecycleObserver การตอบสนองต่อเหตุการณ์ ON_PAUSE นั้นมาจากเหตุการณ์ก่อนหน้า ตัวอย่างเหตุการณ์ ON_RESUME รายการ การปล่อยกล้องที่เริ่มต้นหลังจาก ได้รับเหตุการณ์ ON_RESUME แล้ว

Kotlin

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun releaseCamera() {
        camera?.release()
        camera = null
    }
    ...
}

Java

public class JavaCameraComponent implements LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void releaseCamera() {
        if (camera != null) {
            camera.release();
            camera = null;
        }
    }
    ...
}

ตัวอย่างนี้วางโค้ดรุ่นของกล้องไว้หลัง LifecycleObserver ได้รับเหตุการณ์ ON_PAUSE แล้ว

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

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

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

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

onStop()

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

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

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

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

Kotlin

override fun onStop() {
    // Call the superclass method first.
    super.onStop()

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    val values = ContentValues().apply {
        put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText())
        put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle())
    }

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate(
            token,     // int token to correlate calls
            null,      // cookie, not used here
            uri,       // The URI for the note to update.
            values,    // The map of column names and new values to apply to them.
            null,      // No SELECT criteria are used.
            null       // No WHERE columns are used.
    )
}

Java

@Override
protected void onStop() {
    // Call the superclass method first.
    super.onStop();

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    ContentValues values = new ContentValues();
    values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
    values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate (
            mToken,  // int token to correlate calls
            null,    // cookie, not used here
            uri,    // The URI for the note to update.
            values,  // The map of column names and new values to apply to them.
            null,    // No SELECT criteria are used.
            null     // No WHERE columns are used.
    );
}

ตัวอย่างโค้ดก่อนหน้านี้ใช้ SQLite โดยตรง แต่เราขอแนะนําให้ใช้ "ห้องแชท" ไลบรารีความต่อเนื่องที่ให้เลเยอร์นามธรรมบน SQLite เพื่อเรียนรู้ ข้อมูลเพิ่มเติมเกี่ยวกับประโยชน์ของการใช้ Room และวิธีใช้ Room ในแอป โปรดดู ไลบรารี Room Persistence

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

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

หมายเหตุ: เมื่อกิจกรรมหยุดแล้ว ระบบจะ อาจทำลายกระบวนการที่มีกิจกรรมหากระบบ ต้องการกู้คืนความทรงจำ แม้ว่าระบบจะทำลายกระบวนการในขณะที่กิจกรรม หยุดทำงาน ระบบยังคงรักษาสถานะของ View ไว้ เช่น ข้อความในวิดเจ็ต EditText ใน Bundle - Blob ของคู่คีย์-ค่าและกู้คืน หากผู้ใช้กลับไปที่กิจกรรม สำหรับ ข้อมูลเพิ่มเติมเกี่ยวกับการกู้คืนกิจกรรมที่ผู้ใช้กลับมา โปรดดู ส่วนเกี่ยวกับการบันทึกและกู้คืนสถานะ

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

onDestroy()

มีการเรียก onDestroy() ก่อนการเรียก กิจกรรมจะถูกทำลาย ระบบเรียกใช้ Callback นี้เนื่องจากเหตุผล 1 ใน 2 ประการต่อไปนี้

  1. กิจกรรมเสร็จสิ้นแล้วเนื่องจากผู้ใช้ปิด กิจกรรมหรือเนื่องจาก finish() กำลัง ในกิจกรรม
  2. ระบบกำลังทำลายกิจกรรมชั่วคราวเนื่องจากมีการกำหนดค่า เช่น การหมุนอุปกรณ์ หรือการเข้าสู่โหมดหลายหน้าต่าง

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

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

หากไม่มีการสร้าง Activity ขึ้นใหม่ ViewModel จะมีค่า มีการเรียกเมธอด onCleared() โดยที่ จึงสามารถล้างข้อมูลที่ต้องใช้ก่อนที่จะถูกทำลาย คุณสามารถแยกความแตกต่างระหว่าง 2 สถานการณ์นี้ได้ด้วย isFinishing()

หากกิจกรรมเสร็จสิ้น onDestroy() จะเป็นการเรียกกลับสำหรับวงจรสุดท้าย กิจกรรมที่ได้รับ หากมีการเรียก onDestroy() จากการกำหนดค่า ระบบจะสร้างอินสแตนซ์กิจกรรมใหม่ในทันที แล้วจึงเรียกใช้ onCreate() บนอินสแตนซ์ใหม่ในการกำหนดค่าใหม่

Callback onDestroy() จะเผยแพร่ทรัพยากรทั้งหมดที่ไม่ได้เผยแพร่โดยก่อนหน้านี้ Callback เช่น onStop()

สถานะกิจกรรมและการดีดออกจากหน่วยความจำ

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

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

ตาราง 1 ความสัมพันธ์ระหว่างวงจรของกระบวนการและสถานะกิจกรรม

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

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

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับกระบวนการ โปรดดู กระบวนการและชุดข้อความ ภาพรวม

การบันทึกและคืนค่าสถานะ UI ชั่วคราว

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

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

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

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

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

สถานะอินสแตนซ์

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

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

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

ข้อมูลที่บันทึกไว้ซึ่งระบบใช้เพื่อกู้คืน สถานะก่อนหน้าเรียกว่าสถานะอินสแตนซ์ คอลเล็กชัน คู่คีย์-ค่าที่เก็บไว้ในออบเจ็กต์ Bundle โดยค่าเริ่มต้น แอตทริบิวต์ ระบบใช้สถานะอินสแตนซ์ Bundle เพื่อบันทึกข้อมูล เกี่ยวกับออบเจ็กต์ View แต่ละรายการในเลย์เอาต์กิจกรรม เช่น ค่าข้อความที่ป้อนลงใน วิดเจ็ต EditText

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

หมายเหตุ: เพื่อให้ระบบ Android คืนค่าสถานะ ข้อมูลพร็อพเพอร์ตี้ในกิจกรรมของคุณ ข้อมูลพร็อพเพอร์ตี้แต่ละรายการต้องมีรหัสที่ไม่ซ้ำกัน ซึ่งกำหนดให้โดย android:id

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

บันทึกสถานะ UI ที่เรียบง่ายและใช้ทรัพยากรน้อยโดยใช้ onSaveInstanceState()

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

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

Kotlin

override fun onSaveInstanceState(outState: Bundle?) {
    // Save the user's current game state.
    outState?.run {
        putInt(STATE_SCORE, currentScore)
        putInt(STATE_LEVEL, currentLevel)
    }

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(outState)
}

companion object {
    val STATE_SCORE = "playerScore"
    val STATE_LEVEL = "playerLevel"
}

Java

static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
// ...


@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the user's current game state.
    savedInstanceState.putInt(STATE_SCORE, currentScore);
    savedInstanceState.putInt(STATE_LEVEL, currentLevel);

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(savedInstanceState);
}

หมายเหตุ: onSaveInstanceState() ไม่ใช่ เรียกเมื่อผู้ใช้ปิดกิจกรรมอย่างชัดเจน หรือในกรณีอื่นๆ มีการเรียก finish()

วิธีบันทึกข้อมูลถาวร เช่น ค่ากำหนดของผู้ใช้หรือข้อมูลสำหรับฐานข้อมูล ใช้โอกาสที่เหมาะสมเมื่อกิจกรรมอยู่ในเบื้องหน้า หากไม่มีโอกาส ให้บันทึกข้อมูลถาวรระหว่าง onStop()

คืนค่าสถานะ UI กิจกรรมโดยใช้สถานะอินสแตนซ์ที่บันทึกไว้

เมื่อสร้างกิจกรรมอีกครั้งหลังจากที่ระบบทำลายไปแล้วก่อนหน้านี้ สามารถกู้คืนสถานะอินสแตนซ์ที่บันทึกไว้จาก Bundle ที่ ไปยังกิจกรรมของคุณ ทั้ง onCreate() และ onRestoreInstanceState() เมธอด Callback จะได้รับ Bundle เดียวกันกับที่มี ข้อมูลสถานะอินสแตนซ์

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

ตัวอย่างข้อมูลโค้ดต่อไปนี้แสดงวิธีกู้คืน ข้อมูลสถานะในonCreate():

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState) // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        with(savedInstanceState) {
            // Restore value of members from saved state.
            currentScore = getInt(STATE_SCORE)
            currentLevel = getInt(STATE_LEVEL)
        }
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        // Restore value of members from saved state.
        currentScore = savedInstanceState.getInt(STATE_SCORE);
        currentLevel = savedInstanceState.getInt(STATE_LEVEL);
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

แทนที่จะกู้คืนรัฐในระหว่าง onCreate() คุณเลือกใช้งาน onRestoreInstanceState() ซึ่งระบบเรียกใช้หลังจาก onStart() การเรียกใช้ระบบ onRestoreInstanceState() เฉพาะเมื่อมีสถานะที่บันทึกไว้ให้คืนค่า ไม่ต้องตรวจสอบว่า Bundle เป็นค่าว่างหรือไม่

Kotlin

override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState)

    // Restore state members from saved instance.
    savedInstanceState?.run {
        currentScore = getInt(STATE_SCORE)
        currentLevel = getInt(STATE_LEVEL)
    }
}

Java

public void onRestoreInstanceState(Bundle savedInstanceState) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState);

    // Restore state members from saved instance.
    currentScore = savedInstanceState.getInt(STATE_SCORE);
    currentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

ข้อควรระวัง: เรียกใช้การใช้งานซูเปอร์คลาสของ onRestoreInstanceState() ดังนั้นการใช้งานเริ่มต้นจะคืนค่าสถานะของลำดับชั้นการแสดงผลได้

ไปยังส่วนต่างๆ ระหว่างกิจกรรม

แอปมีแนวโน้มที่จะเข้าและออกจากกิจกรรม ซึ่งหลายครั้งในช่วงระหว่าง อายุการใช้งานของแอป เช่น เมื่อผู้ใช้แตะปุ่ม "กลับ" ของอุปกรณ์ หรือกิจกรรมนั้นเริ่มต้นกิจกรรมอื่น

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

กำลังเริ่มกิจกรรมหนึ่งจากอีกกิจกรรมหนึ่ง

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

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

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

startActivity()

หากกิจกรรมที่เริ่มต้นใหม่ไม่จำเป็นต้องส่งคืนผลลัพธ์ กิจกรรมปัจจุบันสามารถเริ่มได้ โดยการเรียก startActivity()

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

Kotlin

val intent = Intent(this, SignInActivity::class.java)
startActivity(intent)

Java

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

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

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

Kotlin

val intent = Intent(Intent.ACTION_SEND).apply {
    putExtra(Intent.EXTRA_EMAIL, recipientArray)
}
startActivity(intent)

Java

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

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

startActivityForResult()

บางครั้งคุณก็ต้องการรับผลการค้นหากลับจากกิจกรรมเมื่อกิจกรรมสิ้นสุดลง ตัวอย่างเช่น คุณอาจเริ่ม กิจกรรมที่ให้ผู้ใช้เลือกบุคคลในรายชื่อรายชื่อติดต่อ เมื่อสิ้นสุดผลิตภัณฑ์จะแสดงผล บุคคลที่ถูกเลือก ในการดำเนินการนี้ คุณเรียก startActivityForResult(Intent, int) ที่ พารามิเตอร์จำนวนเต็มจะระบุการเรียก

ตัวระบุนี้มีไว้เพื่อแยกความแตกต่างระหว่างการเรียกหลายครั้งไปยัง startActivityForResult(Intent, int) จากกิจกรรมเดียวกัน ไม่ใช่ตัวระบุส่วนกลาง และไม่เสี่ยงต่อการขัดแย้งกับแอปหรือกิจกรรมอื่นๆ ผลลัพธ์ที่ได้จะมาจาก onActivityResult(int, int, Intent)

เมื่อออกจากกิจกรรมของบุตรหลานแล้ว จะสามารถโทรหา setResult(int) เพื่อ ส่งคืนข้อมูลให้ระดับบน กิจกรรมย่อยต้องระบุรหัสผลลัพธ์ ซึ่งอาจเป็นผลลัพธ์มาตรฐาน RESULT_CANCELED, RESULT_OK หรือค่าที่กำหนดเองทั้งหมด เริ่มต้นที่ RESULT_FIRST_USER

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

หากกิจกรรมย่อยล้มเหลวด้วยเหตุผลใดก็ตาม เช่น ขัดข้อง กิจกรรมหลัก กิจกรรมจะได้รับผลลัพธ์ที่มีรหัส RESULT_CANCELED

Kotlin

class MyActivity : Activity() {
    // ...

    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
            // When the user center presses, let them pick a contact.
            startActivityForResult(
                    Intent(Intent.ACTION_PICK,Uri.parse("content://contacts")),
                    PICK_CONTACT_REQUEST)
            return true
        }
        return false
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
        when (requestCode) {
            PICK_CONTACT_REQUEST ->
                if (resultCode == RESULT_OK) {
                    // A contact was picked. Display it to the user.
                    startActivity(Intent(Intent.ACTION_VIEW, intent?.data))
                }
        }
    }

    companion object {
        internal val PICK_CONTACT_REQUEST = 0
    }
}

Java

public class MyActivity extends Activity {
     // ...

     static final int PICK_CONTACT_REQUEST = 0;

     public boolean onKeyDown(int keyCode, KeyEvent event) {
         if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
             // When the user center presses, let them pick a contact.
             startActivityForResult(
                 new Intent(Intent.ACTION_PICK,
                 new Uri("content://contacts")),
                 PICK_CONTACT_REQUEST);
            return true;
         }
         return false;
     }

     protected void onActivityResult(int requestCode, int resultCode,
             Intent data) {
         if (requestCode == PICK_CONTACT_REQUEST) {
             if (resultCode == RESULT_OK) {
                 // A contact was picked. Display it to the user.
                 startActivity(new Intent(Intent.ACTION_VIEW, data));
             }
         }
     }
 }

ประสานงานกิจกรรม

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

มีการกำหนดลำดับของ Callback สำหรับวงจรการใช้งานไว้อย่างชัดเจน โดยเฉพาะเมื่อทั้ง 2 กิจกรรม โดยใช้กระบวนการเดียวกัน ซึ่งก็คือแอปเดียวกัน และอีกแอปหนึ่งกำลังเริ่มต้นอีกแอปหนึ่ง ต่อไปนี้เป็นลำดับการดำเนินการที่เกิดขึ้น เมื่อกิจกรรม A เริ่มต้นกิจกรรม B

  1. เมธอด onPause() ของกิจกรรม A ดำเนินการ
  2. onCreate() ของกิจกรรม ข onStart() และ onResume() เมธอดดำเนินการตามลำดับ กิจกรรม B มุ่งเน้นไปที่ผู้ใช้ได้แล้ว
  3. หากกิจกรรม A ไม่ปรากฏบนหน้าจออีกต่อไป ระบบจะใช้เมธอด onStop() ของกิจกรรม

ลำดับการเรียกกลับสำหรับวงจรนี้ทำให้คุณสามารถจัดการการเปลี่ยน จากกิจกรรมหนึ่งไปยังอีกกิจกรรมหนึ่ง