O_Gyong's TECH

[Android] Clip 속성 알아보기: ClipChildren, ClipToOutline, ClipToPadding

O_Gyong — Wed, 11 Feb 2026 20:13:18 +0900

안드로이드에서 UI 작업을 하다 보면 View의 경계를 다뤄야 할 일들이 종종 있는데, 이때 Clip 네이밍이 들어간 속성 (ClipChildren, ClipToOutline, ClipToPadding) 들이 도움을 준다.

ClipChildren

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <FrameLayout
        android:id="@+id/fl_children"
        android:layout_width="250dp"
        android:layout_height="200dp"
        android:background="@color/blue">

        <TextView
            android:layout_width="150dp"
            android:layout_height="200dp"
            android:layout_marginTop="100dp"
            android:background="@color/red"
            android:text="Children" />
    </FrameLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

안드로이드에서 기본적으로 자식 View는 부모 View의 경계를 넘어갈 수 없다. 그래서 위의 xml 내용에서 TextView의 높이 100dp는 렌더링 되지 않고 잘리게 된다.

ClipChildren은 자식 View가 자신의 경계를 벗어날 수 있도록 해준다. 기본값은 true로 적용을 위해 false값을 지정해야한다. 주의할점은 xml에서 부모 View가 아닌 최상단 View에 적용을 해줘야 한다.

// xml
android:clipChildren="false"

// activity
val main = findViewById<ConstraintLayout>(R.id.main)
main.clipChildren = false

ClipToOutline

    <FrameLayout
        android:id="@+id/fl_outline"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@drawable/bg_round_12">

        <TextView
            android:id="@+id/tv_outline"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="@color/gray"/>
    </FrameLayout>

xml에 정의된 내용을 보면 FrameLayout은 background로 테두리를 둥글게 표시되도록 처리했다. 하지만 TextView의 너비가 match_parent로 적용되어 FrameLayout의 영역을 덮어씌워져서 둥근 테두리를 가리게된다.

ClipToOutline은 내가 background로 설정한 View의 경계선을 기준으로 내부 View의 영역을 잘라낸다. 기본값은 false이며 적용을 위해 true로 설정해야 한다.

// xml
android:clipToOutline="true"

// activity
val flOutline = findViewById<FrameLayout>(R.id.fl_outline)
flOutline.clipToOutline = true

ClipToPadding

        <ScrollView
            android:id="@+id/sv_padding"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:background="@color/gray"
            android:paddingTop="50dp"
            app:layout_constraintTop_toBottomOf="@id/btn_padding"
            app:layout_constraintBottom_toBottomOf="parent">

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="vertical">

                <TextView
                    android:layout_width="match_parent"
                    android:layout_height="400dp"
                    android:background="#FF9800"
                    android:text="끝까지 스크롤 해보세요" />
            </LinearLayout>
        </ScrollView>

Padding은 View의 내부 공간을 결정하기 때문에 스크롤 같은 동작은 Padding 영역을 유지하며 수행하게 된다. 위 xml의 경우 paddingTop:"50dp"로 인해 그 공간만큼을 차지된 상태로 스크롤이 수행될 것이다.

ClipToPadding은 이러한 상황에서 주로 쓰인다. 내부 콘텐츠가 Padding 영역을 무시하게 되며, 실제 View의 끝 영역까지 도달하게끔 한다. 기본값은 true이며 적용을 위해 false로 설정해야 한다.

// xml
android:clipToPadding="false"

// activity
val svPadding = findViewById<ScrollView>(R.id.sv_padding)
svPadding.clipToPadding = false

[Android] Worker Pool 패턴을 통한 작업의 효율/안정성 올리기

O_Gyong — Tue, 20 Jan 2026 20:04:26 +0900

[Android] API의 배치 처리와 동시성 처리 : chunked vs semaphore

기존 문자를 전송하는 로직은 chunked(10)를 통해 10개의 배치를 만들고 배치 내부는 비동기로 실행하되, 배치 내부의 작업이 모두 끝나면 다음 배치로 넘어가는 순차 방식으로 구현을 했다. // sendMm

ogyong.tistory.com

지난번에 다량의 API 호출 건에 대해 리스트의 chunked와 코루틴의 semaphore를 비교해 보고 semaphore를 사용하려 했다. 하지만 semaphore를 사용했을 때 구조 상 처리할 데이터의 수량만큼 코루틴을 생성해야 하는 문제가 발목을 잡았는데, Worker Pool 패턴에 대해 알게 되었다.

Worker Pool / Producer-Consumer / Worker Thread
위 3가지를 섞어서 말하기도 한다.

Worker Pool 패턴은 작업을 처리할 일꾼들을 미리 고용하고, 작업을 처리할 일이 생길 때마다 대기 중인 일꾼에게 일을 맡기는 방식이다. 다시 말하자면 정해진 수의 스레드를 생성하고, 작업을 큐(Queue)에 쌓아두면 스레드에서 작업을 하나씩 처리하는 방식이다.

    val channel = Channel<MmsData>(Channel.UNLIMITED) // 처리할 데이터가 100개 내외기 때문에 UNLIMITED 사용
    mmsList.forEach { channel.send(it) }
    channel.close()

    supervisorScope {
        repeat(5) { // or List(5)
            launch {
                for(mmsItem in channel) {
                    sendMms(mmsItem)
                }
            }
        }
    }

작업을 담을 공간으로 코루틴에서 제공하는 Channel을 사용했다. Channel은 Queue와 매우 유사하게 동작을 하지만, suspend로 동기화가 가능한 코루틴끼리 값을 주고받는 통로이다.

channel.send(it)
처리할 데이터인 mmsList의 Item을 channel에 채워준다
repeat(5) or List(5) / launch
5개의 코루틴을 생성하여 동시성을 확보한다.
for(mmsItem in channel)
5개의 코루틴이 channel에 접근하여 작업을 꺼내 수행한다.(같은 작업을 볼 수 없음)

사실 semaphore()가 동시 실행 수를 제어하는데 있어서 간단하게 쓰기 좋았고, 특히 경량 스레드라고 불리는 코루틴이 100개 내외로 생기는 것은 메모리에 영향을 주지 않을 정도로 미미하다고 한다. 그래도 지금보다 대량의 API 처리가 필요할 때 Worker Pool 패턴을 사용하면 좋을 것 같다.

[Android] ConnectivityManager로 데이터 절약 모드 감지하기

O_Gyong — Tue, 6 Jan 2026 20:49:39 +0900

운영 중인 앱의 기능으로 오전 08:00가 되면 WorkManager를 통해 고객에게 문자를 전송하고 있다. 만약 문자 전송에 실패할 경우 에러 내역을 파일로 저장하고, 미전송 내역을 남겨 수동으로 전송할 수 있다.

stackTrace: java.net.ConnectException: Failed to connect to ...

어느 날 '예약 문자 전송이 며칠 동안 안 돼서 수동으로 계속 보내고 있다.'는 내용으로 문의가 들어왔다. 에러 내역을 확인해 보니 위와 같은 문구를 확인할 수 있었다.

이 문구는 서버와의 연결에 실패했다는 내용으로 순간적으로 서버가 다운이 되었을까 생각이 들었지만 며칠 동안 동일 시간에 다운이 발생했을 거 같지는 않고, 다른 고객에게서 정상적으로 전송된 로그가 보였다. 특히나 전송 실패 로그가 08:00에 찍히고서 재전송 로그가 1분 내외로 찍힌 것이 이상하다고 느껴 다른 원인을 찾아봤다.

기기 자체에서 서버를 차단하는 경우가 무엇이 있는지 찾아보던 중, '데이터 절약 모드'일 때 백그라운드에서 네트워크를 차단한다는 내용을 봤다. 수동 전송의 경우 사용자가 앱 내에서 직접 처리를 하는 포그라운드 상태라서 문제 상황이 일치했다. 아니나 다를까 사용자분은 데이터 절약 모드를 활성화한 상태였고, 비활성화를 요청드린 다음 날 정상적으로 문자 전송이 된 것을 확인했다.

데이터 절약 모드 체크하기

    /**
     * 데이터 절약 모드 체크
     */
    fun checkMobileDataSaveMode(context: Context): Boolean {
        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val status = ConnectivityManagerCompat.getRestrictBackgroundStatus(cm)
        return status == ConnectivityManagerCompat.RESTRICT_BACKGROUND_STATUS_ENABLED
    }

데이터 절약 모드를 체크하는 방법은 간단하다. ConnectivityManager를 사용하면 현재 기기가 데이터 절약 모드인지 확인할 수 있다. WorkManager의 doWork() 블록에서 네트워크를 요청하기 전에 해당 함수를 호출하여 데이터 절약 모드가 활성화된 경우 상태 알림을 띄워 사용자가 어떤 사유로 전송에 실패했는지 알 수 있게 처리했다.

[Android] API의 배치 처리와 동시성 처리 : chunked vs semaphore

O_Gyong — Fri, 19 Dec 2025 15:08:07 +0900

운영중인 앱에는 문자를 전송하는 기능이 있다. 문자를 전송하는 로직은 chunked()를 통해 배치를 만들고, 배치 내부는 비동기로 실행하되, 배치 내부의 작업이 모두 끝나면 다음 배치로 넘어가는 순차 방식으로 구현이 되어 있었다.

// mmsList: List<MmsReq>
val result = mmsList.chunked(10).flatMap { batch ->
    batch.map { job ->
        async { sendMms(job) }
    }.awaitAll()
}

위 방식은 단건씩 처리하는 것과 비교했을 때 효율을 높이고, 처리량을 조절함으로써 로컬과 서버에 부담을 주지 않는다는 장점이 있다. 하지만 현재 배치의 작업이 지연이 생겼을 때 다음 배치의 시작이 지연되어 처리 속도가 떨어질 수 있다.

코루틴에서 제공하는 semaphore()는 동시에 permit을 획득할 수 있는 작업 수를 제한하여, 하나의 작업이 끝나면 다음 작업을 자동으로 채워서 동시 실행 수를 유지시켜준다.

// mmsList: List<MmsReq>
val semaphore = Semaphore(10)
val result = mmsList.map { mmsData ->
    async {
        semaphore.withPermit {
            sendMms(mmsData)
        }
    }
}.awaitAll()

semaphore() 를 적용하면서 배치에 대한 신경을 쓰지 않아도 되서 좋았고, 코드의 일부분을 정리해서 올렸지만 chunked()를 썼을 때와 달리 코드가 정돈됨을 느꼈다.

단, semaphore를 사용하면 현재 구조상 아이템의 개수만큼 코루틴을 생성하기 때문에 작업 데이터가 굉장히 많은 경우 메모리를 크게 잡아 먹게 된다. 그리고 withPermit이 실행되면서 코루틴이 일시 중단되었다가 재개되는데, 아이템의 개수가 많고 개별 작업 시간이 매우 짧다면 스위칭으로 인한 오버헤드가 작업 시간보다 커지는 문제가 발생할 수 있다고 한다. (작업 개수만틈 Deferred 객체가 생성 됨)

두 함수를 비교하여 사용할 때 충분한 테스트가 필요할 것 같다.

chunked
- 작업시간에 편차가 없는 경우
- 리스트가 매우 큰 경우
- 코루틴 개수와 메모리를 확실히 제한하려는 경우

semaphore
- 작업시간에 편차가 있는 경우
- 리스트가 고정되지 않고 추가 및 삭제로 변경되는 경우 동시성을 제한할 때
- 전체 작업 시간을 단축하고 싶을 때(특히 작업마다의 처리 시간이 들쭉날쭉할 때)

[Android][Compose] WorkManager & AlarmManger로 특정 시간에 백그라운드 작업 예약하기

O_Gyong — Fri, 24 Oct 2025 20:48:31 +0900

안드로이드에서는 백그라운드 작업을 돕는 요소들이 있다. 그 요소들 중에서 AlarmManager와 WorkManager를 다뤄 보려고 한다.

AlarmManager는 안드로이드 프레임워크에서 제공하는 API로 시스템 레벨의 알람 서비스에 접근하게 해 준다. 정확한 시간에 대한 작업이 필요한 경우에 사용되며, WorkManager가 없던 시절에는 BroadcastReceiver나 JobScheduler를 함께 사용하여 백그라운드 작업을 수행했다.

WorkManager는 백그라운드에서의 작업을 보장하는 안드로이드 Jetpack 라이브러리이다. 사용자가 화면을 벗어나거나, 앱이 종료가 되더라도 예약한 기능을 안정적으로 수행할 수 있다. 또한 기기의 상태(네트워크 연결, 저장공간, 충전 상태)와 같은 제약 조건을 사용하여 특정 상황에서의 작업 처리도 가능하다.

백그라운드 작업과 관련해서 더 자세한 내용은 아래 페이지를 참고하면 된다.

태스크 예약 | Background work | Android Developers

WorkManager를 사용하여 앱 또는 기기 다시 시작 시 실행되는 작업을 예약하는 방법을 설명합니다.

developer.android.com

WorkManager의 작업은 정해진 시간에 작업을 수행하지 않는다. 시스템이 해당 작업을 수행하기 앞서 효율적인 시점을 선택을 하게 된다. 이런 지연적인 특성은 '정확한 시점의 실행'이 아닌 '언젠가는 반드시 실행'이라는 의미를 갖는다. WorkManager를 사용하되 특정한 시간에 작업을 수행하게 하려면 AlarmManager를 함께 써야 한다.

AlarmManager를 설정하는 버튼을 만들고, 버튼을 클릭 시 WorkManager를 실행한다. WorkManager에서 Room의 값을 업데이트하여 UI에 반영되는지 확인하는 예제를 다음과 같이 만들었다.

◾ 의존성 등록

libs.version.toml

[versions]
lifecycleVersion = "2.9.4"
roomVersion = "2.8.2"
workVersion = "2.10.5"
hiltVersion = "2.57.2"
hiltWorkVersion = "1.3.0"

[libraries]
# ViewModel & LiveData/Flow
lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycleVersion" }
lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycleVersion" }

# Room
room-ktx = { module = "androidx.room:room-ktx", version.ref = "roomVersion" }
room-runtime = { module = "androidx.room:room-runtime", version.ref = "roomVersion" }
room-compiler = { module = "androidx.room:room-compiler", version.ref = "roomVersion" }

# WorkManager
work-runtime-ktx = { module = "androidx.work:work-runtime-ktx", version.ref = "workVersion" }

# Hilt, HiltPlugin에서 사용 됨 (hilt.android, hilt.compiler)
hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hiltVersion" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hiltVersion" }
hilt-work = { group = "androidx.hilt", name = "hilt-work", version.ref = "hiltWorkVersion" }
hilt-android-compiler = { group = "androidx.hilt", name = "hilt-compiler", version.ref = "hiltWorkVersion" }

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "kspVersion" }
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hiltVersion" }

[bundles]
room = ["room-ktx", "room-runtime"]

이 프로젝트에서 사용하게 될 라이브러리(work, hilt, room, lifecycle)를 버전 카탈로그에 추가했다. 참고로 Worker 클래스는 Hilt를 사용한 의존성 주입이 가능한데, 이를 위해 hilt-work와 hilt-compiler를 추가한다.

◾ AlarmManager 설정

AlarmManager는 특정 시간에 알람을 켜라고 안드로이드 시스템에 요청한다. 특정 시간이 되면 안드로이드 시스템은 Broadcast를 통해 알람을 울린다.

AlarmScheduler.kt

@Singleton
class AlarmScheduler @Inject constructor(
    @ApplicationContext private val context: Context
) {
    private val alarmManager = context.getSystemService(Application.ALARM_SERVICE) as AlarmManager

    private fun pendingIntent(): PendingIntent {
        val intent = Intent(context, AlarmReceiver::class.java)
        return PendingIntent.getBroadcast(
            context,
            ALARM_CODE,
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )
    }

    fun schedule(triggerAtMillis: Long) {
        Log.d("LOG_TAG", "AlarmScheduler on")
        val pi = pendingIntent()
        alarmManager.setAndAllowWhileIdle(
            AlarmManager.RTC_WAKEUP,
            triggerAtMillis,
            pi
        )
    }

    fun cancel() {
        alarmManager.cancel(pendingIntent())
    }
}

AlarmScheduler 클래스는 알람을 예약하는 역할을 하는 클래스다.

PendingIntent에 Broadcast를 받을 Class와 알람이 어떻게 동작할지에 대한 플래그를 정의한다.

- PendingIntent.FLAG_UPDATECURRENT
ALARM_CODE로 이미 등록된 PendingIntent가 있을 경우 기존 알람을 취소하지 않고 내용을 현재 Intent로 덮어쓰기(알람 시간 재설정)
- PendingIntent.FLAG_IMMUTABLE
시스템이 이 Intent 내용을 수정할 수 없다고 명시(Android 12 이상부터 필수)

schedule() 함수에서는 알람을 등록하는 역할을 하며, alarmManager.setAndAllowWhileIdle() 함수가 이 기능을 담당한다. triggerAtMillis가 알람이 울릴 정확한 시간이다.(밀리초 단위의 UTC 타임스태프)

- RTC_WAKEUP
RTC(Real Time Clock)은 실제 시간을 의미하고, WAKEUP은 기기가 Doze 모두(깊은 절정 상태)에 빠져 있더라도 강제로 기기를 깨우는 것을 의미한다.

AlarmReceiver.kt

class AlarmReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        Log.d("LOG_TAG", "AlarmReceiver On")

        val workManager = WorkManager.getInstance(context.applicationContext)
        val workerRequest = OneTimeWorkRequestBuilder<SampleCountWorker>()
            .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
            .build()

        workManager.enqueueUniqueWork(
            "SampleCountWorkName",
            ExistingWorkPolicy.KEEP,
            workerRequest
        )
    }
}

AlarmReceiver 클래스는 알람을 수신하여 동작할 행동을 정의한 클래스다. AlarmScheduler에서 지정한 시간이 되면 AlarmMangaer가 Intent를 통해 AlarmReceiver를 깨운다.

BraodcastReceiver가 알람을 수신하게 되면 onReceive() 함수가 자동으로 호출된다. onReceive 블록에서는 백그라운드 작업을 위해 WorkManager에 위임한다. onReceive()에서 모든 작업을 끝내지 않는 이유는 해당 함수가 메인 스레드에서 실행이 되고, 약 10초가 넘어가면 ANR을 발생시킨다고 한다.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />

    <application
        android:name=".SampleApplication"
        ...
       
       
        <receiver
            android:name=".core.alarm.AlarmReceiver"
            android:exported="false" />
    </application>
</manifest>

정확한 시간에 알람을 사용하기 위해 SCHEDULE_EXACT_ALARM이라는 특수 권한을 선언한다. 그리고 BroadcastReceiver를 사용하기 때문에 Manifest에 AlarmReceiver를 등록해 준다.

MainViewModel.kt

fun setAlarmManager() {
    val timer = 5 // timer(초) 이후 alarmManager 실행
    val calendar = Calendar.getInstance()
    calendar.add(Calendar.SECOND, timer)

    val newHour = calendar.get(Calendar.HOUR_OF_DAY)
    val newMinute = calendar.get(Calendar.MINUTE)
    val newSecond = calendar.get(Calendar.SECOND)

    // 값 업데이트 (ui 업데이트)
    _selectedHour.value = newHour
    _selectedMinute.value = newMinute
    _selectedSecond.value = newSecond

    alarmScheduler.cancel() // 기존 알람 제거
    alarmScheduler.schedule(triggerAtMillis = calendar.timeInMillis)

    viewModelScope.launch {
        _toastEvent.emit("${timer}초 뒤에 WorkManager가 실행됩니다.")
    }
}

알람 세팅 버튼을 누르면 ViewModel의 setAlarmManager() 함수를 호출하게 했는데, 임시 설정으로 현재 시간에 5초를 더한 시간에 알람을 울리게 하였다.

◾ WorkManager + Hilt로 의존성 주입하기

SampleApplication.kt

@HiltAndroidApp
class SampleApplication : Application(), Configuration.Provider {
    @Inject
    lateinit var workerFactory: HiltWorkerFactory

    override val workManagerConfiguration: Configuration
        get() = Configuration.Builder().setWorkerFactory(workerFactory).build()
}

Hilt가 제공하는 HiltWorkerFactory를 WorkManager의 기본 팩토리로 지정해 준다. 이 설정을 통해 WorkManager가 Hilt로부터 의존성을 주입받은 Worker를 생성할 수 있게 된다.

AndroidManifest.xml

    <application
        android:name=".SampleApplication"
        ...

        <provider
            android:name="androidx.startup.InitializationProvider"
            android:authorities="${applicationId}.androidx-startup"
            tools:node="remove"/>
    </application>

work-runtime 라이브러리에는 기본적으로 WorkManager를 초기화하는 기능이 추가되어 있어서 앱을 시작하면 InitializationProvider가 자동으로 WorkManager를 기본 설정으로 초기화한다. 그래서 SampleApplication에서 초기화 코드를 작성했음에도 적용이 안 되는 문제가 발생한다. tools:node="remove"를 사용하여 InitializationProvider 자체를 제거하여 자동 초기화를 막아준다.

SampleCountWorker.kt

@HiltWorker
class SampleCountWorker @AssistedInject constructor(
    @Assisted appContext: Context,
    @Assisted params: WorkerParameters,
    private val increaseSampleCountUseCase: IncreaseSampleCountUseCase
) : CoroutineWorker(appContext = appContext, params = params) {
    override suspend fun doWork(): Result {
        try {
            Log.d("LOG_TAG", "SampleCountWorker On")
            increaseSampleCountUseCase()
        } catch (e: Exception) {
            Log.e("SampleCountWorker", "Error increasing sample count", e)
        }

        return Result.success()
    }
}

SampleCountWorker는 Worker가 동작하는 클래스다. CoroutineWorker는 WorkManager의 Worker 클래스 중 하나로 작업을 실행하는 함수 doWork()가 suspend 함수가 된다. 이로 인해 비동기 코드를 doWork 블록 내부에서 간단하게 사용할 수 있다.

의존성 주입 관련하여 다음과 같다.

- @HiltWorker
Worker 클래스를 Hilt가 관리함을 알림
- @AssistedInject
(런타임에 사용되는 값 + DI 요소)인 경우에 사용하는 패턴
- @Assited
WorkerManager가 런타임 시 제공할 요소임을 알림
- IncreaseSampleCountUseCase
Application에서 선언한 HiltWorkerFactory가 Hilt 그래프로부터 해당 클래스를 찾아줌

[AlarmManager Set] 버튼을 클릭하면 5초 뒤 AlarmManger를 통해 WorkManager가 실행되고 Room의 Sample 값을 1 증가시킨다. View에서는 Sample 값을 Flow로 수집을 하고 있기 때문에 백그라운드에서 값이 업데이트가 정상적으로 되었는지 확인할 수 있다.

전체 코드

Android_Study/WorkManager with AlarmManager at master · OhGyong/Android_Study

안드로이드 개발 공부. Contribute to OhGyong/Android_Study development by creating an account on GitHub.

github.com

[Android] Could not create task ':app:kspDebugKotlin'.

O_Gyong — Tue, 14 Oct 2025 19:46:28 +0900

Could not determine the dependencies of task ':app:compileDebugJavaWithJavac'.
> Could not create task ':app:kspDebugKotlin'.
> Cannot query the value of task ':app:kspDebugKotlin' property 'classpathSnapshotProperties.useClasspathSnapshot' because it has no value available.

프로젝트를 새로 만들고 의존성을 추가 후 앱을 실행했더니 위와 같은 에러가 발생했다. 의존성을 추가하고 sync에서 문제가 발생하지 않아서 조금 헤매었는데, 이 에러는 KGP와 KSP의 버전이 불일치할 때 자주 나타난다고 한다.

버전 카탈로그에 적용한 버전 정보를 보면 kotlin과 kspVersion의 버전이 맞지 않았다. 코틀린 버전을 ksp에 맞춰 "2.1.10"으로 수정했더니 정상적으로 앱이 빌드 됐다.

[Android] 인앱 업데이트(in-app update) 적용하기

O_Gyong — Wed, 17 Sep 2025 22:35:19 +0900

인앱 업데이트 | Other Play guides | Android Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. 인앱 업데이트 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 사용자는 기기에서 앱을 최신 상태로

developer.android.com

플레이스토어에 앱을 최신 버전으로 배포했을 때, 앱을 사용하던 유저에게 업데이트 할 것을 알리고 싶을 때가 있다. 인앱 업데이트(in-app update)는 이것을 가능하게 하는 Google Play Core 라이브러리 기능이다.

◾ 업데이트 방식

1. 유연한 업데이트(Flexible udpates)

유연한 업데이트는 사용자가 업데이트를 하는 동안 앱을 사용하는 경우에 적합하다. 이 방식은 앱 사용 흐름에 방해를 주지 않고 업데이트를 진행할 수 있다는 점이 특징이다. 백그라운드에서 업데이트가 진행되고, 업데이트가 완료된 후 앱이 재실행되어 새로운 버전을 사용할 수 있게 된다.

유연한 업데이트 예시 (하단 업데이트 팝업)

2. 즉시 업데이트(immediate updates)

즉시 업데이트는 사용자의 앱 사용을 막고 업데이트를 우선하는 방식으로, 업데이트가 중요한 경우에 적합하다. 앱을 강제로 업데이트해야 하는 경우에 이 방식이 좋아 보인다.

즉시 업데이트 예시 (전체 화면 팝업)

◾ in-app updates 적용하기

스플래시가 구현된 프로젝트는 스플래시 화면에서, 그렇지 않은 경우는 로그인 화면에서 앱 업데이트 체크를 진행하도록 했다. 즉시 업데이트 방식을 사용하여 사용자가 최신 버전을 사용할 수 있게끔 했다.

1. 라이브러리 등록

build.gradle.kts(:app)

implementation("com.google.android.play:app-update-ktx:2.1.0")

in-app updates 라이브러리를 사용하기 위해 Gradle에 라이브러리를 등록시켜 준다.

2. 업데이트 가능 여부 확인 및 업데이트

앱 업데이트를 체크하는 화면

private val appUpdateManager: AppUpdateManager by lazy {
    AppUpdateManagerFactory.create(applicationContext)
}

private fun checkAppUpdate(intentType: Boolean) {
    // PlayStore에서 설치된 경우 설치 경로가 "com.android.vending"으로 됨
    val isRegisteredPlayStore = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { // Android 11 기준
        val info = packageManager.getInstallSourceInfo(packageName)
        info.installingPackageName == "com.android.vending"
    } else {
        packageManager.getInstallerPackageName(packageName) == "com.android.vending"
    }

    // PlayStore에 등록된 앱 아닌 경우 앱 체크 안 하도록 처리
    // 로컬 빌드는 앱 등록이 무조건 안 된 것으로 체크하여 addOnFailureListener를 타게 됨
    if (!isRegisteredPlayStore) {
        intentLogin(intentType)
        return
    }

    appUpdateManager.appUpdateInfo
        // PlayStore 통신 성공
        .addOnSuccessListener { appUpdateInfo ->
            if ((appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE))
                || appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS
            ) { 
            	// 업데이트 시작
                appUpdateManager.startUpdateFlowForResult(
                    appUpdateInfo,
                    this@SplashActivity,
                    AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build(),
                    100
                )
            } else {
                intentLogin(intentType)
            }
        }
        // PlayStore 통신 실패 (Ex- PlayStore에 앱 등록이 안 된 경우)
        .addOnFailureListener { e ->
            Toast.makeText(this, "앱 업데이트 실패", Toast.LENGTH_SHORT).show()
        }
}

앱 업데이트를 요청하기 전에 앱이 먼저 업데이트가 필요한지를 확인해야 한다. AppUpdateManager를 사용하여 업데이트가 있는지 확인할 수 있다.

(appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE && appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
즉시 업데이트 가능한 상태인지

appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS
이전 업데이트에서 중단된 상태인지

PlayStore에 앱이 등록된 경우 addOnSuccessListener 블록을 타게 되는데, 여기서 즉시 업데이트가 가능한 상태인지 그리고 이전의 업데이트에서 중단된 상태는 아닌지 확인한다.

이후 startUpdateFlowForResult()를 통해 업데이트를 시작한다. (업데이트 전체 화면으로 전환)

※ 참고

로컬 환경에서 빌드한 앱의 경우 PlayStore에 앱 등록이 안 된 것으로 판단하여 addOnFailureListener 블록이 실행된다. PlayStore에서 설치된 앱은 설치 경로가 "com.android.vending"으로 되어 있어서 구분이 가능하므로, 로컬 빌드인 경우에 대한 처리를 추가했다.

[Android] WebView에서 다운로드 동작이 안 되는 이유

O_Gyong — Wed, 17 Sep 2025 16:35:42 +0900

공지사항 화면을 WebView로 관리하고 있는데, 게시글 중에서 apk를 다운로드할 수 있는 링크를 클릭했는데 아무 이벤트가 동작하지 않는 문제가 생겼다. 신기한 점은 다른 WebView에서 똑같은 url로 같은 화면을 띄우는데, 다운로드 동작이 정상적으로 되었다.

해당 부분을 찾아보니 WebView를 사용할 때 WebViewClient를 적용한 경우 WebView의 기본 동작을 WebViewClient의 shouldOverrideUrlLoading()이 대신 수행한다고 한다.

그래서 WebViewClient를 적용 안 한 WebView의 경우 다운로드와 같은 특수 MIME 타입은 자동으로 외부 브라우저로 넘겨 처리를 하기 때문에 다운로드가 정상으로 동작한다. 하지만 WebViewCilent를 적용하면 shouldOverrideUrlLoading()이 WebView의 기본 동작을 대신하기 때문에 따로 처리를 하지 않으면 아무 동작을 하지 않는다.

해당 내용을 알고 공지사항의 WebView와 다른 WebView에 사용된 WebViewClient를 비교해 봤는데 공지사항 쪽 Client는 url 링크 처리나 다운로드 관련 처리가 없었고, 다른 WebView의 Client는 아래와 같은 처리가 되어 있어서 다운로드를 할 수 있었다.

override fun shouldOverrideUrlLoading(
    view: WebView?,
    request: WebResourceRequest?
): Boolean {
    view?.context ?: return false

    try {
        val intent = Intent(Intent.ACTION_VIEW, request?.url)
        view.context?.startActivity(intent)
        return true
    } catch (e: Exception) {
        return false
    }
}

[Android] Multi Module + build-logic + hilt

O_Gyong — Mon, 8 Sep 2025 21:44:55 +0900

최근에 프로젝트에 새로 들어가면서 구조를 설계하게 되었다. 마지막에 다뤘던 방식은 presentation-domain-data로 틀을 잡고 다른 필요한 부분(common 등)은 모듈로 추가하는 방식을 썼는데, 이번에 Now In Android(NIA)의 구조를 참고하면서 그 내용을 정리해 봤다. NIA와 차이가 있는데, feature-core 대신 feature-domain-data로 틀을 잡고 core 모듈에 common과 di 등을 두는 걸 생각했다.

◾ 모듈 생성하기

File > New > New Module을 통해 모듈을 생성할 수 있다.

모듈을 생성할 때 Templates 항목에 여러 가지가 있는데, 사용하는 항목들은 아래와 같다.

1. Phone&Tablet
앱 실행에 필요한 모든 요소(Activity, Manifests, Resource 파일 등)를 포함하며 최종적으로 .apk 또는 .aab 파일을 만드는 모듈이다. 보통 프로젝트를 생성할 때 생기는 app 모듈이 여기에 속한다.

2. Android Library
안드로이드 프레임워크를 사용하는 라이브러리 코드가 포함된 모듈이다. 'Phone&Tablet'과의 차이는 .aar 파일을 만든다.
ex) feature, data

3. Java or Kotlin Library
순수 자바 또는 코틀린으로만 이루어졌으며 빌드 시 .jar 파일을 만드는 모듈이다. 안드로이드 프레임워크에 의존하지 않기 때문에 domain 모듈에서 사용하려고 한다.
ex) core:common, domain, build-logic

※ 참고
feature:home, feature:setting(또는 core:common, core:ui)과 같은 구조를 만들려면 feature 폴더를 만들고 하위 레이어의 항목들을 별도의 모듈로 만든 후 해당 폴더에 이동시켜야 한다. 그리고 다음과 같이 settings.gradle에서 projectPaths를 수정해 준다.

settings.gradle.kts(Project)

// 수정 전
include(":home")

// 수정 후
include(":feature:home")

include는 하나의 Gradle 빌드에 모듈을 포함시키는 기능을 한다.

◾ build-logic 적용(커스텀 플러그인)

build-logic 모듈은 프로젝트에서 사용되는 빌드 로직을 중앙 집중화하고 재사용하기 위해 사용되는 모듈이다. 흔히 커스텀 플러그인이라고 하는 것이 build-logic 모듈 내에 담을 플러그인을 말한다.

settings.gradle.kts(Project)

pluginManagement {
    includeBuild("build-logic")
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")

rootProject.name = "ArchitectureMultiModule"
include(":app")
include(":feature:home")
include(":domain")
include(":data")
include(":core:common")

build-logic 모듈을 만들면 includeBuild("build-logic")를 선언하여 프로젝트에 build-logic이 포함되었고, 다른 모듈에서 플러그인처럼 사용할 수 있게 해달라고 알린다.

enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")는 문자열 기반의 모듈 종속성을 코틀린 객체로 자동 변환을 시켜주고, gradle에 projects 접근 권한을 부여한다.(settings.gradle:build-logic에 선언해도 괜찮음) 이 명령어를 통해 아래와 같이 쓸 수 있다.

build.gradle.kts(:app)

// 적용 전
dependencies {
    implementation(project(":feature:home"))
}

// 적용 후
dependencies {
    implementation(projects.feature.home)
}

※ 참고
rootProject 이름에 특수문자나 공백이 있을 경우 에러가 발생한다.

Extension.kt

internal val Project.applicationExtension: CommonExtension<*, *, *, *, *, *>
    get() = extensions.getByType<ApplicationExtension>()

internal val Project.libraryExtension: CommonExtension<*, *, *, *, *, *>
    get() = extensions.getByType<LibraryExtension>()

internal val Project.androidExtension: CommonExtension<*, *, *, *, *, *>
    get() = runCatching { applicationExtension }
        .recoverCatching { libraryExtension }
        .onFailure { println("Could not find Library or Application extension from this project") }
        .getOrThrow()

internal val ExtensionContainer.libs: VersionCatalog
    get() = getByType<VersionCatalogsExtension>().named("libs")

build-logic에서 사용하게 될 Proejct와 VersionCatalog이다. Application과 Library 타입을 같이 처리하기 위해서 runCatching과 recoverCatching을 사용했다. 마지막은 버전 카탈로그를 코드로 쉽게 불러올 수 있게 하도록 선언했다.

KotlinAndroidPlugin.kt

internal class KotlinAndroidPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            val libs = extensions.libs

            pluginManager.apply("org.jetbrains.kotlin.android") // pluginId 접근 1
            pluginManager.apply(libs.findPlugin("kotlin-compose").get().get().pluginId) // pluginId 접근 2

            androidExtension.apply {
                compileSdk = 36

                defaultConfig {
                    minSdk = 26
                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
                }

                buildTypes {
                    getByName("release") {
                        isMinifyEnabled = false
                        proguardFiles(
                            getDefaultProguardFile("proguard-android-optimize.txt"),
                            "proguard-rules.pro"
                        )
                    }
                }

                compileOptions {
                    sourceCompatibility = JavaVersion.VERSION_17
                    targetCompatibility = JavaVersion.VERSION_17
                }
            }

            extensions.configure<KotlinAndroidProjectExtension> {
                compilerOptions.jvmTarget.set(JvmTarget.JVM_11)
            }

            dependencies {
                add("implementation", libs.findLibrary("androidx-core-ktx").get())
                add("implementation", libs.findLibrary("androidx-activity-compose").get())
                add("implementation", libs.findLibrary("androidx-ui").get())
                add("implementation", libs.findLibrary("androidx-ui-graphics").get())
                add("implementation", libs.findLibrary("androidx-ui-tooling-preview").get())
                add("implementation", libs.findLibrary("androidx-material3").get())
                add("implementation", platform(libs.findLibrary("androidx-compose-bom").get()))
                add("testImplementation", libs.findLibrary("junit").get())
                add("androidTestImplementation", libs.findLibrary("androidx-junit").get())
                add("androidTestImplementation", libs.findLibrary("androidx-espresso-core").get())
            }
        }
    }
}

KotlinAndoridPlugin은 Application과 Library에서 공통으로 사용되는 Android/Kotlin 설정을 묶어둔 커스텀 플러그인이다. plugins, android, dependencis을 모두 포함하여 중복 코드를 줄이고 일관되게 관리할 수 있다. 다만 Apllication마다 그리고 Library마다 공통으로 쓰이는 부분이 있어서 모듈의 양이 많다면 예시와 달리 AplicationPlugin, LibraryPlugin으로 분리하는 것이 더 좋아 보인다. 이 경우 NIA의 build-logic을 참고하면 도움이 될 거 같다.

build.gradle.kts(build-logic)

plugins {
    `kotlin-dsl`
    `kotlin-dsl-precompiled-script-plugins`
}

dependencies {
    compileOnly(libs.android.gradlePlugin)
    compileOnly(libs.kotlin.gradlePlugin)
}

kotlin {
    compilerOptions {
        jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11
    }
}

gradlePlugin {
    plugins {
        register("kotlinAndroid") {
            id = libs.plugins.architecturemultimodule.android.kotlinAndroid.get().pluginId
            implementationClass = "com.study.architecturemultimodule.build_logic.KotlinAndroidPlugin"
        }
    }
}

커스텀 플러그인 작업이 끝나면 각 모듈에서 사용할 수 있도록 Gradle에 등록해야 한다. gradlePlugin에 커스텀 플러그인을 등록해 준다.

(왼) gradle(app) / (오) gradle(feature:home)

이제 각 모듈의 plugins에 등록하여 사용할 수 있다. 이런 식으로 공통된 부분을 build-logic에서 처리하여 반복되는 코드를 줄이고 일관성을 유지할 수 있게 되었다.

※ 참고

커스텀 플러그인을 모듈에 등록할 때 application 또는 library 보다 먼저 선언되면 안 된다. Gradle을 빌드 스크립트를 순차적으로 처리하기 때문에 먼저 선언하게 되면 android 블록이 생성되지 않아 에러가 발생한다.

◾ build-logic에서 버전 카탈로그 접근하기

지금까지의 내용을 보면 KotlinAndroidPlugin을 libs로 접근하고 있는데, 접근하는 방법은 다음과 같다.

libs.versions.toml

architecturemultimodule-android-kotlinAndroid = {id = "architecturemultimodule.android.kotlinAndroid"}

우선 버전 카탈로그에 커스텀 플러그인 id를 등록한다.

settings.gradle.kts(build-logic)

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
    versionCatalogs {
        create("libs") {
            from(files("../gradle/libs.versions.toml"))
        }
    }
}

rootProject.name = "build-logic"

그다음 settings.gradle.kts(build-logic)을 만든다. include 명령어로 선언된 모듈은 libs(버전 카탈로그)에 그냥 접근할 수 있지만 includeBuild()로 선언된 build-logic의 경우 libs에 바로 접근할 수 없다. 그래서 별도의 settings.gradle.kts(build-logic)를 만들어서 버전 카탈로그에 접근할 수 있게 위의 처리를 해준다.

참고로 버전 카탈로그에 등록하지 않을 경우 다음과 같이 사용할 수 있다.

build.gradle.kts

# build.gradle/kts(build-logic)
gradlePlugin {
    plugins {
        register("kotlinAndroid") {
            id = "architecturemultimodule.android.kotlinAndroid"
            implementationClass = "com.study.architecturemultimodule.build_logic.KotlinAndroidPlugin"
        }
    }
}

# build.gradle/kts(app) 
plugins {
	alias(libs.plugins.android.application)
	id("architecturemultimodule.android.kotlinAndroid")
}

◾ Hilt 적용하기

libs.versions.toml

[versions]
// ...
hilt = "2.48"
ksp = "2.0.21-1.0.27"
androidxHiltNavigationCompose = "1.2.0"

[libraries]
// ...
# Hilt 관련 Plugin에서 사용
androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version.ref = "androidxHiltNavigationCompose" }
hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
hilt-core = { group = "com.google.dagger", name = "hilt-core", version.ref = "hilt" }
hilt-android-compiler = { group = "com.google.dagger", name = "hilt-android-compiler", version.ref = "hilt" }
hilt-android-testing = { group = "com.google.dagger", name = "hilt-android-testing", version.ref = "hilt" }

[plugins]
// ...
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }

우선 Hilt 사용을 위해 버전 카탈로그에 필요한 라이브러리를 등록한다.

HiltAndroidPlugin.kt

internal class HiltAndroidPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("com.google.dagger.hilt.android")
            pluginManager.apply("com.google.devtools.ksp")

            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")

            dependencies {
                add("implementation", libs.findLibrary("hilt.android").get())
                add("ksp", libs.findLibrary("hilt.compiler").get())
                add("kspAndroidTest", libs.findLibrary("hilt.compiler").get())
            }
        }
    }
}

HiltCorePlugin.kt

internal class HiltCorePlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("com.google.devtools.ksp")

            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")

            dependencies {
                "implementation"(libs.findLibrary("hilt.core").get())
                "ksp"(libs.findLibrary("hilt.compiler").get())
            }
        }
    }
}

Hilt를 각 모듈에서 사용하기 위해 커스텀 플러그인을 만들어야 하는데, app과 featrue 같은 android에 의존하는 모듈은 hilt-android를 사용해도 되지만 domain 같은 순수 kotlin 영역은 hilt-core를 사용해야 한다. 그래서 커스텀 플러그인을 만들 때 HiltAndroidPlugin, HiltCorePlugin을 만들었다.

libs.versions.toml

# Custom Plugin
architecturemultimodule-android-kotlinAndroid = { id = "architecturemultimodule.android.kotlinAndroid" }
architecturemultimodule-hiltAndroid = {id = "architecturemultimodule.hiltAndroid" }
architecturemultimodule-hiltCore = {id = "architecturemultimodule.hiltCore" }

build.gradle.kts

# build.gradle.kts(:app)
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.architecturemultimodule.android.kotlinAndroid)
	alias(libs.plugins.architecturemultimodule.android.hiltAndroid)
}

# build.gradle.kts(:domain)
plugins {
    alias(libs.plugins.jetbrains.kotlin.jvm)
    alias(libs.plugins.architecturemultimodule.hiltCore)
}

# build.gradle.kts(:build-logic)
gradlePlugin {
    plugins {
        register("kotlinAndroid") {
            id = "architecturemultimodule.android.kotlinAndroid"
            implementationClass = "com.study.architecturemultimodule.build_logic.KotlinAndroidPlugin"
        }

        register("hiltAndroid") {
            id = "architecturemultimodule.hiltAndroid"
            implementationClass = "com.study.architecturemultimodule.build_logic.HiltAndroidPlugin"
        }

        register("hiltCore") {
            id = "architecturemultimodule.hiltCore"
            implementationClass = "com.study.architecturemultimodule.build_logic.HiltCorePlugin"
        }
    }
}

플러그인을 만들면 kotlinAndroid에 했던 것처럼 hiltAndroid와 hiltCore를 등록한다.. 이후 각 모듈의 plugins에 hiltAndroid 또는 hiltCore를 추가하여 사용하면 된다.

(왼) gradle(:app) / (오) gradle(core:di)

Hilt 모듈 바인딩 설정을 core:di 모듈에서 하고 있어서 gradle(:core:di)에 data와 domain 모듈을 등록해야 하고, HiltAndroidApp을 기점으로 di가 매핑되기 때문에 gradle(:app)에 core:di 모듈을 등록해야 한다.

전체 코드

Android_Study/Architecture Multi Module at master · OhGyong/Android_Study

안드로이드 개발 공부. Contribute to OhGyong/Android_Study development by creating an account on GitHub.

github.com

[Android][Compose] kizitonwose/Calendar, 캘린더 라이브러리 사용기 #3

O_Gyong — Mon, 14 Jul 2025 22:20:31 +0900

[Android] kizitonwose/Calendar, 캘린더 라이브러리 사용기 #2

[Android] kizitonwose/Calendar 캘린더 라이브러리 사용기 #1GitHub - kizitonwose/Calendar: A highly customizable calendar view and compose library for Android and Kotlin Multiplatform.A highly customizable calendar view and compose library for And

ogyong.tistory.com

kizitonwose/Calendar, 캘린더 라이브러리 사용기 #2는 View 기반으로 작업을 하였다. 이번에는 Compose를 기반으로 사용해 봤다. Compose로 사용하는 방법에 대해서도 정리가 잘 되어 있어서 큰 어려움 없이 적용할 수 있었다. (Compose 기반 설명서)

◾ 임시 데이터 설정

class MainActivity : AppCompatActivity() {
    private var sampleList = listOf<SampleData>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .background(Color.White)
                    .windowInsetsPadding(WindowInsets.systemBars)
            ) {
                setSampleData()
                MainScreen(sampleList)
            }

        }
    }

    private fun setSampleData() {
        val today = LocalDate.now()
        val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
        sampleList = (0 until 50).map { i ->
            SampleData(
                total = Random.nextInt(10, 100),
                date = today.minusDays(i.toLong()).format(formatter)
            )
        }
    }
}

UI 작업은 MainScreen에서 하는데, 그전에 임시 데이터 설정을 MainActivity에서 전달해 줬다.

◾ CalendarView 적용하기

@Composable
fun MainScreen(sampleList: List<SampleData> = listOf()) {
    val currentMonth = remember { YearMonth.now() }
    val startMonth = remember { currentMonth.minusMonths(2) }
    val endMonth = remember { currentMonth.plusMonths(0) }
    val daysOfWeek = remember { daysOfWeek() }

    // 60일 전과 오늘 이후 날짜 사용 금지
    val today = LocalDate.now()
    val agoDate = today.minusDays(60)

    val calendarState = rememberCalendarState(
        startMonth = startMonth,
        endMonth = endMonth,
        firstVisibleMonth = currentMonth,
        firstDayOfWeek = daysOfWeek.first()
    )

    HorizontalCalendar(
        state = calendarState,
        dayContent = {
            Day(
                day = it,
                sampleList = sampleList,
                useDate = !it.date.isBefore(agoDate) && !it.date.isAfter(today),
            )
        }
    )
}

@Composable
fun Day(
    day: CalendarDay,
    sampleList: List<SampleData>,
    useDate: Boolean,
) {
    val count = sampleList.find { it.date == day.date.toString() }?.total?:0

    Box(
        modifier = Modifier.aspectRatio(1f),
        contentAlignment = Alignment.Center
    ) {
        Column {
            Text(
                modifier = Modifier.align(Alignment.CenterHorizontally),
                text = day.date.dayOfMonth.toString(),
                color =
                    if(useDate) {
                        colorResource(R.color.black)
                    } else {
                        colorResource(R.color.colorGray)
                    },
                style = CalendarTheme.bodyMedium
            )

            if(useDate) {
                Text(
                    text = "${count}건",
                    color = colorResource(R.color.colorPurple),
                    style = CalendarTheme.bodySmall
                )
            }
        }
    }
}

우선 설명서의 내용에 따라 기본적인 세팅을 했다. currentMonth에 minusMonths를 2, plustMonths를 0으로 하여 CalendarView의 스크롤을 제한했다. 그리고 60일 전과 오늘 이후 날짜에 대한 영역을 비활성화가 되도록 useDate를 만들었다.

◾ 요일 표시하기

@Composable
fun MainScreen(sampleList: List<SampleData> = listOf()) {
    // 생략

    HorizontalCalendar(
        state = calendarState,
        dayContent = {
            Day(
                day = it,
                sampleList = sampleList,
                useDate = !it.date.isBefore(agoDate) && !it.date.isAfter(today),
            )
        },
        monthHeader = { month ->
            val daysOfWeek = month.weekDays.first().map { it.date.dayOfWeek }
            Week(daysOfWeek = daysOfWeek)
        }
    )
}

@Composable
fun Week(daysOfWeek: List<DayOfWeek>) {
    Row(modifier = Modifier.fillMaxWidth()) {
        for (dayOfWeek in daysOfWeek) {
            Text(
                modifier = Modifier.weight(1f),
                text = dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.getDefault()),
                color = colorResource(when(dayOfWeek) {
                    DayOfWeek.SUNDAY -> {
                        R.color.colorRed
                    }
                    DayOfWeek.SATURDAY -> {
                        R.color.colorBlue
                    }
                    else -> {
                        R.color.colorDarkGray
                    }
                }),
                style = CalendarTheme.titleMedium
            )
        }
    }
}

HorizontalCalendar의 monthHeader를 통해 캘린더의 머리글을 정할 수 있는데, 요일명을 넘겨줘서 요일을 표시했다. 요일을 표시할 때 일요일과 토요일은 컬러를 각각 빨간색과 파란색으로 했다.

◾ 연, 월 타이틀 표시하기

@Composable
fun MainScreen(sampleList: List<SampleData> = listOf()) {
    // 생략

    val calendarState = rememberCalendarState(
        startMonth = startMonth,
        endMonth = endMonth,
        firstVisibleMonth = currentMonth,
        firstDayOfWeek = daysOfWeek.first()
    )

    Column {
        YearMonthTitle(calendarState)
        HorizontalCalendar(
            // 생략
        )
    }
}

@Composable
fun YearMonthTitle(calendarState: CalendarState) {
    val yearMoth = calendarState.firstVisibleMonth.yearMonth.toString()
    Text(
        modifier = Modifier.fillMaxWidth(),
        textAlign = TextAlign.Center,
        text = yearMoth,
        style = CalendarTheme.titleLarge,
        color = colorResource(R.color.black)
    )
}

rememberCalendarState는 값이 업데이트되는 것을 감지하여 리 컴포지션을 해준다. 리 컴포지션이 되는 것을 이용하여 연도와 월을 표시했다. firstVisibleMonth는 CalendarView에 표시되는 첫 번째 달 값이라고 한다.

◾ 날짜 선택

@Composable
fun MainScreen(sampleList: List<SampleData> = listOf()) {
    // 생략
    
    var selectedDate by remember { mutableStateOf<LocalDate?>(null) }

    Column {
        YearMonthTitle(calendarState)
        HorizontalCalendar(
            modifier = Modifier.padding(top = 10.dp),
            state = calendarState,
            dayContent = {
                Day(
                    day = it,
                    sampleList = sampleList,
                    isSelected = selectedDate == it.date,
                    useDate = !it.date.isBefore(agoDate) && !it.date.isAfter(today),
                    onClick = { calendarDay ->
                        selectedDate = if(selectedDate == it.date) null else it.date
                    }
                )
            },
            monthHeader = { month ->
                val daysOfWeek = month.weekDays.first().map { it.date.dayOfWeek }
                Week(daysOfWeek = daysOfWeek)
            }
        )
    }
}

@Composable
fun Day(
    day: CalendarDay,
    sampleList: List<SampleData>,
    isSelected: Boolean,
    useDate: Boolean,
    onClick: (CalendarDay) -> Unit
) {
    val count = sampleList.find { it.date == day.date.toString() }?.total?:0

    Box(
        modifier = Modifier
            .aspectRatio(1f)
            .background(
                color = if (isSelected) colorResource(R.color.colorPurple) else Color.Transparent
            )
            .clickable(
                enabled = useDate,
                onClick = { onClick(day) }
            ),
        contentAlignment = Alignment.Center
    ) {
        Column {
            Text(
                modifier = Modifier.align(Alignment.CenterHorizontally),
                text = day.date.dayOfMonth.toString(),
                color =
                    if(useDate) {
                        if(isSelected) colorResource(R.color.white)
                        else colorResource(R.color.black)
                    } else {
                        colorResource(R.color.colorGray)
                    },
                style = CalendarTheme.bodyMedium
            )

            if(useDate) {
                Text(
                    text = "${count}건",
                    color =
                        if(isSelected) colorResource(R.color.white)
                        else colorResource(R.color.colorPurple),
                    style = CalendarTheme.bodySmall
                )
            }
        }
    }
}

날짜 클릭과 선택 해제를 위해서 MainScreen에는 selectedDate 변수를 추가하고, Day UI에 isSelected와 onClick을 매개변수로 추가했다.

전체 코드

Android_Study/Calendar by Kizitonwose at calendar-by-kizitonwose-step3 · OhGyong/Android_Study

안드로이드 개발 공부. Contribute to OhGyong/Android_Study development by creating an account on GitHub.

github.com