แชร์เรื่องนี้
โดย Seven Peaks เมื่อ 26 ส.ค. 2021, 17:18:00
วิธีใช้ Kotlin flow
ผมชื่อ Vijay Patel ปัจจุบันทำงานในตำแหน่ง Senior Android Developer ที่ Seven Peaks Software ภายในบทความนี้ผมจะมาสอนวิธีการใช้งาน Kotlin flow ในแอปพลิเคชันบน Android ให้พวกคุณได้รู้จักและสามารถทำตามได้เอง
เนื้อหาของบทความนี้จะครอบคลุมทั้ง Kotlin flow และ channel ซึ่งทั้งสองฟีเจอร์นี้มีอยู่ในไลบรารี Kotlin Coroutine อยู่แล้ว
หนึ่งในความท้าทายที่เราต้องเจอคือ asynchrony
ความท้าทายของ asynchrony ที่เราต้องเจอนั้น ไม่ว่าการทำ network request หรือการอ่านฐานข้อมูล เป็นสิ่งที่เกิดขึ้นซ้ำๆ ตัวอย่างของความท้าทายภายใต้เรื่องของ asynchrony ก็คือ race condition
Android Kotlin Coroutines
หนึ่งในปัญหาที่เกิดขึ้นบ่อยคือสิ่งที่เรียกว่า backpressure
ระหว่างที่เรากำลังพัฒนาแอปพลิเคชันสำหรับ streaming อยู่ เราพบว่ามีปัญหา backpressure นี้เกิดขึ้น รวมถึงมีการรั่วไหลของทรัพยากรระบบและ thread
เรารู้ว่า thread นั้นเป็นสิ่งที่ expensive และสามารถทำให้เกิดปัญหา asynchrony อื่นๆ ได้อีกมากมาย
การแก้ไขปัญหา asynchrony นี้ใน Kotlin ได้นั้น เราต้องพัฒนาไลบรารีขึ้นมาตัวหนึ่ง เรียกว่า Coroutine ซึ่งเป็นกระดูกสันหลังของ Kotlin flow และ channel
ก่อนที่เราจะไปถึงเรื่องของ flows และ channel มาพูดถึงเรื่องของ Coroutines รวมถึงหลักการทำงานของ Coroutinesกันก่อน
ในฐานะที่เราเป็น Android developer กัน ผมมั่นใจว่าคุณคงเคยใช้งาน Kotlin Coroutine มาก่อน
ดังนั้น ผมอยากให้คุณรู้ว่าทำไม Kotlin Coroutine จึงทรงพลังมากในการสอนการใช้งาน Kotlin flow ของผมในครั้งนี้ ตัวอย่างบางฟีเจอร์ของ Kotlin Coroutine นั้นได้แก่ การที่มันมีขนาดเล็กและทำให้คุณสามารถรัน Coroutines หลายๆ ตัวใน thread เดียวได้ เนื่องจากระบบรองรับ suspension
ความท้าทายของ Asynchrony
- Race conditions
- Back pressure
- ทรัพยากรระบบรั่วไหล
- Threading (expensive, starvation, deadlocks)
- และอื่นๆ
ดังนั้น นี่คือสาเหตุว่าทำไมคุณต้องไม่บล็อก thread ที่ Coroutine กำลังรันอยู่ หนึ่งในฟีเจอร์ที่น่าทึ่งคือ suspension ที่ทำให้เกิดการรั่วไหลของความจำน้อยกว่า เนื่องจากการใช้ structured concurrency นอกจากนี้เรายังรองรับฟังก์ชัน cancel ที่ built-in อยู่ในระบบอีกด้วย
มี Jetpack Library มากมายที่รองรับการทำงานของ Coroutine อย่างเต็มรูปแบบ โดย Coroutine สามารถ suspend bean ได้ แปลว่า มันสามารถหยุดการทำงานชั่วคราวได้
พูดง่ายๆ ก็คือ มันทำงานเหมือนกับปุ่ม pause นั่นเอง
สมมติว่า Coroutine กำลังรันอยู่ใน thread มันก็สามารถหยุดการทำงานไว้ชั่วคราวแล้วทำงานต่อได้ภายหลัง เพื่อให้ thread สามารถสั่ง asynchronous process อื่นๆ หรือการเขียนโค้ดแบบอื่นๆ ได้
มันทำแบบนี้ได้ด้วยการเลือกว่าจะ suspend หรือทำงานต่อตอนไหน สมมติว่าเรามี Coroutine อยู่สองตัว ตัวหนึ่งอยู่ทางซ้าย อีกตัวอยู่ทางขวา ทั้งสองรันพร้อมๆ กัน
หมายความว่า thread สามารถตัดสินใจเลือกได้ว่า Coroutine ตัวไหนต้อง suspend แล้วตัวไหนสามารถทำงานต่อได้ แปลว่า thread สามารถสลับการทำงานระหว่าง Coroutine ได้ เรียกได้ว่าเกือบจะทำงานแบบผสมผสานกันเลย
ซึ่งสิ่งนี้จะไม่ไปบล็อก process อื่นๆ ขณะที่มันกำลังทำงานอยู่แต่อย่างใด
Channel ใน Kotlin
ต่อจากนั้น หากเราต้องการใช้งาน state บางอย่างใน Coroutine เช่น ใช้งาน change-of-state
หนึ่งในวิธีที่เราสามารถทำได้ก็คือการสื่อสารระหว่าง Coroutine ด้วยการใช้สิ่งที่เรียกว่า channels นั่นเอง
แต่ก่อนที่เราจะไปพูดถึง channel เราจำเป็นต้องเช็กให้แน่ใจก่อนว่าไม่ได้ไปยุ่งกับ shared-mutable-state เนื่องจากเราแค่ต้องการสื่อสารระหว่างสอง Coroutine เท่านั้น
เราไม่ต้องการแชร์ shared-mutable-state เราแค่ต้องการแชร์บาง state เท่านั้นพอ
แล้ว channel คืออะไร อันที่จริงมันก็เปรียบเสมือนท่อที่เราสามารถใช้และรับข้อมูลได้ เป็นเหมือน synchronization primitive ที่ทำงานแบบ synchronous นั่นเอง
เราสามารถส่งข้อมูลบางอย่างเข้าไปแล้วมันก็จะส่งข้อมูลบางอย่างออกมาเหมือน non-blocking queue ซึ่งมันจะมี suspending function ที่แยกออกมาเพื่อส่งข้อมูลไปยัง channel และมีอีก suspending function ที่แยกออกมาเพื่อรับข้อมูลเช่นกัน
สามารถดูเดโมนี้ของผมเพื่อทำความเข้าใจได้ว่า channel ทำงานอย่างไร
ดูวิดีโอ live coding สาธิตการใช้งาน Kotlin Flow ได้ข้างล่างนี้
การใช้งาน Kotlin Flow ในแอปพลิเคชัน Android โดย Vijay
AndroidX Biometrics API
ผมชื่อ Sifat ผมเองก็ทำงานอยู่ที่ Seven Peaks Software เช่นกัน โดยทำตำแหน่ง Senior Android Developer ผมจะมาพูดถึงเรื่องของ analytic biometrics, AndroidX Biometrics API, วิธีการใช้งาน biometric บน Android, และวิธีการนำ analytics biometric มาใช้กับโปรเจกต์ของคุณ
ก่อนอื่น ด้วยความที่เราต่างก็เป็น Android developer กันหมด ผมจึงคิดว่าเราน่าจะมีประสบการณ์ในการใช้ AndroidX Biometrics API เหมือนๆ กัน โดยเฉพาะอย่างยิ่งในแอปพลิเคชันกระเป๋าเงินดิจิทัลหรือแอปพลิเคชันของธนาคาร
AndroidX Biometrics API เป็นไลบรารีที่มีชุดของ API ให้เราใช้งานสำหรับการ integrate แอปฯ Android เข้ากับ biometric authentication
อันดับแรก fingerprint manager นั้นเริ่มมีให้ใช้งานตั้งแต่ Android 6 หรือก็คือ API level 23 ซึ่งมีสองปัญหาเกี่ยวกับ fingerprint manager ปัญหาแรกคือ มันไม่มี UI เลย ส่วนปัญหาที่สองคือ มันอนุญาตให้นักพัฒนาเข้าถึงได้แค่เซนเซอร์ลายนิ้วมือเท่านั้น
อย่างที่รู้กันว่า biometric ประเภทอื่นนั้นได้รับความนิยมมากขึ้นในปัจจุบัน เช่น การยืนยันตัวตนด้วยใบหน้า เป็นต้น
ดังนั้น นักพัฒนาจึงเริ่มส่งเสียงให้ฟีดแบ็กในทิศทางเดียวกันว่ามันไม่มี UI ซึ่งหมายความว่านักพัฒนาจำเป็นต้องสร้าง UI แบบคัสตอมขึ้นมาเอง และยังมีปัญหาอื่นอีกเพราะว่าอุปกรณ์ที่แตกต่างกันก็ใช้เซนเซอร์ไม่เหมือนกันด้วย
ยกตัวอย่าง เช่น อุปกรณ์บางตัวมีเซนเซอร์ในหน้าจอแสดงผล แต่บางตัวมีเซนเซอร์อยู่ด้านหลัง ดังนั้นนักพัฒนาจึงต้องสร้าง UI แบบคัสตอมขึ้นมาเพื่อรองรับเซนเซอร์ที่แตกต่างกัน
เมื่อทีม Google Framework และทีมดูแลด้านความปลอดภัยได้รับฟีดแบ็กดังกล่าวก็เริ่มแก้ไขปัญหาใน Android 9 ที่พวกเขาเผยแพร่ fingerprint UI policy ออกมา พร้อมด้วย biometric prompt
biometric prompt ไม่ใช่แค่ทำให้เราสามารถเข้าถึงเซนเซอร์ลายนิ้วมือเท่านั้น แต่ยังเข้าถึง biometric sensor อื่นๆ ที่นักพัฒนาสามารถใช้ในการยืนยันตัวตนผู้ใช้ได้อีกด้วย
เวอร์ชันที่เริ่มมีให้ใช้และสิ่งที่ทำงานอยู่เบื้องหลัง
Android 6 (API 23)
- FingerprintManager
Android 9 (API 28)
- FingerPrint UI policy
- BiometricPrompt
Android 10 (API 29)
- BiometricManager
นอกจากนี้ มันยังมี UI เรียบๆ ให้ใช้งาน ซึ่งนักพัฒนาสามารถปรับแต่งและกำหนดพารามิเตอร์บางอย่างเข้าไปได้ แถมยังไม่ต้องสร้าง UI ขึ้นมาใหม่ตั้งแต่ต้นอีกต่อไป
ข้อดีอีกอย่างก็คือ ผู้ผลิตอุปกรณ์สามารถปรับแต่ง UI ให้เหมาะกับความต้องการของอุปกรณ์ที่พวกเขาผลิตได้ จากนั้นใน Android 10 ก็มี biometric manager ออกมาให้ใช้งาน
biometric manager ทำให้เรามี API สำหรับตรวจสอบว่าอุปกรณ์รองรับการยืนยันตัวตนด้วย biometric หรือไม่ และยังมีตัวเลือกสำรองให้นำมาใช้ได้ด้วย ดังนั้น ถ้าเราต้องการใช้การปลดล็อกด้วยวิธีอื่นที่ไม่ใช่ biometric เช่น PIN, รหัสผ่าน, หรือ แพตเทิร์น เพื่อเป็นตัวเลือกสำรองจากการยืนยันตัวตนด้วย biometric เราก็สามารถทำได้
การรองรับเวอร์ชันเก่า
API 23
- รองรับ biometric authentication
API 21
- ปลดล็อกอุปกรณ์ด้วยรหัส (PIN, รหัสผ่าน, หรือแพตเทิร์น)
การรองรับเวอร์ชันเก่าของ AndroidX Biometrics API รองรับย้อนไปถึง API 23 และถ้าคุณต้องการใช้การปลดล็อกอุปกรณ์ด้วย PIN, รหัสผ่าน, หรือแพตเทิร์น ก็สามารถใช้ได้จนถึง API 21 เลยทีเดียว
ต่อไปนี้คือขั้นตอนการนำไลบรารีไปใช้กับโปรเจกต์ของคุณ ซึ่งมีด้วยกันทั้งหมด 5 ขั้นตอน ได้แก่
ขั้นตอนการนำไปใช้งาน
- เพิ่ม Gradle dependency เข้าไปในโมดูลของแอปฯ คุณ
- เช็กว่าอุปกรณ์รองรับ biometric authentication หรือไม่
- สร้าง PromptInfo object ขึ้นมาอันหนึ่ง
- สร้าง instance ของ BiometricPrompt ขึ้นมาหนึ่งอัน
- บอกให้ผู้ใช้ยืนยันตัวตน
ก่อนอื่น เราจำเป็นต้องเพิ่ม library dependency เข้าไปในโมดูลของแอปฯ จากนั้น เราต้องเช็กว่าอุปกรณ์รองรับ biometric authentication หรือไม่
ต่อมา เราต้องสร้าง prompt สำหรับ object เพื่อสร้าง biometric prompt จากนั้นเราก็ต้องบอกผู้ใช้ให้ยืนยันตัวตน
สามารถดูขั้นตอนทั้งหมดอย่างละเอียดได้ที่วิดีโอนี้ของผม
วิธีใช้งาน biometric ใน Android
อย่างแรกสุด Gradle dependency รุ่นเสถียรคือ 1.1.0
คุณสามารถเพิ่ม dependency นี้เข้าไปในไฟล์ Gradle ในระดับ app level แล้ว sync โปรเจกต์เพื่อเข้าถึงการทำงานของ AndroidX Biometrics API
การเพิ่ม Gradle Dependency
ให้ implement ‘androidx.biometric:biometric:1.1.0’ เข้าไป
จากนั้น คุณจะต้องเช็กว่าอุปกรณ์รองรับ biometric authentication หรือไม่
คุณต้องส่งค่าของ integer ไปยังพารามิเตอร์ หมายความว่าค่าของ integer จะแทนชนิดของการยืนยันตัวตนที่คุณกำลังต้องการใช้ ซึ่งทำให้คุณสามารถส่งหนึ่งในสาม authenticator ของ BIOMETRIC_WEAK สำหรับฐานข้อมูลการยืนยันตัวตน และใช้วิธียืนยันตัวตนด้วย PIN, รหัสผ่าน, หรือแพตเทิร์น ได้
เช็กการรองรับ biometric ของอุปกรณ์
BiometricManager.canAuthenticate(int)
Authenticators:
- BIOMETRIC_WEAK สำหรับการยืนยันตัวตนแบบ non-crypto
- BIOMETRIC_STRONG สำหรับการยืนยันตัวตนแบบ crypto-based
- DEVICE_CREDENTIAL สำหรับการยืนยันตัวตนที่ไม่ใช้ biometric
ในตอนนี้คุณก็สามารถ combine flag ได้ด้วยเช่นกัน
ถ้าหากคุณต้องการเพิ่มการยืนยันตัวตนด้วยรหัสเป็นตัวเลือกสำรองของ biometric authenticatio คุณก็สามารถ combine BIOMETRIC_WEAK กับ DEVICE_CREDENTIAL และสร้าง flag ใหม่ได้
คุณต้องจำเอาไว้ว่า API นั้นไม่สามารถรองรับทุกรูปแบบการยืนยันตัวตนที่ผสมกันได้ ยกตัวอย่างเช่น คุณไม่สามารถผสม BIOMETRIC_STRONG กับ DEVICE_CREDENTIAL และไม่สามารถผสม API level 28 กับ 29 ได้
และในรุ่นก่อนหน้า API 30 คุณก็ไม่สามารถใช้งาน DEVICE_CREDENTIAL แค่อย่างเดียวได้
นี่คือสิ่งที่คุณต้องพิจารณาและสร้าง prompt ขึ้นมารองรับ การสร้าง PromptInfo คือแนวทางที่เราใช้เพื่อกำหนด metadata และ configuration สำหรับ biometric prompt
การสร้าง prompt นั้น เราจะใช้วิธีตั้งค่าในการแสดงผล โดยคุณสามารถกำหนด title, subtitle, และ description ของ biometric prompt ซึ่งจริงๆ แล้วมีวิธีอื่นเหมือนกัน แต่ผมอยากพูดถึงสองวิธีหลักๆ ต่อไปนี้
วิธีแรกคือ setAllowedAuthenticators(int)
ซึ่งจากรูปข้างล่าง คุณจะเห็นว่าคุณต้องส่งค่า integer นั่นหมายความว่ามันเป็นรูปแบบการยืนยันตัวตนแบบที่คุณต้องการใช้
ถ้าคุณต้องการใช้การยืนยันตัวตนแบบใช้รหัสเป็นตัวเลือกสำรอง คุณก็สามารถเพิ่มมันได้ตรงนี้ นอกจากนี้ก็มีอีกวิธีคือ setConfirmationRequired(boolean) ที่เราสามารถเปิดหรือปิดการทำงานได้ด้วยปุ่มยืนยัน
ถ้าเราเปิดการทำงาน มันจะเพิ่มเลเยอร์ของการยืนยันเข้าไปอีกชั้นหนึ่ง
หมายความว่า ผู้ใช้ต้องกดปุ่มยืนยันเพื่อยืนยันตัวตนพร้อมด้วย biometric authentication
สำหรับ biometric prompt เราจำเป็นต้องใช้ component 4 ตัวด้วยกัน ตัวแรกคือ FragmentActivity หรือ Fragment ซึ่งเป็นที่ที่ biometric prompt จะรับ fragment manager และ context จากนั้นก็เป็น prompt ที่เราเพิ่งสร้างไป
การสร้าง BiometricPrompt
BiometricPrompt ต้องการ 4 component นี้ถึงจะทำงานได้:
- FragmentActivity หรือ Fragment
- PromptInfo object
- AuthenticationCallback:
onAuthenticationSucceeded()
onAuthenticationError()
onAuthenticationFailed()- Executor หนึ่งตัว (มีหรือไม่มีก็ได้)
ContextCompat.getMainExecutor()
จากนั้น คุณต้องเพิ่ม AuthenticationCallback เข้าไป เพื่อให้ method 3 ตัวดังกล่าวทำงานได้
ดูวิดีโอนี้ ของผมเพื่อทำความเข้าใจแบบละเอียดได้
ตามที่ชื่อของมันบอกไว้ เมื่อยืนยันตัวตนสำเร็จแล้ว onAuthenticationSucceeded() จะถูกเรียก ส่วน onAuthenticationError() จะถูกเรียกถ้าหากมี error อะไรก็ตามที่ไม่สามารถแก้ไขได้เกิดขึ้น
ซึ่ง error เหล่านี้อาจเกิดขึ้นได้เมื่อผู้ใช้กดปุ่ม back หรือยังไม่ได้บันทึกข้อมูล biometric ลงในระบบ หรืออุปกรณ์ไม่รองรับ biometric authentication
ในกรณีเหล่านี้ คุณจะได้รับ callback จาก onAuthenticationError() และอันต่อไปคือ onAuthenticationFailed()
หมายความว่า ในช่วงแรกมันจะถูกเรียกถ้าผู้ใช้กรอกรหัสไม่ถูกต้อง ยกตัวอย่างเช่น ถ้าผู้ใช้ใส่รหัส PIN ผิด หรือใช้นิ้วอื่นมาวางบนเซนเซอร์ error method นี้ก็จะทำงาน
แต่ onAuthenticationFailed() จะต่างจาก method สองตัวแรกตรงที่มันไม่ใช่ terminal method หมายความว่าถ้าคุณใช้ failed method ผู้ใช้ยังสามารถยืนยันตัวเองได้ โดยที่คุณสามารถรับ subsequent call และได้รับ callback ไม่ว่ามันจะผ่านหรือเกิด error ก็ตาม ข้อผิดพลาดที่เกิดขึ้นจึงไม่ใช่ terminal callback สำหรับเรื่องนี้
ตัวสุดท้ายคือ เราต้องส่งค่า Executor หนึ่งตัว (มีหรือไม่มีก็ได้)
ตามค่า default แล้ว callback method ของ Executor จะแสดงว่า state หรือ callback ไหนที่จะถูก execute ซึ่งเป็น thread เดียวกันกับที่ biometric authentication โดนเรียก แต่ถ้าคุณต้องการจริงๆ คุณก็สามารถประกาศ thread ที่แยกกันได้ หรือถ้าคุณอยากให้ callback นี้รันบน UI ก็สามารถทำได้
ต่อไปคือการแสดงผล authentication dialog ให้ผู้ใช้เห็น การแสดงผล prompt นี้สามารถทำได้ง่ายๆ เพียงแค่เรียก biometric prompt หรือ authentication ด้วย PromptInfo ที่เราสร้างไว้ก่อนหน้านี้
เราสามารถยกเลิก biometric prompt ได้ด้วยการเขียนโค้ดที่เรียก BiometricPrompt.cancelAuthentication()
บอกให้ผู้ใช้ยืนยันตัวตน
แสดง Prompt:
- BiometricPrompt.authenticate(promptInfo)
ยกเลิก Prompt:
- BiometricPrompt.cancelAuthentication()
ดูวิดีโอ live coding สาธิตการใช้ AndroidX Biometrics API ได้ที่ลิงก์ข้างล่างนี้
AndroidX Biometric โดย Sifat
Navigation ของ Android
สวัสดีครับทุกคน ผมชื่อ Dmitrii มีตำแหน่งเป็น Android Technical Lead ที่ Seven Peaks Software ผมจะมาพูดถึงเรื่อง navigation ของ Android และการ implement navigation ในแอปพลิเคชัน Android
เอาละ มาดูกันว่า navigation ของ Android คืออะไร และวิธี implement มันในแอปฯ ของเรา ต้องทำอย่างไรบ้าง
ลองดูโฟลว์การทำงานในรูปข้างล่างนี้ เมื่อแอปพลิเคชันของคุณมีเพียงแค่สองสามหน้า navigation ก็จะดูเรียบง่ายมากๆ
คุณแค่ต้องใช้ Android launcher ที่สามารถแตะที่ไอคอนของแอปพลิเคชันคุณแล้วก็ทำหน้าแรกเอาไว้ จาก action ที่เกิดขึ้นบนหน้านี้ คุณต้องเลื่อนไปยังหน้าอื่นๆ ต่อไปเรื่อยๆ
แต่ถ้าแอปฯ คุณมีหน้าจำนวนมากมาย และมี action หลายอย่างเกิดขึ้นในแอปพลิเคชันของคุณ รวมทั้งมีภาระในการทำ deep link และมีการใช้งานเครื่องมือภายนอกล่ะ จะทำอย่างไร แอปพลิเคชันอาจดูยุ่งเหยิง และคุณก็ต้อง implement คลาสเพิ่มเติมเพื่อทำเรื่องเหล่านี้
Manager เพิ่มเติมบางตัวอาจจะเป็น controller และเนื่องจาก Android ไม่ได้มีรูปแบบที่ตายตัวในเรื่องนี้หรือมี requirement ที่เข้มงวดอะไรเกี่ยวกับ navigation คุณจึงต้องเข้าใจเรื่องนี้อย่างชัดเจนในการสร้างแอปฯ
ปกติแล้ว เราจะใช้วิธีสองสามอย่างในการ implement อันดับแรก เราสามารถสลับระหว่างหน้าจอในแอปฯ ของเราได้ มาดูรายละเอียดกัน
หากคุณสามารถรองรับหลายๆ activity ได้ด้วยรูปแบบ multiple activity ง่ายๆ นี้ คุณก็สามารถใช้มันเพื่อสลับหน้าได้
ในแอปพลิเคชันบน Android ที่ใช้รูปแบบนี้ ทุกหน้าคือหนึ่ง activity ที่สามารถส่งผู้ใช้ไปยังอีกหน้าได้ แน่นอนว่าสามารถนำผู้ใช้กลับมาหน้าเดิมได้เช่นกัน
ซึ่งรูปแบบนี้เป็นสิ่งที่พบเห็นได้ทั่วไป และมีให้ใช้งานตั้งแต่ Android เวอร์ชันแรก นี่เป็นวิธีที่ง่ายที่สุดในการนำ navigation มา integrate แต่ว่ามันก็มีข้อเสียบางอย่างอยู่
หนึ่งในข้อเสียก็คือการประเมินว่าผู้ใช้จะใช้ activity ต่างๆ ในแอปพลิเคชันอย่างไร ซึ่งอาจเกิด overhead ขึ้นมากมายเนื่องจากเป็นสิ่งที่หนักระบบ และเรายังต้อง implement navigation manager ที่เอาไว้จัดการ การสลับการทำงานระหว่างหน้าจออีกด้วย
ทันทีที่เรามีสองหน้าจอ logic ในการ integrate ระหว่างหน้าอาจกลายเป็นเรื่องที่ซับซ้อนมากๆ
อีกรูปแบบหนึ่งที่เราสามารถนำมาใช้ได้คือ single activity เมื่อเราต้องการเพียงแค่ activity เดียวในแอปพลิเคชันของเรา และ implement ทุกหน้าให้อยู่ในรูปแบบของ fragment ซึ่งเราสามารถใช้มันใน MainActivity หรือหลายๆ activity ที่เรามีในแอปฯ ได้ เช่น FrameLayout หรือ container ใดๆ ก็ตาม ที่เราสามารถนำมาใช้เป็น content holder สำหรับ fragment ได้
เราสามารถใช้หนึ่งหรือมากว่าหนึ่ง activity ได้ ขึ้นอยู่กับโซลูชันของเราและความต้องการทางธุรกิจ
ในด้านหนึ่ง มันก็ช่วยทำให้ navigation มีความเรียบง่ายมากขึ้นเพราะว่ามันมี fragment อยู่หลายตัว ซึ่งมีขนาดเล็กกว่า activity
แต่เราก็ต้องเจอกับปัญหาที่เหมือนหรือคล้ายกันตรงที่เรามีเลเยอร์ที่ต้อง implement เพิ่ม เช่น component เสริม, manager เสริม, หรือ controller เสริม เพื่อจัดการกับการสลับหน้านั่นเอง
เราจำเป็นต้องใช้โซลูชันภายนอกบางอย่างเพื่อแก้ไขปัญหานี้
Android navigation components ที่ผมแนะนำไปก่อนหน้านี้เป็นชุดของไลบรารีใหม่ที่ได้รับความนิยมสูงมากในช่วงที่ผ่านมา ซึ่งมีการนำมาใช้ implement navigation ในแอปฯ บน Android ด้วยวิธีการทันสมัย
Navigation component นั้นมี Android navigation controller และ navigation graph บรรจุอยู่แล้ว โดยมันสามารถบรรจุ graph กลุ่มเล็กๆ ที่คุณต้องการได้
Navigation graph ก็เหมือนกับ fragment, dialogue, หรือ view ที่ทำงานเกี่ยวกับ fragment ซึ่ง action หรือทิศทางระหว่าง fragment เหล่านี้สามารถนำมาใช้ในการสลับหน้าได้
สามารถดูวิดีโอ live coding นี้ของผมได้เพื่อดูว่ามันทำงานอย่างไร