Android Architecture Components (ViewModel, LiveData, Room) என்றால் என்ன?

Question

Accepted Answer

**Android Architecture Components** (Jetpack இன் பகுதி) வலிமையான, பராமரிப்பு சாத்தியமான பயன்பாடுகளை உருவாக்க உதவும் நூலகங்கள் — **ViewModel** (lifecycle-aware state), **LiveData/StateFlow** (observable data), மற்றும் **Room** (database abstraction) உட்பட. அவை பரிந்துரைக்கப்பட்ட architecture patterns ஐ ஆதரிக்கின்றன.

## ViewModel — lifecycle-aware state holder

```text
VIEWMODEL holds UI-related state and logic, SURVIVING configuration changes:
  → state stored in a ViewModel SURVIVES screen rotation (the activity recreates, but the
    ViewModel persists) → solves the lost-state-on-rotation problem
  → separates UI logic from the Activity/Fragment (the View just observes/displays)
```

## LiveData / StateFlow — observable data

```text
LIVEDATA / STATEFLOW → observable data holders that notify observers of changes:
  → the UI OBSERVES the data; when it changes, the UI updates automatically (reactive)
  → LiveData is LIFECYCLE-AWARE (only updates active UI; no leaks/crashes)
  → StateFlow (Kotlin Flow) is the modern coroutine-based alternative
```

## Room — database abstraction

```text
ROOM → an abstraction layer over SQLite (the recommended local database):
  → define entities (tables), DAOs (data access objects with queries), a database
  → compile-time SQL verification; works with coroutines/Flow; less boilerplate than
    raw SQLite
```

## Recommended architecture

```text
UI (Activity/Fragment/Compose) → observes → VIEWMODEL (state + logic) → REPOSITORY
  (data abstraction) → data sources (Room database, network API)
→ Separation of concerns; lifecycle-aware; testable; survives config changes.
→ This is Google's RECOMMENDED app architecture (MVVM-style with these components).
```

## இது ஏன் முக்கியம்

Android Architecture Components ஐ புரிந்துகொள்வது முக்கியம் ஏனெனில் அவை **Google இன் பரிந்துரைக்கப்பட்ட நவீன Android architecture இன் மையமாக** உள்ளன, வலிமையான, பராமரிப்பு சாத்தியமான பயன்பாடுகளை உருவாக்க உதவுகின்றன, எனவே இது quality Android development க்கான மதிப்பான அறிவு.

இந்த Jetpack நூலகங்கள் ஒவ்வொன்றும் உண்மையான சிக்கல்களைத் தீர்க்கின்றன. **ViewModel** UI state மற்றும் logic ஐ удерж வைத்துக்கொள்கிறது, இது **configuration changes ஐ தாக்க்கள் செய்கிறது** — முக்கியமாக **lost-state-on-rotation problem** ஐ (activity rotation இல் அழிக்கப்பட்டு மீண்டும் உருவாக்கப்பட்டு, state இழக்கப்படுவது, ஒரு பிரபலமான Android issue) தீர்க்கிறது, state ஐ recreations இல் persist வைத்துக்கொள்வதன் மூலம், மேலும் UI logic ஐ Activity/Fragment இலிருந்து பிரித்துவைக்கிறது. **LiveData/StateFlow** **observable, lifecycle-aware data** ஐ வழங்குகின்றன — UI data ஐ observe செய்கிறது மற்றும் அது மாறும்போது தானாகவே更新 வகிறது (reactive pattern), lifecycle-awareness உள்ளதுடன் older observer patterns ஐ தொந்தரவு செய்த leaks மற்றும் crashes ஐ தடுக்கிறது. **Room** **SQLite மீது깔끔 한abstraction** ஐ வழங்குகிறது (பரிந்துரைக்கப்பட்ட local database) compile-time SQL verification மற்றும் coroutine/Flow integration உடன், raw SQLite ஐ விட மிகவும் சிறந்தது.

**recommended architecture** ஐ புரிந்துகொள்வது — UI ViewModel ஐ observe செய்கிறது (state மற்றும் logic வைத்துக்கொள்கிறது) data sources (Room, network) மீது Repository (data abstracting) ஆல் back செய்யப்பட்டு — என்பது முக்கிய மதிப்பு: இந்த MVVM-style architecture (Google இன் பரிந்துரை) separation of concerns, lifecycle-awareness, testability, மற்றும் robustness (config changes தாக்க்கள் செய்தல்) ஐ வழங்குகிறது, நவீன, பராமரிப்பு சாத்தியமான Android பயன்பாடுகளின் கட்டமைப்பை பிரதிநிதித்வம் செய்கிறது.

இந்த components fundamental Android சிக்கல்களை (state surviving rotation, reactive lifecycle-aware data, clean database access) தீர்க்கிறது மற்றும் robust, maintainable பயன்பாடுகளுக்கான Google இன் பரிந்துரைக்கப்பட்ட architecture ஐ உருவாக்குகிறது, மேலும் அவற்றை புரிந்துகொள்வது பரிந்துரைக்கப்பட்ட வழியில் quality நவீன Android பயன்பாடுகளை உருவாக்குவதற்கு முக்கியமாக இருப்பதால், Android Architecture Components ஐ புரிந்துகொள்வது மதிப்பான, practically-relevant அறிவு — நவீன Android architecture க்கு மையமாக, உண்மையான சிக்கல்களைத் தீர்க்கிறது (குறிப்பாக configuration-change state loss) மற்றும் maintainable, testable, robust app structure ஐ enable செய்கிறது, அது professional Android development பின்பற்றுகிறது.