야, 솔직히 말해볼게. 안드로이드 앱 개발하다가 "이거 왜 이렇게 복잡해?" 라고 느낀 적 없어? 🤯
액티비티 생명주기 관리하다가 머리 터지고, 백그라운드 작업 처리하다가 앱 크래시 나고, 데이터베이스 쿼리 짜다가 밤새고...
근데 있잖아, 구글이 이 모든 고통을 해결하려고 만든 게 바로 Jetpack이야! 🎉

Jetpack은 단순한 라이브러리 하나가 아니야. 안드로이드 개발의 베스트 프랙티스를 모아놓은 거대한 도구 모음집이라고 생각하면 돼.
2018년 구글 I/O에서 처음 발표됐고, 지금은 안드로이드 개발자라면 거의 필수로 쓰는 라이브러리들이 여기 다 들어있어.
오늘은 이 Jetpack의 핵심 라이브러리들을 하나하나 뜯어보면서, 어떻게 하면 개발 생산성을 진짜로 올릴 수 있는지 같이 알아보자! 💪

🤔 Jetpack이 뭔데? 왜 써야 해?

Jetpack을 한 마디로 정의하면 "안드로이드 개발자의 고통을 줄여주는 구글의 선물 세트"야. 😄
공식적으로는 "안드로이드 앱을 더 쉽게 개발할 수 있도록 도와주는 라이브러리, 도구, 가이드의 모음"이라고 정의돼 있어.

Jetpack 이전에는 어땠냐고? 🤦
예를 들어 화면 회전할 때 데이터 유지하려면 onSaveInstanceState()에 직접 데이터 저장하고, onRestoreInstanceState()에서 복원하는 코드를 매번 써야 했어.
근데 지금은? ViewModel 하나면 끝이야. 화면이 회전해도 데이터가 알아서 살아남아. 🎯

Jetpack은 크게 4가지 카테고리로 나뉘어:
🏗️ Architecture 🎨 UI ⚙️ Behavior 🔧 Foundation

오늘은 이 중에서 개발 생산성에 가장 직접적인 영향을 주는 핵심 라이브러리들을 집중적으로 파헤쳐볼 거야!

🧠 ViewModel + LiveData: 생명주기 지옥에서 탈출!

안드로이드 개발에서 가장 악명 높은 게 뭔지 알아? 바로 생명주기(Lifecycle) 관리야. 😱
액티비티가 생성되고, 일시정지되고, 재개되고, 파괴되는 과정에서 데이터를 어떻게 관리하느냐가 진짜 골치거리였거든.
화면 회전 한 번에 앱이 뻗어버리는 경험... 다들 한 번쯤은 해봤을 거야. 😅

📦 ViewModel이란?

ViewModel은 UI 관련 데이터를 저장하고 관리하는 클래스야.
핵심은 화면 구성 변경(화면 회전 등)에서 살아남는다는 거야!
액티비티나 프래그먼트가 파괴되고 재생성되어도 ViewModel은 메모리에 그대로 유지돼.

// ViewModel 클래스 정의
class MainViewModel : ViewModel() {
    private val _count = MutableLiveData<Int>(0)
    val count: LiveData<Int> = _count
    
    fun increment() {
        _count.value = (_count.value ?: 0) + 1
    }
    
    override fun onCleared() {
        super.onCleared()
        // ViewModel이 완전히 소멸될 때 호출
        // 리소스 정리 코드 여기에!
    }
}

// Activity에서 사용
class MainActivity : AppCompatActivity() {
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // LiveData 관찰
        viewModel.count.observe(this) { count ->
            binding.tvCount.text = count.toString()
        }
        
        binding.btnIncrement.setOnClickListener {
            viewModel.increment()
        }
    }
}

📡 LiveData란?

LiveData는 생명주기를 인식하는 관찰 가능한 데이터 홀더야.
쉽게 말하면, 데이터가 바뀌면 자동으로 UI에 알려주는 똑똑한 데이터 컨테이너야.
그리고 생명주기를 알고 있어서, 액티비티가 백그라운드에 있을 때는 업데이트를 보내지 않아. 메모리 누수 걱정 없음! 🙌

ViewModel과 LiveData를 함께 쓰면 MVVM(Model-View-ViewModel) 아키텍처를 자연스럽게 구현할 수 있어.
UI 로직과 비즈니스 로직이 분리되니까 테스트도 쉬워지고, 코드 유지보수도 훨씬 편해져. 👍

🗄️ Room: SQLite를 인간답게 쓰는 법

SQLite 직접 써본 사람? 🙋
SQLiteOpenHelper 상속받고, onCreate()에 CREATE TABLE 쿼리 쓰고, Cursor로 데이터 읽고...
생각만 해도 손가락이 아파오지 않아? 😭
Room은 이 모든 고통을 없애주는 SQLite 위에 구축된 추상화 레이어야!

Room의 핵심 구성요소는 딱 3가지야:

// 1. Entity 정의
@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    @ColumnInfo(name = "user_name")
    val name: String,
    val email: String,
    val createdAt: Long = System.currentTimeMillis()
)

// 2. DAO 정의
@Dao
interface UserDao {
    @Query("SELECT * FROM users ORDER BY createdAt DESC")
    fun getAllUsers(): Flow<List<User>>  // Flow로 반응형 처리!
    
    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUserById(userId: Int): User?
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUser(user: User)
    
    @Update
    suspend fun updateUser(user: User)
    
    @Delete
    suspend fun deleteUser(user: User)
    
    @Query("DELETE FROM users WHERE id = :userId")
    suspend fun deleteUserById(userId: Int)
}

// 3. Database 정의
@Database(
    entities = [User::class],
    version = 1,
    exportSchema = false
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null
        
        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

특히 Flow<List<User>>를 반환하는 DAO 메서드는 진짜 강력해!
데이터베이스에 변경이 생기면 자동으로 새 데이터를 emit해서 UI가 알아서 업데이트돼.
이걸 ViewModel의 StateFlow와 연결하면 완전 자동화된 데이터 파이프라인이 완성되는 거야! 🚀

🗺️ Navigation Component: 화면 전환의 신세계

예전에 프래그먼트 전환 코드 짜본 적 있어? 😤
FragmentManager에 beginTransaction()하고, replace()하고, addToBackStack()하고...
백스택 관리하다가 뒤로가기 버튼 동작이 이상해지고, 화면 전환 애니메이션 추가하려면 또 코드가 늘어나고.
Navigation Component는 이 모든 걸 시각적인 그래프로 관리하게 해줘! 🎨

Navigation의 핵심 개념

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/nav_graph"
    app:startDestination="@id/homeFragment">

    <fragment
        android:id="@+id/homeFragment"
        android:name="com.example.HomeFragment"
        android:label="홈">
        <action
            android:id="@+id/action_home_to_detail"
            app:destination="@id/detailFragment"
            app:enterAnim="@anim/slide_in_right"
            app:exitAnim="@anim/slide_out_left"/>
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name="com.example.DetailFragment"
        android:label="상세">
        <argument
            android:name="itemId"
            app:argType="integer"/>
    </fragment>
</navigation>

// 화면 이동 (Safe Args 사용)
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42)
findNavController().navigate(action)

// 뒤로가기
findNavController().navigateUp()

// BottomNavigationView와 연동
val navController = findNavController(R.id.nav_host_fragment)
binding.bottomNav.setupWithNavController(navController)

Navigation Component의 또 다른 강점은 딥링크(Deep Link) 지원이야.
외부에서 특정 화면으로 바로 진입하는 기능을 NavGraph에서 선언적으로 정의할 수 있어.
URL 패턴 매핑도 지원하니까 웹 링크에서 앱 특정 화면으로 연결하는 것도 쉽게 구현 가능해! 🔗

⚙️ WorkManager: 백그라운드 작업의 최강자

백그라운드 작업... 안드로이드 개발에서 진짜 악몽 같은 영역이야. 😰
AsyncTask는 deprecated됐고, Service는 배터리 잡아먹는다고 시스템이 죽여버리고,
JobScheduler는 API 21 이상에서만 되고, AlarmManager는 도즈 모드에서 안 되고...
이 모든 혼란을 WorkManager가 해결해줘! 🦸

WorkManager는 보장된 실행(Guaranteed Execution)이 핵심이야.
앱이 종료되거나 기기가 재시작되어도 작업이 실행되는 걸 보장해줘.
단, 즉각적인 실행이 필요한 작업보다는 지연 가능하고 신뢰성이 필요한 작업에 적합해.

// Worker 클래스 정의
class ImageUploadWorker(
    context: Context,
    workerParams: WorkerParameters
) : CoroutineWorker(context, workerParams) {
    
    override suspend fun doWork(): Result {
        val imageUri = inputData.getString("image_uri") 
            ?: return Result.failure()
        
        return try {
            // 이미지 업로드 로직
            uploadImage(imageUri)
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) {
                Result.retry()  // 최대 3번 재시도
            } else {
                Result.failure()
            }
        }
    }
}

// WorkRequest 생성 및 실행
val uploadWorkRequest = OneTimeWorkRequestBuilder<ImageUploadWorker>()
    .setInputData(workDataOf("image_uri" to imageUri))
    .setConstraints(
        Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)  // 네트워크 연결 시에만
            .setRequiresBatteryNotLow(true)  // 배터리 부족 시 실행 안 함
            .build()
    )
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        WorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .build()

WorkManager.getInstance(context).enqueue(uploadWorkRequest)

// 작업 상태 관찰
WorkManager.getInstance(context)
    .getWorkInfoByIdLiveData(uploadWorkRequest.id)
    .observe(this) { workInfo ->
        when (workInfo.state) {
            WorkInfo.State.SUCCEEDED -> showSuccess()
            WorkInfo.State.FAILED -> showError()
            WorkInfo.State.RUNNING -> showProgress()
            else -> {}
        }
    }

WorkManager의 강력한 기능들

// 이미지 처리 파이프라인: 압축 → 필터 적용 → 업로드
WorkManager.getInstance(context)
    .beginWith(compressWorkRequest)
    .then(filterWorkRequest)
    .then(uploadWorkRequest)
    .enqueue()

💉 Hilt: 의존성 주입을 쉽게!

의존성 주입(Dependency Injection, DI)... 처음 들으면 뭔가 어려워 보이지? 😅
근데 개념은 간단해. "필요한 객체를 직접 만들지 말고, 외부에서 받아라"는 거야.
예를 들어 Repository가 필요한 ViewModel이 있을 때, ViewModel 안에서 Repository를 직접 생성하는 게 아니라 외부에서 주입받는 방식이야.

Hilt는 Dagger2 기반의 안드로이드 전용 DI 라이브러리야.
Dagger2가 너무 복잡하다는 불만을 반영해서 구글이 안드로이드에 최적화된 버전으로 만든 거야.
어노테이션 몇 개만 추가하면 DI 설정이 끝나! 🎉

// Application 클래스에 @HiltAndroidApp 추가
@HiltAndroidApp
class MyApplication : Application()

// Activity에 @AndroidEntryPoint 추가
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    // ViewModel에 자동으로 의존성 주입됨
    private val viewModel: MainViewModel by viewModels()
}

// ViewModel에 @HiltViewModel 추가
@HiltViewModel
class MainViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {
    // userRepository가 자동으로 주입됨!
}

// Repository 정의
class UserRepository @Inject constructor(
    private val userDao: UserDao,
    private val apiService: ApiService
) {
    fun getUsers() = userDao.getAllUsers()
}

// Module로 인터페이스 바인딩
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
    @Binds
    @Singleton
    abstract fun bindUserRepository(
        impl: UserRepositoryImpl
    ): UserRepository
}

// 외부 라이브러리 객체 제공
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

Hilt를 쓰면 코드 구조가 훨씬 깔끔해지고, 특히 테스트 코드 작성이 엄청 편해져.
테스트할 때 실제 Repository 대신 Mock Repository를 주입하면 되니까, 네트워크 없이도 ViewModel 테스트가 가능해! 🧪

🎨 Jetpack Compose: UI 개발의 혁명

자, 이제 진짜 핫한 녀석을 소개할 시간이야! 🔥
Jetpack Compose는 2021년에 안정 버전이 출시된 안드로이드의 새로운 UI 툴킷이야.
기존의 XML 기반 UI 개발 방식을 완전히 뒤집어버린 혁명적인 변화야!

기존 방식은 XML로 레이아웃 정의하고, 코드에서 findViewById()나 ViewBinding으로 뷰를 찾아서 조작하는 방식이었잖아.
Compose는 선언형(Declarative) UI 방식이야. "이 상태일 때 UI가 이렇게 보여야 해"라고 선언하면, 상태가 바뀔 때 UI가 알아서 업데이트돼!

// Composable 함수 정의
@Composable
fun UserCard(
    user: User,
    onFollowClick: (User) -> Unit
) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(horizontal = 16.dp, vertical = 8.dp),
        elevation = CardDefaults.cardElevation(4.dp),
        shape = RoundedCornerShape(12.dp)
    ) {
        Row(
            modifier = Modifier.padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            // 프로필 이미지
            AsyncImage(
                model = user.profileImageUrl,
                contentDescription = "프로필 이미지",
                modifier = Modifier
                    .size(56.dp)
                    .clip(CircleShape)
            )
            
            Spacer(modifier = Modifier.width(12.dp))
            
            // 사용자 정보
            Column(modifier = Modifier.weight(1f)) {
                Text(
                    text = user.name,
                    style = MaterialTheme.typography.titleMedium,
                    fontWeight = FontWeight.Bold
                )
                Text(
                    text = user.bio,
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                    maxLines = 2,
                    overflow = TextOverflow.Ellipsis
                )
            }
            
            // 팔로우 버튼
            Button(
                onClick = { onFollowClick(user) },
                shape = RoundedCornerShape(20.dp)
            ) {
                Text("팔로우")
            }
        }
    }
}

// 상태 관리
@Composable
fun UserListScreen(viewModel: UserViewModel = hiltViewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    
    when (uiState) {
        is UiState.Loading -> CircularProgressIndicator()
        is UiState.Success -> LazyColumn {
            items(uiState.users) { user ->
                UserCard(
                    user = user,
                    onFollowClick = viewModel::followUser
                )
            }
        }
        is UiState.Error -> ErrorScreen(message = uiState.message)
    }
}

Compose의 주요 장점

💾 DataStore: SharedPreferences의 진화형

SharedPreferences 써본 사람? 🙋
간단한 설정값 저장할 때 편하긴 한데... 메인 스레드에서 I/O 작업이 발생할 수 있고, 타입 안전성도 없고, 트랜잭션 지원도 안 되고.
DataStore는 이 모든 문제를 해결한 SharedPreferences의 현대적 대안이야! 🚀

DataStore는 두 가지 구현체가 있어:

// DataStore 생성 (Application 레벨에서 싱글톤으로)
val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
    name = "user_settings"
)

// 키 정의
object PreferencesKeys {
    val DARK_MODE = booleanPreferencesKey("dark_mode")
    val USER_NAME = stringPreferencesKey("user_name")
    val FONT_SIZE = intPreferencesKey("font_size")
}

// Repository에서 DataStore 사용
class SettingsRepository(private val dataStore: DataStore<Preferences>) {
    
    // 데이터 읽기 (Flow로 반환 - 변경 시 자동 emit)
    val darkModeFlow: Flow<Boolean> = dataStore.data
        .catch { exception ->
            if (exception is IOException) {
                emit(emptyPreferences())
            } else {
                throw exception
            }
        }
        .map { preferences ->
            preferences[PreferencesKeys.DARK_MODE] ?: false
        }
    
    // 데이터 쓰기 (suspend 함수 - 코루틴에서 호출)
    suspend fun setDarkMode(enabled: Boolean) {
        dataStore.edit { preferences ->
            preferences[PreferencesKeys.DARK_MODE] = enabled
        }
    }
    
    suspend fun setUserName(name: String) {
        dataStore.edit { preferences ->
            preferences[PreferencesKeys.USER_NAME] = name
        }
    }
}

📄 Paging 3: 무한 스크롤을 우아하게

SNS 피드나 상품 목록처럼 데이터가 많을 때 어떻게 처리해? 🤔
한 번에 다 불러오면 메모리 터지고, 로딩 시간도 엄청 걸리잖아.
그래서 페이지네이션(Pagination)이 필요한데, 이걸 직접 구현하면 생각보다 복잡해.
Paging 3는 이 복잡한 페이지네이션 로직을 깔끔하게 처리해주는 라이브러리야!

// PagingSource 정의
class UserPagingSource(
    private val apiService: ApiService
) : PagingSource<Int, User>() {
    
    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, User> {
        val page = params.key ?: 1
        
        return try {
            val response = apiService.getUsers(
                page = page,
                pageSize = params.loadSize
            )
            
            LoadResult.Page(
                data = response.users,
                prevKey = if (page == 1) null else page - 1,
                nextKey = if (response.users.isEmpty()) null else page + 1
            )
        } catch (e: Exception) {
            LoadResult.Error(e)
        }
    }
    
    override fun getRefreshKey(state: PagingState<Int, User>): Int? {
        return state.anchorPosition?.let { anchorPosition ->
            state.closestPageToPosition(anchorPosition)?.prevKey?.plus(1)
                ?: state.closestPageToPosition(anchorPosition)?.nextKey?.minus(1)
        }
    }
}

// Repository에서 Pager 생성
class UserRepository(private val apiService: ApiService) {
    fun getUsersPagingData(): Flow<PagingData<User>> {
        return Pager(
            config = PagingConfig(
                pageSize = 20,
                enablePlaceholders = false,
                prefetchDistance = 5  // 5개 남으면 미리 로드
            ),
            pagingSourceFactory = { UserPagingSource(apiService) }
        ).flow
    }
}

// ViewModel
@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {
    val users = repository.getUsersPagingData()
        .cachedIn(viewModelScope)  // 화면 회전 시 캐시 유지!
}

// Fragment에서 PagingDataAdapter 사용
class UserAdapter : PagingDataAdapter<User, UserViewHolder>(USER_COMPARATOR) {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
        // ViewHolder 생성
    }
    
    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        getItem(position)?.let { holder.bind(it) }
    }
    
    companion object {
        val USER_COMPARATOR = object : DiffUtil.ItemCallback<User>() {
            override fun areItemsTheSame(oldItem: User, newItem: User) = 
                oldItem.id == newItem.id
            override fun areContentsTheSame(oldItem: User, newItem: User) = 
                oldItem == newItem
        }
    }
}

📸 CameraX: 카메라 개발의 구원자

안드로이드 카메라 API... 진짜 악명 높지. 😤
Camera1 API는 너무 구식이고, Camera2 API는 너무 복잡하고, 기기마다 동작이 달라서 테스트하다가 머리 빠지고...
CameraX는 이 모든 복잡함을 추상화해서 일관된 카메라 경험을 제공해줘!

CameraX는 내부적으로 Camera2 API를 사용하지만, 개발자에게는 훨씬 간단한 API를 제공해.
그리고 기기 호환성 문제를 자동으로 처리해줘서 다양한 안드로이드 기기에서 일관되게 동작해.

class CameraFragment : Fragment() {
    private lateinit var cameraExecutor: ExecutorService
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        cameraExecutor = Executors.newSingleThreadExecutor()
        startCamera()
    }
    
    private fun startCamera() {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(requireContext())
        
        cameraProviderFuture.addListener({
            val cameraProvider = cameraProviderFuture.get()
            
            // Preview UseCase
            val preview = Preview.Builder().build().also {
                it.setSurfaceProvider(binding.viewFinder.surfaceProvider)
            }
            
            // ImageCapture UseCase
            val imageCapture = ImageCapture.Builder()
                .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                .build()
            
            // ImageAnalysis UseCase (실시간 분석)
            val imageAnalyzer = ImageAnalysis.Builder()
                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                .build()
                .also {
                    it.setAnalyzer(cameraExecutor) { imageProxy ->
                        analyzeImage(imageProxy)
                    }
                }
            
            // 카메라 바인딩
            try {
                cameraProvider.unbindAll()
                cameraProvider.bindToLifecycle(
                    viewLifecycleOwner,
                    CameraSelector.DEFAULT_BACK_CAMERA,
                    preview,
                    imageCapture,
                    imageAnalyzer
                )
            } catch (e: Exception) {
                Log.e("CameraX", "카메라 바인딩 실패", e)
            }
        }, ContextCompat.getMainExecutor(requireContext()))
    }
    
    override fun onDestroyView() {
        super.onDestroyView()
        cameraExecutor.shutdown()
    }
}

✨ Android KTX: Kotlin의 힘을 최대로!

KTX는 Kotlin Extensions의 약자야.
안드로이드 API를 Kotlin 친화적으로 만들어주는 확장 함수 모음이야.
코드가 얼마나 간결해지는지 직접 비교해볼게! 👀

// ❌ KTX 없이
val sharedPreferences = context.getSharedPreferences("prefs", Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putString("key", "value")
editor.apply()

// ✅ KTX 사용
context.getSharedPreferences("prefs", Context.MODE_PRIVATE).edit {
    putString("key", "value")
}

// ❌ KTX 없이 - Fragment 트랜잭션
supportFragmentManager.beginTransaction()
    .replace(R.id.container, fragment)
    .addToBackStack(null)
    .commit()

// ✅ KTX 사용
supportFragmentManager.commit {
    replace(R.id.container, fragment)
    addToBackStack(null)
}

// ❌ KTX 없이 - Bundle 생성
val bundle = Bundle()
bundle.putString("name", "홍길동")
bundle.putInt("age", 25)

// ✅ KTX 사용
val bundle = bundleOf("name" to "홍길동", "age" to 25)

// ❌ KTX 없이 - View 가시성
view.visibility = View.VISIBLE
view.visibility = View.GONE

// ✅ KTX 사용
view.isVisible = true
view.isGone = true

// ❌ KTX 없이 - 색상 가져오기
ContextCompat.getColor(context, R.color.primary)

// ✅ KTX 사용
context.getColor(R.color.primary)  // API 23+에서 자동 처리

KTX를 쓰면 코드가 훨씬 간결하고 읽기 쉬워져.
특히 lifecycleScope와 viewModelScope는 코루틴을 생명주기에 맞게 자동으로 취소해줘서 메모리 누수 걱정이 없어! 🙌

🏗️ 실전! Jetpack으로 완성하는 앱 아키텍처

자, 이제 배운 것들을 종합해서 실제 프로젝트에 어떻게 적용하는지 보여줄게! 🎯
구글이 권장하는 Clean Architecture + MVVM 패턴에 Jetpack 라이브러리들을 녹여낸 구조야.

@HiltViewModel
class HomeViewModel @Inject constructor(
    private val getUsersUseCase: GetUsersUseCase,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    
    // UI 상태를 하나의 sealed class로 관리
    sealed class UiState {
        object Loading : UiState()
        data class Success(val users: List<User>) : UiState()
        data class Error(val message: String) : UiState()
    }
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    
    // 검색어 상태
    private val _searchQuery = MutableStateFlow("")
    val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
    
    init {
        loadUsers()
    }
    
    fun loadUsers() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            getUsersUseCase()
                .catch { e ->
                    _uiState.value = UiState.Error(e.message ?: "알 수 없는 오류")
                }
                .collect { users ->
                    _uiState.value = UiState.Success(users)
                }
        }
    }
    
    fun updateSearchQuery(query: String) {
        _searchQuery.value = query
    }
    
    fun refreshUsers() {
        loadUsers()
    }
}

이 구조의 핵심은 단방향 데이터 흐름(UDF, Unidirectional Data Flow)이야.
UI는 이벤트를 ViewModel에 전달하고, ViewModel은 상태를 업데이트하고, UI는 상태를 관찰해서 화면을 업데이트해.
데이터가 한 방향으로만 흐르니까 디버깅이 쉽고, 예측 가능한 동작을 보장할 수 있어! 🎯

🎯 Jetpack 도입 실전 팁 & 주의사항

자, 이제 실제로 Jetpack을 프로젝트에 도입할 때 알아두면 좋은 팁들을 정리해볼게! 💪

✅ 버전 관리: BOM(Bill of Materials) 활용

Jetpack 라이브러리들은 서로 의존성이 있어서 버전 충돌이 생길 수 있어.
Compose BOM을 사용하면 모든 Compose 라이브러리 버전을 한 번에 관리할 수 있어!

// build.gradle.kts (app)
dependencies {
    // Compose BOM - 버전 하나로 모든 Compose 라이브러리 관리
    val composeBom = platform("androidx.compose:compose-bom:2024.02.00")
    implementation(composeBom)
    
    // 버전 명시 불필요!
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")
    implementation("androidx.compose.ui:ui-tooling-preview")
    
    // Jetpack 핵심 라이브러리들
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
    implementation("androidx.room:room-runtime:2.6.1")
    implementation("androidx.room:room-ktx:2.6.1")
    ksp("androidx.room:room-compiler:2.6.1")  // KSP 사용 권장!
    
    implementation("androidx.navigation:navigation-fragment-ktx:2.7.7")
    implementation("androidx.navigation:navigation-ui-ktx:2.7.7")
    
    implementation("androidx.work:work-runtime-ktx:2.9.0")
    
    implementation("com.google.dagger:hilt-android:2.51")
    ksp("com.google.dagger:hilt-compiler:2.51")
    
    implementation("androidx.datastore:datastore-preferences:1.0.0")
    implementation("androidx.paging:paging-runtime-ktx:3.2.1")
}

🔄 점진적 도입 전략

📚 공식 학습 리소스

⚡ Jetpack으로 앱 성능까지 잡기

생산성만 올리는 게 아니야! Jetpack 라이브러리들을 제대로 활용하면 앱 성능도 크게 향상돼. 🚀

🔍 Benchmark 라이브러리

Jetpack Benchmark는 코드 성능을 정확하게 측정할 수 있는 도구야.
일반 JUnit 테스트와 달리 JIT 컴파일, 가비지 컬렉션 등의 영향을 제거하고 정확한 측정값을 제공해.

@RunWith(AndroidJUnit4::class)
class MyBenchmark {
    @get:Rule
    val benchmarkRule = BenchmarkRule()
    
    @Test
    fun benchmarkSomeWork() {
        benchmarkRule.measureRepeated {
            // 성능 측정할 코드
            doSomeExpensiveWork()
        }
    }
}

📊 Compose 성능 최적화 팁

// ❌ 매번 새로운 람다 생성 - 불필요한 recomposition 유발
@Composable
fun UserList(users: List<User>, onUserClick: (User) -> Unit) {
    LazyColumn {
        items(users) { user ->
            UserItem(
                user = user,
                onClick = { onUserClick(user) }  // 매번 새 람다 생성!
            )
        }
    }
}

// ✅ key 파라미터 + 안정적인 람다 전달
@Composable
fun UserList(users: List<User>, onUserClick: (User) -> Unit) {
    LazyColumn {
        items(
            items = users,
            key = { user -> user.id }  // 고유 키 지정!
        ) { user ->
            UserItem(
                user = user,
                onClick = onUserClick  // 람다 직접 전달
            )
        }
    }
}

// derivedStateOf 활용
@Composable
fun SearchScreen(users: List<User>, query: String) {
    // query나 users가 바뀔 때만 재계산
    val filteredUsers by remember(users, query) {
        derivedStateOf {
            users.filter { it.name.contains(query, ignoreCase = true) }
        }
    }
    
    LazyColumn {
        items(filteredUsers, key = { it.id }) { user ->
            UserItem(user = user)
        }
    }
}

🗄️ Room 성능 최적화

🧪 Jetpack으로 테스트 코드 작성하기

테스트 코드... 귀찮다고 안 쓰는 사람 많지? 😅
근데 Jetpack 라이브러리들은 테스트를 정말 쉽게 만들어줘.
특히 ViewModel, Room, WorkManager는 전용 테스트 도구가 있어!

@OptIn(ExperimentalCoroutinesApi::class)
class HomeViewModelTest {
    
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()  // 테스트용 디스패처
    
    private lateinit var viewModel: HomeViewModel
    private val fakeRepository = FakeUserRepository()  // 가짜 Repository
    
    @Before
    fun setup() {
        viewModel = HomeViewModel(fakeRepository)
    }
    
    @Test
    fun `사용자 목록 로드 성공 시 Success 상태`() = runTest {
        // Given
        fakeRepository.setUsers(listOf(
            User(id = 1, name = "홍길동"),
            User(id = 2, name = "김철수")
        ))
        
        // When
        viewModel.loadUsers()
        
        // Then
        val state = viewModel.uiState.value
        assertTrue(state is HomeViewModel.UiState.Success)
        assertEquals(2, (state as HomeViewModel.UiState.Success).users.size)
    }
    
    @Test
    fun `네트워크 오류 시 Error 상태`() = runTest {
        // Given
        fakeRepository.setShouldThrowError(true)
        
        // When
        viewModel.loadUsers()
        
        // Then
        assertTrue(viewModel.uiState.value is HomeViewModel.UiState.Error)
    }
}

// Room 인메모리 DB 테스트
@RunWith(AndroidJUnit4::class)
class UserDaoTest {
    private lateinit var database: AppDatabase
    private lateinit var userDao: UserDao
    
    @Before
    fun setup() {
        database = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(),
            AppDatabase::class.java
        ).allowMainThreadQueries().build()
        userDao = database.userDao()
    }
    
    @After
    fun teardown() {
        database.close()
    }
    
    @Test
    fun insertAndGetUser() = runTest {
        val user = User(name = "테스트 유저", email = "test@test.com")
        userDao.insertUser(user)
        
        val users = userDao.getAllUsers().first()
        assertEquals(1, users.size)
        assertEquals("테스트 유저", users[0].name)
    }
}

특히 재능넷에서 안드로이드 개발 프리랜서로 활동한다면, 테스트 코드 작성 능력은 클라이언트에게 신뢰를 줄 수 있는 중요한 역량이야.
Jetpack 라이브러리들이 테스트를 쉽게 만들어주니까, 꼭 테스트 코드 작성 습관을 들여봐! 💪

🔮 2024년 Jetpack 최신 트렌드

Jetpack은 계속 발전하고 있어! 최신 트렌드를 알아두면 미래 준비도 되고, 기술 면접에서도 빛날 수 있어. ✨

1. Compose Multiplatform 확장

JetBrains와 구글이 협력해서 Compose를 iOS, 데스크톱, 웹까지 확장하고 있어.
Kotlin Multiplatform Mobile(KMM)과 결합하면 하나의 코드베이스로 안드로이드와 iOS 앱을 동시에 개발할 수 있어!
아직 완전히 안정화되진 않았지만, 2024년에 빠르게 성숙해지고 있어. 주목해야 할 기술이야! 👀

2. Credential Manager

기존의 분산된 인증 API들(SmartLock, FIDO2, Google Sign-In)을 통합한 새로운 인증 라이브러리야.
패스키(Passkey) 지원이 핵심이야. 비밀번호 없는 인증의 미래! 🔐

3. Health Connect

건강 데이터를 안전하게 공유하고 관리하는 플랫폼이야.
피트니스 앱, 건강 모니터링 앱 개발할 때 필수가 될 라이브러리야.

4. Macrobenchmark

앱 시작 시간, 스크롤 성능 등 실제 사용자 경험에 가까운 성능을 측정하는 도구야.
Baseline Profiles와 함께 사용하면 앱 시작 속도를 최대 40%까지 개선할 수 있어! ⚡

// Macrobenchmark로 Baseline Profile 생성
@RunWith(AndroidJUnit4::class)
class BaselineProfileGenerator {
    @get:Rule
    val rule = BaselineProfileRule()
    
    @Test
    fun generate() {
        rule.collect("com.example.myapp") {
            // 앱 시작 및 주요 사용자 여정 시뮬레이션
            pressHome()
            startActivityAndWait()
            
            // 주요 화면 탐색
            device.findObject(By.text("홈")).click()
            device.waitForIdle()
        }
    }
}

🎉 마무리: Jetpack으로 더 나은 개발자 되기

자, 오늘 정말 많은 내용을 다뤘어! 🎊
Jetpack의 핵심 라이브러리들을 정리해보면:

안드로이드 개발은 계속 발전하고 있고, Jetpack도 함께 진화하고 있어.
처음에는 배울 게 많아서 부담스러울 수 있지만, 하나씩 익혀가다 보면 어느 순간 "이게 없으면 어떻게 개발했지?"라는 생각이 들 거야. 😄

중요한 건 완벽하게 다 알고 시작하려 하지 말고, 일단 써보면서 배우는 것이야.
공식 코드랩부터 시작해서 실제 프로젝트에 하나씩 적용해봐. 그게 가장 빠른 학습 방법이야! 🚀

자, 이제 Jetpack으로 더 빠르고, 더 안정적이고, 더 유지보수하기 쉬운 앱을 만들어봐! 💪
궁금한 점이 있으면 구글 공식 문서나 Android Developers YouTube 채널을 참고해.
그리고 같은 고민을 하는 개발자들과 지식을 나누고 싶다면, 재능넷 같은 플랫폼에서 서로의 경험을 공유하는 것도 정말 좋은 방법이야! 🌟