การจัดการวงจรด้วยคอมโพเนนต์ที่รับรู้ถึงวงจร (มุมมอง)

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

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

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

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

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

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

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Java

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

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

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

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

แพ็กเกจ androidx.lifecycle มีคลาสและอินเทอร์เฟซที่ช่วยให้คุณจัดการปัญหาเหล่านี้ได้อย่างยืดหยุ่นและแยกต่างหาก

อายุการใช้งาน

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

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

กิจกรรม

เหตุการณ์ในวงจรที่ส่งมาจากเฟรมเวิร์กและคลาส Lifecycle เหตุการณ์เหล่านี้จะแมปกับเหตุการณ์ Callback ในกิจกรรมและ Fragment

รัฐ

สถานะปัจจุบันของคอมโพเนนต์ที่ติดตามโดยออบเจ็กต์ Lifecycle

รูปที่ 1 สถานะและเหตุการณ์ของวงจรกิจกรรม Android

ให้คิดว่าสถานะเป็นโหนดของกราฟและเหตุการณ์เป็นขอบระหว่างโหนดเหล่านี้

คลาสสามารถตรวจสอบสถานะวงจรของคอมโพเนนต์ได้โดยใช้ DefaultLifecycleObserver และลบล้างเมธอดที่เกี่ยวข้อง เช่น onCreate, onStart เป็นต้น จากนั้นคุณสามารถเพิ่มผู้สังเกตการณ์ได้โดยเรียกใช้เมธอด addObserver() ของคลาส Lifecycle และส่งอินสแตนซ์ของผู้สังเกตการณ์ ดังที่แสดงในตัวอย่างต่อไปนี้

Kotlin

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

Java

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

ในตัวอย่างข้างต้น ออบเจ็กต์ myLifecycleOwner จะใช้อินเทอร์เฟซ LifecycleOwner ซึ่งอธิบายไว้ในส่วนต่อไปนี้

LifecycleOwner

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

อินเทอร์เฟซนี้จะแยกการเป็นเจ้าของ Lifecycle ออกจากคลาสแต่ละคลาส เช่น Fragment และ AppCompatActivity และอนุญาตให้เขียนคอมโพเนนต์ที่ทำงานร่วมกับคลาสเหล่านั้นได้ คลาสแอปพลิเคชันที่กำหนดเองสามารถใช้อินเทอร์เฟซ LifecycleOwner ได้

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

สำหรับตัวอย่างการติดตามตำแหน่ง เราสามารถทำให้คลาส MyLocationListener ใช้ DefaultLifecycleObserver แล้วเริ่มต้นด้วย Lifecycle ของกิจกรรมในเมธอด onCreate() ซึ่งจะช่วยให้คลาส MyLocationListener ทำงานได้ด้วยตนเอง หมายความว่าตรรกะในการตอบสนองต่อการเปลี่ยนแปลงสถานะวงจรจะได้รับการประกาศใน MyLocationListener แทนกิจกรรม การจัดเก็บตรรกะของคอมโพเนนต์แต่ละรายการจะช่วยให้จัดการตรรกะของกิจกรรมและ Fragment ได้ง่ายขึ้น

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
            // update UI
        });
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
  }
}

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

เพื่อให้กรณีการใช้งานนี้เป็นเรื่องง่าย คลาส Lifecycle จะอนุญาตให้ออบเจ็กต์อื่นๆ ค้นหาสถานะปัจจุบันได้

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

Java

class MyLocationListener implements DefaultLifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

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

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

การติดตั้งใช้งาน LifecycleOwner ที่กำหนดเอง

Fragment และ Activity ใน Support Library 26.1.0 ขึ้นไปใช้อินเทอร์เฟซ LifecycleOwner อยู่แล้ว

หากมีคลาสที่กำหนดเองซึ่งต้องการทำให้เป็น LifecycleOwner คุณสามารถใช้คลาส LifecycleRegistry ได้ แต่ต้องส่งต่อเหตุการณ์ ไปยังคลาสนั้น ดังที่แสดงในตัวอย่างโค้ดต่อไปนี้

Kotlin

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

แนวทางปฏิบัติแนะนำสำหรับคอมโพเนนต์ที่รับรู้วงจร

  • ทำให้ UI Controller (กิจกรรมและ Fragment) มีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้ โดยไม่ควรพยายามรับข้อมูลของตนเอง แต่ให้ใช้ ViewModel เพื่อดำเนินการดังกล่าว และสังเกตออบเจ็กต์ LiveData เพื่อแสดงการเปลี่ยนแปลงกลับไปยังมุมมอง
  • ลองเขียน UI ที่ขับเคลื่อนด้วยข้อมูลซึ่งหน้าที่ของ UI Controller คือการอัปเดตมุมมองเมื่อข้อมูลมีการเปลี่ยนแปลง หรือแจ้งเตือนการดำเนินการของผู้ใช้กลับไปยัง ViewModel
  • ใส่ตรรกะข้อมูลในคลาส ViewModel ViewModel ควรทำหน้าที่เป็นตัวเชื่อมต่อระหว่างตัวควบคุม UI กับส่วนที่เหลือของแอป แต่โปรดทราบว่าการดึงข้อมูล (เช่น จากเครือข่าย) ไม่ใช่หน้าที่ของ ViewModel แต่ ViewModel ควรเรียกคอมโพเนนต์ที่เหมาะสมเพื่อดึงข้อมูล แล้วส่งผลลัพธ์กลับไปยังตัวควบคุม UI
  • ใช้การเชื่อมโยงข้อมูลเพื่อรักษาอินเทอร์เฟซที่สะอาดตาระหว่างมุมมองและตัวควบคุม UI ซึ่งจะช่วยให้คุณสร้างมุมมองที่ชัดเจนมากขึ้นและลดโค้ดอัปเดตที่ต้องเขียนในกิจกรรมและ Fragment หากต้องการดำเนินการนี้ในภาษาโปรแกรม Java ให้ใช้ไลบรารีอย่าง Butter Knife เพื่อหลีกเลี่ยงโค้ด Boilerplate และมีการแยกข้อมูลที่ดีขึ้น
  • หาก UI ของคุณซับซ้อน ให้พิจารณาสร้างคลาส presenter เพื่อจัดการการแก้ไข UI ซึ่งอาจเป็นงานที่ต้องใช้ความพยายาม แต่จะช่วยให้ทดสอบคอมโพเนนต์ UI ได้ง่ายขึ้น
  • หลีกเลี่ยงการอ้างอิงบริบท View หรือ Activity ใน ViewModel หาก ViewModel มีอายุการใช้งานนานกว่ากิจกรรม (ในกรณีที่มีการเปลี่ยนแปลงการกำหนดค่า) กิจกรรมจะรั่วไหลและไม่ได้รับการกำจัดอย่างเหมาะสมโดย Garbage Collector
  • ใช้ Kotlin Coroutine เพื่อจัดการงานที่ใช้เวลานานและการดำเนินการอื่นๆ ที่ทำงานแบบอะซิงโครนัสได้

กรณีการใช้งานสำหรับคอมโพเนนต์ที่รับรู้ถึงวงจรชีวิต

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

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

การจัดการเหตุการณ์การหยุด

เมื่อ Lifecycle เป็นของ AppCompatActivity หรือ Fragment สถานะของ Lifecycle จะเปลี่ยนเป็น CREATED และระบบจะส่งเหตุการณ์ ON_STOP เมื่อมีการเรียกใช้ onSaveInstanceState() ของ AppCompatActivity หรือ Fragment

เมื่อบันทึกสถานะของ Fragment หรือ AppCompatActivity โดยใช้ onSaveInstanceState ระบบจะถือว่า UI ของสถานะดังกล่าวเปลี่ยนแปลงไม่ได้จนกว่าจะมีการเรียกใช้ ON_START การพยายามแก้ไข UI หลังจากบันทึกสถานะแล้วมีแนวโน้มที่จะทำให้สถานะการนำทางของแอปพลิเคชันไม่สอดคล้องกัน ซึ่งเป็นสาเหตุที่ FragmentManager แสดงข้อยกเว้นหากแอปเรียกใช้ FragmentTransaction หลังจากบันทึกสถานะแล้ว ดูรายละเอียดได้ที่ commit()

LiveData ป้องกันกรณีที่เกิดขึ้นไม่บ่อยนี้ได้ทันทีโดยงดเว้นการเรียกใช้ Observer หาก Lifecycle ที่เชื่อมโยงกับ Observer ไม่ได้อยู่ในสถานะ STARTED เป็นอย่างน้อย เบื้องหลัง ระบบจะเรียกใช้ isAtLeast() ก่อนตัดสินใจเรียกใช้ Observer

แต่ระบบจะเรียกใช้เมธอด onStop() ของ AppCompatActivity หลังจาก onSaveInstanceState ซึ่งทำให้เกิดช่องว่างที่ไม่อนุญาตให้เปลี่ยนแปลงสถานะ UI แต่ยังไม่ได้ย้าย Lifecycle ไปยังสถานะ CREATED

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

แต่โซลูชันนี้มีปัญหาสำคัญ 2 ประการ ได้แก่

  • ใน API ระดับ 23 และต่ำกว่า ระบบ Android จะบันทึกสถานะของกิจกรรมไว้แม้ว่ากิจกรรมนั้นจะถูกกิจกรรมอื่นบดบังบางส่วนก็ตาม กล่าวคือ ระบบ Android จะเรียกใช้ onSaveInstanceState() แต่ไม่จำเป็นต้องเรียกใช้ onStop ซึ่งจะสร้างช่วงเวลาที่อาจยาวนานซึ่งผู้สังเกตการณ์ยังคงคิดว่าวงจรทำงานอยู่ แม้ว่าจะแก้ไขสถานะ UI ไม่ได้ก็ตาม
  • คลาสใดก็ตามที่ต้องการแสดงลักษณะการทำงานที่คล้ายกับคลาส LiveData ต้องใช้วิธีแก้ปัญหาชั่วคราวที่ Lifecycle เวอร์ชัน beta 2 และต่ำกว่ามีให้

แหล่งข้อมูลเพิ่มเติม

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

Codelab

บล็อก