บทความและข่าวสาร | Seven Peaks Insights

วิธีใช้ Kotlin Flow, Biometrics API, และ Navigation บน Android

1920 - Kotlin Flows

c003a22e-14b3-4881-bcee-74ad2bb38d9b

วิธีใช้ 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 อื่นๆ ได้อีกมากมาย

Utilizing-Kotlin-Flows-in-an-Android-application-300x169-1


การแก้ไขปัญหา asynchrony นี้ใน Kotlin ได้นั้น เราต้องพัฒนาไลบรารีขึ้นมาตัวหนึ่ง เรียกว่า Coroutine ซึ่งเป็นกระดูกสันหลังของ Kotlin flow และ channel

ก่อนที่เราจะไปถึงเรื่องของ flows และ channel มาพูดถึงเรื่องของ Coroutines รวมถึงหลักการทำงานของ Coroutinesกันก่อน

ในฐานะที่เราเป็น Android developer กัน ผมมั่นใจว่าคุณคงเคยใช้งาน Kotlin Coroutine มาก่อน

ดังนั้น ผมอยากให้คุณรู้ว่าทำไม Kotlin Coroutine จึงทรงพลังมากในการสอนการใช้งาน Kotlin flow ของผมในครั้งนี้ ตัวอย่างบางฟีเจอร์ของ Kotlin Coroutine นั้นได้แก่ การที่มันมีขนาดเล็กและทำให้คุณสามารถรัน Coroutines หลายๆ ตัวใน thread เดียวได้ เนื่องจากระบบรองรับ suspension

ความท้าทายของ Asynchrony

  1. Race conditions
  2. Back pressure
  3. ทรัพยากรระบบรั่วไหล
  4. Threading (expensive, starvation, deadlocks)
  5. และอื่นๆ

ดังนั้น นี่คือสาเหตุว่าทำไมคุณต้องไม่บล็อก thread ที่ Coroutine กำลังรันอยู่ หนึ่งในฟีเจอร์ที่น่าทึ่งคือ suspension ที่ทำให้เกิดการรั่วไหลของความจำน้อยกว่า เนื่องจากการใช้ structured concurrency นอกจากนี้เรายังรองรับฟังก์ชัน cancel ที่ built-in อยู่ในระบบอีกด้วย

มี Jetpack Library มากมายที่รองรับการทำงานของ Coroutine อย่างเต็มรูปแบบ โดย Coroutine สามารถ suspend bean ได้ แปลว่า มันสามารถหยุดการทำงานชั่วคราวได้

Utilizing-Kotlin-Flows-in-an-Android-application-1-300x169

พูดง่ายๆ ก็คือ มันทำงานเหมือนกับปุ่ม pause นั่นเอง

สมมติว่า Coroutine กำลังรันอยู่ใน thread มันก็สามารถหยุดการทำงานไว้ชั่วคราวแล้วทำงานต่อได้ภายหลัง เพื่อให้ thread สามารถสั่ง asynchronous process อื่นๆ หรือการเขียนโค้ดแบบอื่นๆ ได้

มันทำแบบนี้ได้ด้วยการเลือกว่าจะ suspend หรือทำงานต่อตอนไหน สมมติว่าเรามี Coroutine อยู่สองตัว ตัวหนึ่งอยู่ทางซ้าย อีกตัวอยู่ทางขวา ทั้งสองรันพร้อมๆ กัน

หมายความว่า thread สามารถตัดสินใจเลือกได้ว่า Coroutine ตัวไหนต้อง suspend แล้วตัวไหนสามารถทำงานต่อได้ แปลว่า thread สามารถสลับการทำงานระหว่าง Coroutine ได้ เรียกได้ว่าเกือบจะทำงานแบบผสมผสานกันเลย

ซึ่งสิ่งนี้จะไม่ไปบล็อก process อื่นๆ ขณะที่มันกำลังทำงานอยู่แต่อย่างใด

Utilizing-Kotlin-Flows-in-an-Android-application-3

Channel ใน Kotlin

ต่อจากนั้น หากเราต้องการใช้งาน state บางอย่างใน Coroutine เช่น ใช้งาน change-of-state

หนึ่งในวิธีที่เราสามารถทำได้ก็คือการสื่อสารระหว่าง Coroutine ด้วยการใช้สิ่งที่เรียกว่า channels นั่นเอง

Utilizing-Kotlin-Flows-in-an-Android-application-4

แต่ก่อนที่เราจะไปพูดถึง 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

b574532c-dd2f-4460-979c-e1050187aac7

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 ขั้นตอน ได้แก่

ขั้นตอนการนำไปใช้งาน

  1. เพิ่ม Gradle dependency เข้าไปในโมดูลของแอปฯ คุณ
  2. เช็กว่าอุปกรณ์รองรับ biometric authentication หรือไม่
  3. สร้าง PromptInfo object ขึ้นมาอันหนึ่ง
  4. สร้าง instance ของ BiometricPrompt ขึ้นมาหนึ่งอัน
  5. บอกให้ผู้ใช้ยืนยันตัวตน

ก่อนอื่น เราจำเป็นต้องเพิ่ม 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 นั่นหมายความว่ามันเป็นรูปแบบการยืนยันตัวตนแบบที่คุณต้องการใช้

Sifat-AndroidX-Biometric


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

Safe-Navigation-11.08.2021-4

Navigation ของ Android

สวัสดีครับทุกคน ผมชื่อ Dmitrii มีตำแหน่งเป็น Android Technical Lead ที่ Seven Peaks Software ผมจะมาพูดถึงเรื่อง navigation ของ Android และการ implement navigation ในแอปพลิเคชัน Android

เอาละ มาดูกันว่า navigation ของ Android คืออะไร และวิธี implement มันในแอปฯ ของเรา ต้องทำอย่างไรบ้าง

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

Safe-Navigation-11.08.2021


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

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

Manager เพิ่มเติมบางตัวอาจจะเป็น controller และเนื่องจาก Android ไม่ได้มีรูปแบบที่ตายตัวในเรื่องนี้หรือมี requirement ที่เข้มงวดอะไรเกี่ยวกับ navigation คุณจึงต้องเข้าใจเรื่องนี้อย่างชัดเจนในการสร้างแอปฯ

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

Safe-Navigation-11.08.2021-1


หากคุณสามารถรองรับหลายๆ 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 ได้

Safe-Navigation-11.08.2021-2


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

ในด้านหนึ่ง มันก็ช่วยทำให้ navigation มีความเรียบง่ายมากขึ้นเพราะว่ามันมี fragment อยู่หลายตัว ซึ่งมีขนาดเล็กกว่า activity

แต่เราก็ต้องเจอกับปัญหาที่เหมือนหรือคล้ายกันตรงที่เรามีเลเยอร์ที่ต้อง implement เพิ่ม เช่น component เสริม, manager เสริม, หรือ controller เสริม เพื่อจัดการกับการสลับหน้านั่นเอง

เราจำเป็นต้องใช้โซลูชันภายนอกบางอย่างเพื่อแก้ไขปัญหานี้

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

Navigation component นั้นมี Android navigation controller และ navigation graph บรรจุอยู่แล้ว โดยมันสามารถบรรจุ graph กลุ่มเล็กๆ ที่คุณต้องการได้

Safe-Navigation-11.08.2021-3


Navigation graph ก็เหมือนกับ fragment, dialogue, หรือ view ที่ทำงานเกี่ยวกับ fragment ซึ่ง action หรือทิศทางระหว่าง fragment เหล่านี้สามารถนำมาใช้ในการสลับหน้าได้

สามารถดูวิดีโอ live coding นี้ของผมได้เพื่อดูว่ามันทำงานอย่างไร

 

ดูวิดีโอ live coding สาธิตการใช้งาน Navigation บน Android ได้ข้างล่างนี้

การใช้ Android Navigation Component สร้าง Navigation อย่างปลอดภัยด้วย โดย Dimitrii

คุณเป็น Android developer ที่มีความสามารถหรือเปล่า
อ่านรายละเอียดการรับสมัคร Senior, Mid-level, และ Junior Android developer ได้ข้างล่างนี้!
อ่านรายละเอียดงาน Android Developer