คำแนะนำสำหรับสถาปัตยกรรม Android

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

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

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

สถาปัตยกรรมแบบเลเยอร์

สถาปัตยกรรมแบบเลเยอร์ที่เราแนะนำจะเน้นการแยกส่วนที่เกี่ยวข้อง โดยจะขับเคลื่อน UI จากโมเดลข้อมูล เป็นไปตามหลักการแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว (SSOT) และเป็นไปตามหลักการการไหลของข้อมูลแบบทิศทางเดียว แนวทางปฏิบัติแนะนำบางส่วนสำหรับสถาปัตยกรรมแบบเลเยอร์มีดังนี้

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

ตรวจสอบว่าคอมโพเนนต์ในเลเยอร์ UI เช่น Composable หรือ ViewModel ไม่ได้โต้ตอบกับแหล่งข้อมูลโดยตรง ตัวอย่างแหล่งข้อมูล ได้แก่

  • ฐานข้อมูล, DataStore, SharedPreferences, Firebase API
  • ผู้ให้บริการตำแหน่ง GPS
  • ผู้ให้บริการข้อมูลบลูทูธ
  • ผู้ให้บริการสถานะการเชื่อมต่อเครือข่าย
ใช้ Coroutines และ Flow ใช้ Coroutine และ Flow เพื่อสื่อสารระหว่างเลเยอร์

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

ใช้เลเยอร์โดเมน ใช้เลเยอร์โดเมนกับ Use Case หากต้องการใช้ตรรกะทางธุรกิจซ้ำซึ่งโต้ตอบกับชั้นข้อมูลใน ViewModel หลายรายการ หรือต้องการลดความซับซ้อนของตรรกะทางธุรกิจของ ViewModel หนึ่งๆ

เลเยอร์ UI

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

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำสำหรับ ViewModel ได้ที่คำแนะนำเกี่ยวกับสถาปัตยกรรม

ดูข้อมูลเพิ่มเติมเกี่ยวกับประโยชน์ของ ViewModel ได้ที่ViewModel เป็นตัวเก็บสถานะตรรกะทางธุรกิจ

ใช้การรวบรวมสถานะ UI ที่คำนึงถึงวงจรชีวิต รวบรวมสถานะ UI จาก UI โดยใช้เครื่องมือสร้าง Coroutine ที่รับรู้ถึงวงจรชีวิตที่เหมาะสม collectAsStateWithLifecycle

อ่านเพิ่มเติมเกี่ยวกับ collectAsStateWithLifecycle

อย่าส่งเหตุการณ์จาก ViewModel ไปยัง UI ประมวลผลเหตุการณ์ทันทีใน ViewModel และทำให้เกิดการอัปเดตสถานะพร้อมผลลัพธ์ของการจัดการเหตุการณ์ ดูข้อมูลเพิ่มเติมเกี่ยวกับเหตุการณ์ UI ได้ที่จัดการเหตุการณ์ ViewModel
ใช้แอปพลิเคชันกิจกรรมเดียว ใช้ Navigation 3 เพื่อไปยังหน้าจอต่างๆ และทำ Deep Link ไปยังแอปหากแอปมีมากกว่า 1 หน้าจอ
ใช้ Jetpack Compose ใช้ Jetpack Compose เพื่อสร้างแอปใหม่สำหรับโทรศัพท์ แท็บเล็ต อุปกรณ์แบบพับได้ และ Wear OS

ข้อมูลโค้ดต่อไปนี้แสดงวิธีรวบรวมสถานะ UI ในลักษณะที่รับรู้ถึงวงจรชีวิต

  @Composable
  fun MyScreen(
      viewModel: MyViewModel = viewModel()
  ) {
      val uiState by viewModel.uiState.collectAsStateWithLifecycle()
  }

ViewModel

ViewModels มีหน้าที่รับผิดชอบในการระบุสถานะ UI และเข้าถึงชั้นข้อมูล แนวทางปฏิบัติแนะนำบางส่วนสำหรับ ViewModel มีดังนี้

คำแนะนำ คำอธิบาย
ทำให้ ViewModel เป็นอิสระจากวงจรของ Android ใน ViewModel อย่าเก็บการอ้างอิงไปยังประเภทที่เกี่ยวข้องกับวงจร อย่าส่ง Activity, Context หรือ Resources เป็นทรัพยากร Dependency หากมีบางสิ่งที่ต้องใช้ Context ใน ViewModel ให้ประเมินอย่างรอบคอบว่าสิ่งนั้นอยู่ในเลเยอร์ที่ถูกต้องหรือไม่
ใช้ Coroutines และ Flow

ViewModel จะโต้ตอบกับข้อมูลหรือเลเยอร์โดเมนโดยใช้สิ่งต่อไปนี้

  • Kotlin Flow สำหรับรับข้อมูลแอปพลิเคชัน
  • ฟังก์ชัน suspend สำหรับการดำเนินการโดยใช้ viewModelScope
ใช้ ViewModel ที่ระดับหน้าจอ

อย่าใช้ ViewModel ในส่วนที่นำมาใช้ซ้ำได้ของ UI คุณควรใช้ ViewModel ในกรณีต่อไปนี้

  • คอมโพสิเบิลระดับหน้าจอ
  • ปลายทางหรือกราฟเมื่อใช้ Jetpack Navigation

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

ใช้คลาสตัวเก็บสถานะธรรมดาในคอมโพเนนต์ UI ที่นำกลับมาใช้ใหม่ได้ ใช้คลาสตัวเก็บสถานะธรรมดาเพื่อจัดการความซับซ้อนในคอมโพเนนต์ UI ที่นำกลับมาใช้ใหม่ได้ เมื่อทำเช่นนี้ คุณจะยกและควบคุมสถานะจากภายนอกได้
อย่าใช้ AndroidViewModel ใช้คลาส ViewModel ไม่ใช่ AndroidViewModel อย่าใช้คลาส Application ใน ViewModel แต่ให้ย้ายทรัพยากร Dependency ไปยัง UI หรือชั้นข้อมูลแทน
แสดงสถานะ UI ทำให้ ViewModel แสดงข้อมูลต่อ UI ผ่านพร็อพเพอร์ตี้เดียวที่ชื่อว่า uiState หาก UI แสดงข้อมูลหลายรายการที่ไม่เกี่ยวข้อง VM จะแสดงพร็อพเพอร์ตี้สถานะ UI หลายรายการได้
  • ทำให้ uiState เป็น StateFlow
  • สร้าง uiState โดยใช้โอเปอเรเตอร์ stateIn กับนโยบาย WhileSubscribed(5000) หากข้อมูลมาเป็นสตรีมข้อมูลจากเลเยอร์อื่นๆ ของลำดับชั้น (ดูตัวอย่างโค้ดนี้)
  • สำหรับกรณีที่ง่ายกว่าซึ่งไม่มีสตรีมข้อมูลที่มาจากชั้นข้อมูล คุณสามารถใช้ MutableStateFlow ที่แสดงเป็น StateFlow ที่เปลี่ยนแปลงไม่ได้
  • คุณเลือกให้ ${Screen}UiState เป็นคลาสข้อมูลที่มีข้อมูล ข้อผิดพลาด และสัญญาณการโหลดได้ คลาสนี้ยังเป็นคลาสที่ปิดผนึกได้ด้วยหากสถานะต่างๆ ไม่ซ้ำกัน

ข้อมูลโค้ดต่อไปนี้แสดงวิธีแสดงสถานะ UI จาก ViewModel

@HiltViewModel
class BookmarksViewModel @Inject constructor(
    newsRepository: NewsRepository
) : ViewModel() {

    val feedState: StateFlow<NewsFeedUiState> =
        newsRepository
            .getNewsResourcesStream()
            .mapToFeedState(savedNewsResourcesState)
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000),
                initialValue = NewsFeedUiState.Loading
            )

    // ...
}

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

ทำตามแนวทางปฏิบัติแนะนำสำหรับการทำงานกับวงจรกิจกรรม ดังนี้

คำแนะนำ คำอธิบาย
ใช้เอฟเฟกต์ที่รับรู้ถึงวงจรใน Composable แทนการลบล้าง Lifecycle Callback Activity

อย่าลบล้างเมธอดวงจรของ Activity เช่น onResume เพื่อเรียกใช้งานที่เกี่ยวข้องกับ UI แต่ให้ใช้ LifecycleEffects ของ Compose หรือขอบเขต Coroutine ที่รับรู้ถึงวงจรแทน ดังนี้

  • ใช้ LifecycleStartEffect เพื่อทำงานแบบซิงโครนัสเมื่อกิจกรรมเริ่มต้นและหยุดลง
  • ใช้ LifecycleResumeEffect เพื่อทำงานแบบซิงโครนัสเมื่อกิจกรรมของคุณกลับมาทำงานต่อและหยุดชั่วคราว
  • ใช้ repeatOnLifecycle เพื่อทำงานแบบอะซิงโครนัสเพื่อตอบสนองต่อเหตุการณ์ในวงจร
  • รวบรวมข้อมูลแบบอะซิงโครนัสจาก Flows โดยใช้ collectAsStateWithLifecycle

ข้อมูลโค้ดต่อไปนี้แสดงวิธีดำเนินการตามสถานะวงจรที่กำหนด

  @Composable
  fun LocationChangedEffect(
    locationManager: LocationManager,
    onLocationChanged: (Location) -> Unit
  ) {
    val currentOnLocationChanged by rememberUpdatedState(onLocationChanged)

    LifecycleStartEffect(locationManager) {
        val listener = LocationListener { newLocation ->
            currentOnLocationChanged(newLocation)
        }

        try {
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER,
                1000L,
                1f,
                listener,
            )
        } catch (e: SecurityException) {
            // TODO: Handle missing permissions
        }

        onStopOrDispose {
            locationManager.removeUpdates(listener)
        }
    }
  }

จัดการทรัพยากร Dependency

ทำตามแนวทางปฏิบัติแนะนำเมื่อจัดการทรัพยากร Dependency ระหว่างคอมโพเนนต์ ดังนี้

คำแนะนำ คำอธิบาย
ใช้การแทรกทรัพยากร Dependency ใช้แนวทางปฏิบัติแนะนำสำหรับการแทรกทรัพยากร Dependency โดยเฉพาะการแทรกเครื่องมือสร้างเมื่อเป็นไปได้
กำหนดขอบเขตให้กับคอมโพเนนต์เมื่อจำเป็น กำหนดขอบเขตเป็นคอนเทนเนอร์ทรัพยากร Dependency เมื่อประเภทมีข้อมูลที่เปลี่ยนแปลงได้ซึ่งจำเป็นต้องแชร์ หรือประเภทนั้นใช้ทรัพยากรมากในการเริ่มต้นและมีการใช้กันอย่างแพร่หลายในแอป
ใช้ Hilt ใช้ Hilt หรือการแทรก Dependency ด้วยตนเองในแอปที่เรียบง่าย ใช้ Hilt หากโปรเจ็กต์มีความซับซ้อนมากพอ เช่น หากมีสิ่งต่อไปนี้
  • หลายหน้าจอที่มี ViewModel
  • ใช้ WorkManager
  • มี ViewModel ที่กำหนดขอบเขตไว้ใน Back Stack ของการนำทาง

การทดสอบ

แนวทางปฏิบัติแนะนำบางส่วนสำหรับการทดสอบมีดังนี้

คำแนะนำ คำอธิบาย
รู้ว่าควรทดสอบอะไร

ทดสอบโปรเจ็กต์ เว้นแต่ว่าโปรเจ็กต์นั้นจะเป็นแอป "Hello World" ที่เรียบง่าย โดยอย่างน้อยต้องมีข้อมูลต่อไปนี้

  • Unit Test สำหรับ ViewModel รวมถึง Flow
  • Unit Test สำหรับเอนทิตีชั้นข้อมูล ซึ่งก็คือที่เก็บและแหล่งข้อมูล
  • การทดสอบการไปยังส่วนต่างๆ ของ UI ที่มีประโยชน์เป็นการทดสอบการถดถอยใน CI
  • การทดสอบประสิทธิภาพโดยใช้ Macrobenchmark เพื่อวัดการเริ่มต้นแอปและการแสดงผล UI
ใช้ Fake แทน Mock ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Fake ได้ที่ใช้ Test Double ใน Android
ทดสอบ StateFlow เมื่อทดสอบ StateFlow ให้ทำดังนี้

ดูข้อมูลเพิ่มเติมได้ที่สิ่งที่ควรทดสอบใน Android และทดสอบเลย์เอาต์ Compose

ประสิทธิภาพ

แนวทางปฏิบัติแนะนำบางส่วนในการปรับปรุงประสิทธิภาพมีดังนี้

คำแนะนำ คำอธิบาย
ใช้ R8 เพื่อลดขนาดและเพิ่มประสิทธิภาพแอป เปิดใช้ R8 ในโหมดเต็มรูปแบบในการกำหนดค่าบิลด์เพื่อนำโค้ดที่ไม่ได้ใช้ออก ปรับคลาสให้ยากต่อการอ่าน และเขียนโค้ดใหม่เพื่อปรับปรุงประสิทธิภาพรันไทม์
ใช้โปรไฟล์พื้นฐานและโปรไฟล์การเริ่มต้นระบบ สร้าง Baseline Profile และ Startup Profile เพื่อคอมไพล์เส้นทางโค้ดที่สำคัญล่วงหน้า ซึ่งจะช่วยลดเวลาในการตอบสนองของการเริ่มต้น (TTID และ TTFD) ได้อย่างมาก รวมถึงลดอาการกระตุกและ ANR ด้วย
ทดสอบประสิทธิภาพด้วย Macrobenchmark ใช้ไลบรารี Macrobenchmark เพื่อทดสอบประสิทธิภาพของแอปและป้องกันการถดถอย

โมเดล

โปรดปฏิบัติตามแนวทางปฏิบัติแนะนำต่อไปนี้เมื่อพัฒนาโมเดลในแอป

คำแนะนำ คำอธิบาย
สร้างโมเดลต่อเลเยอร์ในแอปที่ซับซ้อน

ในแอปที่ซับซ้อน ให้สร้างโมเดลใหม่ในเลเยอร์หรือคอมโพเนนต์ต่างๆ ตามความเหมาะสม ลองดูตัวอย่างต่อไปนี้

  • แหล่งข้อมูลระยะไกลสามารถแมปโมเดลที่ได้รับผ่านเครือข่ายกับคลาสที่ง่ายกว่าซึ่งมีเฉพาะข้อมูลที่แอปต้องการ
  • ที่เก็บข้อมูลสามารถแมปโมเดล DAO กับคลาสข้อมูลที่ง่ายขึ้นซึ่งมีเฉพาะข้อมูลที่เลเยอร์ UI ต้องการ
  • ViewModel สามารถรวมโมเดลชั้นข้อมูลในคลาส UiState ได้

รูปแบบการตั้งชื่อ

เมื่อตั้งชื่อฐานของโค้ด คุณควรคำนึงถึงแนวทางปฏิบัติแนะนำต่อไปนี้

คำแนะนำ คำอธิบาย
วิธีการตั้งชื่อ
ไม่บังคับ
ใช้คำกริยาเพื่อตั้งชื่อเมธอด เช่น makePayment()
การตั้งชื่อพร็อพเพอร์ตี้
ไม่บังคับ
ใช้นามวลีเพื่อตั้งชื่อพร็อพเพอร์ตี้ เช่น inProgressTopicSelection
การตั้งชื่อสตรีมข้อมูล
ไม่บังคับ
เมื่อคลาสแสดงสตรีม Flow หรือสตรีมอื่นๆ รูปแบบการตั้งชื่อจะเป็น get{model}Stream เช่น getAuthorStream(): Flow<Author> หากฟังก์ชันแสดงรายการโมเดล ให้ใช้ชื่อโมเดลพหูพจน์: getAuthorsStream(): Flow<List<Author>>
การตั้งชื่อการใช้งานอินเทอร์เฟซ
ไม่บังคับ
ใช้ชื่อที่มีความหมายสำหรับการติดตั้งใช้งานอินเทอร์เฟซ ใช้ Default เป็นคำนำหน้าหากไม่พบชื่อที่ดีกว่า ตัวอย่างเช่น สำหรับอินเทอร์เฟซ NewsRepository คุณอาจมี OfflineFirstNewsRepository หรือ InMemoryNewsRepository หากไม่พบชื่อที่เหมาะสม ให้ใช้ DefaultNewsRepository ใส่คำนำหน้าการติดตั้งใช้งานปลอมด้วย Fake เช่น FakeAuthorsRepository

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับสถาปัตยกรรม Android ได้ที่แหล่งข้อมูลเพิ่มเติมต่อไปนี้

เอกสารประกอบ

ดูเนื้อหา