🤖 Android 완전 가이드

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

// @Composable: "이 함수는 화면을 그리는 함수입니다" 라는 표시
@Composable
fun Greeting(name: String) {
    Column(modifier = Modifier.padding(16.dp)) {
        Text(text = "안녕하세요, $name!")
        Button(onClick = { /* 버튼을 누르면 실행할 코드 */ }) {
            Text("눌러보세요")
        }
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // setContent 안에서 Composable을 호출하면 화면에 그려집니다
        setContent {
            Greeting(name = "AI DevOps")
        }
    }
}

@Composable
fun ProfileCard() {
    Row(
        modifier = Modifier
            .fillMaxWidth()      // 가로 폭을 화면 끝까지 채움
            .padding(16.dp),     // 바깥 여백 16dp
        verticalAlignment = Alignment.CenterVertically
    ) {
        Column {
            Text("홍길동")
            Text("Android 개발자")
        }
        Spacer(modifier = Modifier.weight(1f)) // 남은 공간을 모두 차지 (오른쪽 정렬 효과)
        Text("팔로우")
    }
}

@Composable
fun Counter() {
    // remember: recomposition 간에 값을 유지
    // mutableStateOf: 값이 바뀌면 이 값을 읽는 UI를 자동으로 다시 그림
    // by 키워드를 쓰면 count.value 대신 count로 바로 읽고 쓸 수 있습니다
    var count by remember { mutableStateOf(0) }

    Column {
        Text(text = "카운트: ${count}")
        Button(onClick = { count++ }) { Text("증가") }
    }
}

data class Todo(val id: Int, val title: String)

@Composable
fun TodoList(todos: List<Todo>) {
    LazyColumn {
        items(todos, key = { it.id }) { todo ->
            Text(
                text = todo.title,
                modifier = Modifier.padding(12.dp)
            )
        }
    }
}

@Composable
fun AppNavHost() {
    val navController = rememberNavController()

    NavHost(navController = navController, startDestination = "home") {
        composable("home") {
            HomeScreen(onNavigateToDetail = {
                navController.navigate("detail") // "detail" 화면으로 이동
            })
        }
        composable("detail") {
            DetailScreen(onBack = {
                navController.popBackStack() // 이전 화면으로 돌아가기
            })
        }
    }
}

class CounterViewModel : ViewModel() {
    // private set: 외부에서는 읽기만 가능, 수정은 이 클래스 안에서만
    var count by mutableStateOf(0)
        private set

    fun increment() { count++ }
}

@Composable
fun CounterScreen(viewModel: CounterViewModel = viewModel()) {
    Column {
        Text("카운트: ${viewModel.count}")
        Button(onClick = { viewModel.increment() }) { Text("증가") }
    }
}

data class User(val id: Int, val name: String)

interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

val api: ApiService = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()
    .create(ApiService::class.java)

class UserViewModel : ViewModel() {
    var users by mutableStateOf<List<User>>(emptyList())
        private set

    fun loadUsers() {
        // viewModelScope: ViewModel이 사라질 때 자동으로 코루틴도 함께 취소됨
        viewModelScope.launch {
            try {
                users = api.getUsers()
            } catch (e: Exception) {
                // 네트워크 오류, 서버 오류 등을 여기서 처리
            }
        }
    }
}

@Composable
fun CameraScreen() {
    val context = LocalContext.current
    val launcher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) {
            // 권한이 승인된 경우의 처리
        } else {
            // 거부된 경우 — 이유를 설명하는 안내 UI를 보여주는 것이 좋습니다
        }
    }

    Button(onClick = {
        launcher.launch(Manifest.permission.CAMERA)
    }) {
        Text("카메라 권한 요청")
    }
}

val Context.dataStore by preferencesDataStore(name = "settings")
val DARK_MODE_KEY = booleanPreferencesKey("dark_mode")

// 저장하기
suspend fun setDarkMode(context: Context, enabled: Boolean) {
    context.dataStore.edit { prefs -> prefs[DARK_MODE_KEY] = enabled }
}

// Flow로 값 관찰하기 — 값이 바뀔 때마다 자동으로 새 값이 흘러옴
fun darkModeFlow(context: Context): Flow<Boolean> =
    context.dataStore.data.map { prefs -> prefs[DARK_MODE_KEY] ?: false }

class CounterTest {
    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun clickingButton_incrementsCounter() {
        composeTestRule.setContent { Counter() }

        // 초기 상태 확인
        composeTestRule.onNodeWithText("카운트: 0").assertExists()

        // 버튼 클릭
        composeTestRule.onNodeWithText("증가").performClick()

        // 클릭 후 상태 확인
        composeTestRule.onNodeWithText("카운트: 1").assertExists()
    }
}