Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

วงจรกิจกรรม (มุมมอง)

แนวคิดและการติดตั้งใช้งาน Jetpack Compose

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Lifecycle Callback

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

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

onCreate

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

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

หากคุณมีคอมโพเนนต์ที่รับรู้ถึงวงจรการใช้งานซึ่งเชื่อมต่อกับวงจรการใช้งานของ กิจกรรม คอมโพเนนต์นั้นจะได้รับเหตุการณ์ 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);
}

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

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

onStart

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

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

onStart เมธอดจะเสร็จสมบูรณ์อย่างรวดเร็ว และเช่นเดียวกับสถานะ Created กิจกรรมจะไม่อยู่ในสถานะ Started เมื่อการเรียกกลับนี้เสร็จสิ้น กิจกรรมจะเข้าสู่สถานะResumed และระบบจะเรียกใช้เมธอด onResume

onResume

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

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

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

หากกิจกรรมเปลี่ยนจากสถานะหยุดชั่วคราวกลับไปเป็นสถานะกลับมาทำงานต่อ ระบบจะเรียกใช้เมธอด 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

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

onPause

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

เหตุการณ์ที่ขัดจังหวะการเรียกใช้แอปตามที่อธิบายไว้ในส่วนเกี่ยวกับ การเรียกกลับ 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;
        }
    }
    ...
}

ตัวอย่างนี้จะวางโค้ดการปล่อยกล้องหลังจากที่ ON_PAUSE ได้รับLifecycleObserver

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

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

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

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

onStop

เมื่อกิจกรรมไม่ปรากฏต่อผู้ใช้แล้ว กิจกรรมจะเข้าสู่สถานะหยุด และระบบจะเรียกใช้การเรียกกลับ onStop ปัญหานี้อาจเกิดขึ้นเมื่อ กิจกรรมที่เพิ่งเปิดตัวครอบคลุมทั้งหน้าจอ ระบบจะเรียกใช้ 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 โดยตรง อย่างไรก็ตาม เราขอแนะนำให้ใช้ Room ซึ่งเป็นไลบรารีการคงอยู่ที่มีเลเยอร์การแยกข้อมูลเหนือ SQLite ดูข้อมูลเพิ่มเติมเกี่ยวกับประโยชน์ของการใช้ Room และวิธีติดตั้งใช้งาน Room ในแอปได้ที่คู่มือไลบรารี Room Persistence

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

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

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

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

onDestroy

onDestroy จะเรียกใช้ก่อนที่กิจกรรมจะถูกทำลาย ระบบจะเรียกใช้แฮนเดิล นี้ด้วยเหตุผล 2 ประการต่อไปนี้

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

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

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

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

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

การเรียกกลับ onDestroy จะปล่อยทรัพยากรทั้งหมดที่การเรียกกลับก่อนหน้าไม่ได้ปล่อย เช่น onStop

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

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

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

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

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

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

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

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

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

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

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

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

บันทึกสถานะ UI ที่เรียบง่ายและมีน้ำหนักเบาโดยใช้ onSaveInstanceState

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

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

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);
}

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

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

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

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

ข้อมูลโค้ดต่อไปนี้แสดงวิธีคืนค่าข้อมูลสถานะบางอย่างใน 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.
    }
    // ...
}

คุณสามารถเลือกใช้ onStart แทนการกู้คืนสถานะระหว่าง 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);
}

การไปยังกิจกรรมต่างๆ

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

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

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

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

คุณจะเริ่มกิจกรรมใหม่โดยใช้เมธอด 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 ที่ อธิบายการดำเนินการที่ต้องการทำได้ และระบบจะเปิด กิจกรรมที่เหมาะสมจากแอปพลิเคชันอื่น หากมีกิจกรรมหลายรายการที่สามารถ จัดการ 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 คืออาร์เรย์สตริงของอีเมล ที่จะส่งอีเมลไปให้ เมื่อแอปพลิเคชันอีเมลตอบสนองต่อ 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 จะทับซ้อนกับกระบวนการหยุดรายการแรก

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

เมธอด onPause ของกิจกรรม A จะทํางาน
เมธอด onCreate, onStart และ onResume ของกิจกรรม B จะทำงานตามลำดับ ตอนนี้กิจกรรม B มีโฟกัสของผู้ใช้แล้ว
หากกิจกรรม A ไม่ปรากฏบนหน้าจออีกต่อไป ระบบจะเรียกใช้เมธอด onStop ของกิจกรรม

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