• 안드로이드 프로젝트를 멀티 모듈 구조로 변경하면서 build.gradle.kts 파일이 많아 관리가 힘든 문제 발생
• common.gradle파일을 사용해 공통되는 부분을 줄였지만, 여전히 파일을 하나하나 관리해야 함
• build-logic 모듈을 사용해 플러그인 형태로 관리하려고 함

🧱 build-logic 모듈 생성

• build-logic모듈 생성

  • Android 모듈과 Kotlin 모듈 둘 다 해봤는데 되는 것 같음

• 테스트, 리소스 등 불필요한 파일은 정리

🧭 설정 파일 구성

🔧 build-logic/settings.gradle.kts

해당 파일이 없으면 직접 생성해야함함

enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")

@Suppress("UnstableApiUsage")
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }

    // 버전 카탈로그 사용할 수 있게 설정정
    versionCatalogs {
        create("libs") {
            from(files("../gradle/libs.versions.toml"))
        }
    }
}

🔧 프로젝트의 settings.gradle.kts

pluginManagement {
    includeBuild("build-logic")
}

❗ 모듈을 만들면 추가되는 include(":build-logic")는 제거

📦 라이브러리 정의 (libs.versions.toml)

[versions]
kotlin = "2.0.0"
androidGradlePlugin = "8.5.0"
org-jetbrains-kotlin-android = "1.9.24"

[libraries]
android-gradlePlugin = { group = "com.android.tools.build", name = "gradle", version.ref = "androidGradlePlugin" }
kotlin-gradlePlugin = { group = "org.jetbrains.kotlin", name = "kotlin-gradle-plugin", version.ref = "org-jetbrains-kotlin-android" }
compose-compiler-gradle-plugin = { module = "org.jetbrains.kotlin:compose-compiler-gradle-plugin", version.ref = "kotlin" }

📜 build-logic/build.gradle.kts

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

dependencies {
    implementation(libs.android.gradlePlugin)
    implementation(libs.kotlin.gradlePlugin)
    compileOnly(libs.compose.compiler.gradle.plugin)
}

🛠️ 코드 작성 예시

✅ 공통 확장 함수 (Extension.kt)

필수는 아니지만 있으면 편함

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

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

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

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

✅ Compose 설정 함수 (ComposeAndroid.kt)

internal fun Project.configureComposeAndroid() {

    // plugin
    with(plugins) {
        apply("org.jetbrains.kotlin.plugin.compose")
    }

    // library
    val libs = extensions.libs
    androidExtension.apply {
        dependencies {
            val bom = libs.findLibrary("androidx-compose-bom").get()
            add("implementation", platform(bom))
            add("androidTestImplementation", platform(bom))

            add("implementation", libs.findLibrary("androidx.compose.material3").get())
            add("implementation", libs.findLibrary("androidx.compose.ui").get())
            add("implementation", libs.findLibrary("androidx.compose.ui.tooling.preview").get())

            add("androidTestImplementation", libs.findLibrary("androidx.test.ext").get())
            add("androidTestImplementation", libs.findLibrary("androidx.test.espresso.core").get())
            add("androidTestImplementation", libs.findLibrary("androidx.compose.ui.test").get())

            add("debugImplementation", libs.findLibrary("androidx.compose.ui.tooling").get())
            add("debugImplementation", libs.findLibrary("androidx.compose.ui.testManifest").get())
        }
    }

    extensions.getByType<ComposeCompilerGradlePluginExtension>().apply {
        enableStrongSkippingMode.set(true)
        includeSourceInformation.set(true)
    }
}

🔌 플러그인 적용 방법

방법 1: gradlePlugin DSL

다음 클래스 생성해야 함

internal class HiltAndroidPlugin : Plugin<Project> {

    override fun apply(target: Project) {
        with(target) {
            configureHiltAndroid()
        }
    }
}

gradlePlugin {
    plugins {
        register("androidHilt") {
            id = "test.android.hilt"
            implementationClass = "com.test.app.HiltAndroidPlugin"
        }
    }
}

사용 시

plugins {
    id("test.android.hilt")
}

방법 2: Precompiled 스크립트

• 파일명: test.android.compose.gradle.kts

import com.example.build_logic.configureComposeAndroid

configureComposeAndroid()

사용 시

plugins {
    // 파일 이름으로 지정함
    id("test.android.compose")
}

⚠️ 주의 사항

• build-logic에서 다른 프로젝트를 사용해야 할때 kotlin-dsl 같은 방식은 사용이 안되는 것 같음

  // 됨
  implementation(project(":core:ui"))
  

// 안됨 implementation(projects.core.ui)

```

📚 참고자료

• Nowinandroid
• DroidKnightsApp

✅ 정리

• 각 알림이 화면에 등장할 때 애니메이션으로 표시
• 삭제 버튼을 누르면 퇴장 애니메이션 후 알림 제거

💡 개선된 코드 예시

// 알림 그룹
val currentAlarms by rememberUpdatedState(alarms)

LazyColumn(
    modifier = modifier
        .wrapContentWidth()
        .height(300.dp),
    verticalArrangement = Arrangement.spacedBy(10.dp)
) {
    // 특정 개수만 알림 표시
    items(
        items = currentAlarms.takeLast(maxCount),
        key = { it.id }
    ) { alarm ->

        var isVisible by remember { mutableStateOf(false) }
        var isDeleted by remember { mutableStateOf(false) }

        // 알림이 나타날때 애니메이션에 필요
        LaunchedEffect(alarm.id) {
            isVisible = true
        }

        AnimatedVisibility(
            modifier = Modifier.animateItem(),
            visible = isVisible && !isDeleted,
            enter = slideInVertically { it } + fadeIn(),
            exit = slideOutVertically { -it } + fadeOut(),
            exitFinishedListener = {
                // 애니메이션 종료 후 알림 제거
                onAlarmRemoved?.invoke(alarm.id)
            }
        ) {
            AlarmItem(
                event = alarm,
                onClickDismiss = {
                    // 삭제 버튼을 누르면 알림이 지워진 것처럼 애니메이션션
                    isDeleted = true
                }
            )
        }
    }
}

📌 주요 포인트

1. 알림 삭제

• 알림을 삭제할 때 목록에서 바로 삭제하면 애니메이션 없이 삭제되버린다.
• 삭제 애니메이션이 끝나 후 삭제하게 만들어야 함함

2. id

• 목록에서 아이템을 id로 구별하고 애니메이션도 id를 기준으로 동작하기 때문에 id가 중복되면 안됨됨

이를 방지하기 위해 클라이언트에서 SHA-256 해시 함수를 이용한 암호화를 적용할 수 있음

🔧 SHA-256 암호화 함수

/**
 * SHA256 암호화
 */
fun encryptSha256(keyword: String): String {
    return try {
        val md = MessageDigest.getInstance("SHA-256")
        md.update(keyword.toByteArray())
        bytesToHex(md.digest())
    } catch (e: NoSuchAlgorithmException) {
        e.printStackTrace()
        ""
    }
}

🔄 바이트 배열을 16진수 문자열로 변환

/**
 * 바이트 배열을 문자열로
 *
 * @param bytes 바이트 배열
 * @return 문자열
 */
private fun bytesToHex(bytes: ByteArray): String {
    val builder = StringBuilder()
    for (b in bytes) {
        builder.append(String.format("%02x", b))
    }
    return builder.toString()
}

🛡️ 사용 예

val encryptedPassword = encryptSha256("myPassword123")
println("Encrypted: $encryptedPassword")

osmdroid를 사용하여 지도에 커스텀 타일을 추가할 때, 기본 타일은 잘 보이지만 추가한 타일 오버레이가 일부만 보이는 현상 발생

이는 타일은 다운로드되었지만, 실제 그리기 작업이 이루어지지 않았기 때문으로 보임임

⚠️ 문제 상황

• 기본 타일 소스는 정상적으로 전체 영역 표시됨
• 추가한 타일 소스는 일부 타일만 그려짐
• 로그 상으로는 타일이 로드된 것으로 보임 → 렌더링 트리거 누락 가능성

✅ 해결 방법

추가 타일 오버레이 생성 시 tileRequestCompleteHandler를 등록

🔧 코드 예시

val tileSource = MapTileSource.WarshipLocalPortals[level] ?: return

val tileProvider = MapTileProviderBasic(context, tileSource).apply {
    tileRequestCompleteHandlers.add(mapView.tileRequestCompleteHandler)
}

val overlay = TilesOverlay(tileProvider, context)

🔍 코드

LazyListState의 layoutInfo.visibleItemsInfo를 활용하여 현재 화면에 보이는 아이템 정보를 가져올 수 있음

✅ 시작에 도달했는지 확인

/**
 * 현재 스크롤에 첫번째가 포함되는지 검사
 */
internal fun LazyListState.isScrolledStart(): Boolean {
    return layoutInfo.visibleItemsInfo.firstOrNull()?.index == 0
}

✅ 끝에 도달했는지 확인

/**
 * 현재 스크롤에 마지막이 포함되는지 검사
 */
internal fun LazyListState.isScrolledEnd(): Boolean {
    return layoutInfo.visibleItemsInfo.lastOrNull()?.index ==
        layoutInfo.totalItemsCount - 1
}

🧪 사용 예시

val state: LazyListState = rememberLazyListState()

Icon(
    imageVector = Icons.Default.ArrowUpward,
    contentDescription = null,
    tint = if (state.isScrolledStart().not()) Gray10 else Color.Transparent,
)

LazyColumn(
    state = state,
) {
    // 리스트 아이템들
}

이 API를 활용하면 앱에서도 화면 미러링을 할 수 있음

본 글에서는 ExoPlayer를 이용해 미러링을 구현하는 방법을 소개

📱 테스트 환경

• Galaxy Tab S6 Lite, Galaxy Z Flip 4
• Android API 33
• ExoPlayer 버전: media3:1.3.1

🔧 ExoPlayer 설정

라이브러리 버전 설정, 아래 코드는 libs.versions.toml 파일 기준준

media3 = "1.3.1"

media-exoplayer = { group = "androidx.media3", name = "media3-exoplayer", version.ref = "media3" }
media-exoplayer-dash = { group = "androidx.media3", name = "media3-exoplayer-dash", version.ref = "media3" }
media-ui = { group = "androidx.media3", name = "media3-ui", version.ref = "media3" }

dependencies {
    implementation(libs.media.exoplayer)
    implementation(libs.media.exoplayer.dash)
    implementation(libs.media.ui)
}

🚨 문제 1: 인증서 오류 (HTTPS)

스트리밍 API는 HTTPS로 제공되는데, 인증서를 신뢰하지 못하면 오류가 발생

이를 우회하려면 인증서를 강제로 신뢰하도록 설정해야 함

✅ Application에 인증서 무시 로직 추가

class TestApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        disableSSLCertificateChecking()
    }

    private fun disableSSLCertificateChecking() {
        val trustAllCerts: Array<TrustManager> = arrayOf(
            object : X509TrustManager {
                override fun checkClientTrusted(chain: Array<out X509Certificate>?, authType: String?) {}
                override fun checkServerTrusted(chain: Array<out X509Certificate>?, authType: String?) {}
                override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
            }
        )

        try {
            val sc = SSLContext.getInstance("TLS")
            sc.init(null, trustAllCerts, SecureRandom())

            // 반드시 설정
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.socketFactory)

            // 선택 사항
            HttpsURLConnection.setDefaultHostnameVerifier { _, _ -> true }

        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

Manifest에 Application 추가

<application
    android:name=".TestApplication"
    ... />

🔐 문제 2: 인증 헤더 추가

홀로렌즈 API는 인증이 필요하며, 아이디와 비밀번호를 Base64로 인코딩한 값을 Authorization 헤더에 포함시켜야 함

예시

"Authorization": "Basic Zm9ybWFsd29ya3M6Zm9ybWFsd29ya3M="

• "아이디:비밀번호" 문자열을 Base64로 인코딩

🎞 DataSourceFactory 구현

@OptIn(UnstableApi::class)
private fun getSourceFactory(): DataSource.Factory {
    val defaultFactory = DefaultHttpDataSource.Factory()
        .setUserAgent(Util.getUserAgent(this, getString(R.string.app_name)))

    val headers = mapOf(
        "Authorization" to "Basic Zm9ybWFsd29ya3M6Zm9ybWFsd29ya3M="
    )

    return ResolvingDataSource.Factory(defaultFactory) { spec ->
        spec.withAdditionalHeaders(headers)
    }
}

▶️ ExoPlayer 연결

@OptIn(UnstableApi::class)
private fun getExoPlayer(): ExoPlayer {
    val mediaItem = MediaItem.Builder().setUri(streamUri).build()
    val mediaSource = ProgressiveMediaSource.Factory(getSourceFactory())
        .createMediaSource(mediaItem)

    return ExoPlayer.Builder(this)
        .setLoadControl(DefaultLoadControl())
        .setTrackSelector(DefaultTrackSelector(this))
        .build().apply {
            setMediaSource(mediaSource)
            playWhenReady = true
            repeatMode = Player.REPEAT_MODE_OFF
        }
}

🔗 스트리밍 URI 예시

private val streamUri =
    "https://~~~~~~~~~~/api/holographic/stream/live_low.mp4?holo=true&pv=false&mic=false&loopback=false&RenderFromCamera=true"

📚 참고 문서

• Device portal API reference - Mixed Reality | Microsoft Learn

✅ 결론

1. 인증서 신뢰 우회 (HTTPS)
2. 인증 헤더 처리 (Basic Auth)
3. ExoPlayer에서 DataSource.Factory 커스터마이징

Kotlin Multiplatform(KMP)의 데스크탑에서 화면 캡처 기능이 필요한 경우, Java AWT의 Robot 클래스를 활용하여 지정된 화면 영역을 이미지로 저장할 수 있다.

📄 전체 코드 예시

import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
import androidx.compose.ui.window.rememberWindowState
import java.awt.*
import java.io.File
import javax.imageio.ImageIO

// 지정된 영역을 캡처하여 PNG 이미지로 저장
fun saveScreenImage(rectangle: Rectangle) {
    try {
        val screenImage = Robot().createScreenCapture(rectangle)

        val fileFrame = Frame("이미지 저장")
        val fileDialog = FileDialog(fileFrame, "이미지 저장", FileDialog.SAVE)
        fileDialog.isVisible = true

        if (fileDialog.file == null) return

        val fileName = File(fileDialog.directory, "${fileDialog.file}.png")
        ImageIO.write(screenImage, "png", fileName)
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

fun main() = application {
    val windowState = rememberWindowState(size = DpSize(800.dp, 1000.dp))

    Window(
        onCloseRequest = ::exitApplication,
        title = "",
        state = windowState
    ) {
        App(
            onScreenSave = {
                val rectangle = Rectangle(
                    window.locationOnScreen.x,
                    window.locationOnScreen.y,
                    window.width,
                    window.height
                )
                saveScreenImage(rectangle)
            }
        )
    }
}

⚠️ 주의 사항

• 캡처할 영역을 내가 지정해 줘야하는 문제점이 있음

Android Studio의 Gradle Tool Window에서 Gradle tasks가 보이지 않는 문제 발생

🔧 해결 방법

Gradle tasks 조회는 무거운 작업이라 관련 설정이 비활성화되어 있으면 표시되지않음

실험적 기능(Experimental Settings) 에서 해당 옵션을 활성화 필요

1. 메뉴바에서 File → Settings (Mac: Android Studio → Preferences) 선택
2. 좌측 검색창에 Experimental 입력
3. Experimental → Gradle 항목에서
   Configure all Gradle tasks during Gradle Sync (this can make Gradle Sync slower) 옵션을 체크
4. 설정을 저장한 후 Gradle sync 시작

🔗 관련 링크: Gradle tasks are not showing in the gradle tool window in Android Studio 4.2 - Stack Overflow

Android Studio에서 앱을 실행할 때마다 Logcat 창을 수동으로 열어야 해서 번거롭습니다.

🔧 해결 방법

실행/디버그 설정에서 Logcat 창을 자동으로 표시하도록 설정할 수 있습니다.

1. 실행 버튼 옆 톱니바퀴 아이콘 클릭 → Edit Configurations 선택
2. 좌측에서 실행 구성을 선택한 뒤, 아래쪽 Miscellaneous 항목 클릭
3. Show logcat automatically 옵션 체크
4. Apply → OK

✅ 결과

이제 앱을 실행하면 Logcat 창이 자동으로 열려 로그를 바로 확인할 수 있습니다.

자바에서 전역 변수는 static로 선언된다.

반면 코틀린은 static 키워드가 없기 때문에 다른 방법을 사용한다. 코틀린에서 사용하는 방법들에 대해 조사하려 한다.

🍠Top-level property

클래스 없이 파일에 작성하는 변수

// Top-level
val a = "A"

자바 파일로 변환하면 아래와 같다. 파일 이름으로 클래스가 만들어지고 static 변수로 설정된다.

public final class StaticTestKt {
   @NotNull
   private static final String a = "A";

   @NotNull
   public static final String getA() {
      return a;
   }
}

🍠Companion object

클래스에 포함된 형태로 작성하는 변수

// Companion object
class B {
    companion object {
        val b = "B"
    }
}

자바 파일로 변환하면 아래와 같다. Companion 클래스를 추가로 생성했으며 static 변수로 클래스를 선언했다. 변수에 대한 접근을 Companion 클래스를 통해서만 하게 만들었다.

public final class B {
   @NotNull
   private static final String b = "B";
   @NotNull
   public static final Companion Companion = new Companion((DefaultConstructorMarker)null);

   public static final class Companion {
      @NotNull
      public final String getB() {
         return B.b;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

🍠Object

object 키워드를 사용해서 만든 싱글턴 클래스의 멤버로 작성하는 변수

// object
object C {
    val c = "C"
}

자바 파일로 변환하면 아래와 같다. 일반적인 싱글턴 패턴으로 만들었으며 변수에 대한 접근을 클래스를 통해서만 가능하게 했다.

public final class C {
   @NotNull
   private static final String c;
   @NotNull
   public static final C INSTANCE;

   @NotNull
   public final String getC() {
      return c;
   }

   private C() {
   }

   static {
      C var0 = new C();
      INSTANCE = var0;
      c = "C";
   }
}

🍠차이점

일단 변수를 사용할 때는 다음 차이점이 있다. a는 변수가 어디에 있는지 알 수 없지만, b, c는 어디에 있는지 알 수 있다.

a
B.b
C.c

자바 코드로 비교하면 다음과 같다. Top-level이 성능에 영향이 가장 적을 것으로 예상된다.

Top-level: 가장 간단한 형태 companion object: 코드도 길고 클래스도 2개를 사용하는 형태 object: Top-level 보다는 복잡하지만 companion object 보다는 간단한 형태

🍠정리

Top-level 클래스와 크게 연관이 없고 독립적으로 사용되는 값. 주로 사용하는 걸 추천

companion object 클래스와 깊게 연관된 경우 사용하지만, 단순히 변수를 선언하는 용도로는 추천하지 않음. 다만 메소드의 경우 companion object를 많이 활용하는 것으로 보임

object companion object 대신 사용하기 적합 연관된 클래스와 다른 이름을 사용해야 하는 문제가 있음

🍠참고 자료

Kotlin Discussions Stack overflow

컴포즈에서 스크롤 동작을 처리하는 방법에 대한 소개

컴포즈에서 스크롤은 다음 Modifier 속성을 사용해서 구현할 수 있다. horizontalScroll, verticalScroll, scrollable, nestedScroll

🧊horizontalScroll

가로 스크롤을 활성화하는 속성 자식 컴포넌트가 부모 컴포넌트보다 크면, 스크롤을 할 수 있게 해준다.

@Composable
private fun HorizontalScroll() {
    Row(
        modifier = Modifier
            .size(100.dp)
            .background(color = Color.LightGray)
            .horizontalScroll(state = rememberScrollState())
    ) {
        repeat(20) {
            Text(text = "Item $it ")
        }
    }
}

🧊verticalScroll

세로 스크롤을 활성화하는 속성 방향이 세로인 점만 빼면 horizontalScroll과 동일하다. 실제로 내부 코드를 보면 둘 다 scrollable을 사용하고 있다.

@Composable
private fun VerticalScroll() {
    Column(
        modifier = Modifier
            .size(100.dp)
            .background(color = Color.LightGray)
            .verticalScroll(state = rememberScrollState())
    ) {
        repeat(20) {
            Text(text = "Item $it")
        }
    }
}

🧊scrollable

horizontalScroll과 verticalScroll은 내부적으로 scrollable을 사용하고 있다.

하지만 scrollable은 스크롤 애니메이션을 만들지 않는다. 내부 코드를 보면 스크롤 애니메이션과 스크롤 계산을 따로 하는 것을 볼 수 있다. 그래서 scrollable을 사용해도 스크롤이 되지 않는 것을 볼 수 있다.

대신 scrollable은 사용자의 스크롤 동작에 대한 자세한 정보를 얻을 수 있다. horizontalScroll과 verticalScroll은 현재 스크롤 위치와 진행 상태만 확인할 수 있다. 반면 scrollable은 스크롤 동작에 대한 delta 값을 받을 수 있다.

스크롤 애니메이션은 필요없지만, 사용자의 스크롤 동작을 알아야할 때 사용할 수 있다.

@Composable
private fun ScrollableScroll() {
    var offset by remember { mutableFloatStateOf(0f) }
    val scrollState = rememberScrollableState { delta ->
        offset += delta
        delta
    }

    Column(
        modifier = Modifier
            .size(100.dp)
            .background(color = Color.LightGray)
            .scrollable(
                orientation = Orientation.Vertical,
                state = scrollState
            ),
        verticalArrangement = Arrangement.Center,
    ) {
        Text(text = "$offset")
    }
}

🧊nestedScroll

nestedScroll은 조금 특이한 속성으로 다른 스크롤의 정보를 처리할 수 있는 속성이다.

nestedScroll은 스크롤을 2가지 방법으로 처리할 수 있다. NestedScrollConnection을 사용해서 자식 컴포넌트의 스크롤을 가로채는 방법과 NestedScrollDispatcher를 사용해서 부모 컴포넌트에서 스크롤 이벤트를 전달하는 방법이 있다.

NestedSCrollConnection을 사용하면 자식 컴포넌트가 스크롤하는 걸 알 수 있다. 이걸 활용하면 스크롤에 따라 다른 UI가 변하게 만들 수 있다. 아래 코드는 스크롤에 따라 상단에 있는 UI가 변하는 코드로 이런 식으로 활용할 수 있다.

@Composable
private fun NestedScroll() {
    var offset by remember { mutableFloatStateOf(0f) }
    val scrollState = remember {
        object : NestedScrollConnection {
            override fun onPreScroll(
                available: Offset,
                source: NestedScrollSource
            ): Offset {
                val newOffset = (offset + available.y).coerceIn(-20f, 0f)
                offset = newOffset

                return super.onPreScroll(available, source)
            }
        }
    }

    Column(
        modifier = Modifier
            .size(100.dp)
            .nestedScroll(connection = scrollState)
    ) {
        Box(
            modifier = Modifier
                .fillMaxWidth()
                .height(20.dp)
                .offset(y = offset.dp)
                .background(color = Color.Green),
            content = {},
        )
        VerticalScroll()
    }
}

☕NestedScrollConnection

NestedScrollConnection은 인터페이스지만, 메소드가 구현되어 있어서 필요한 메소드만 구현하면 된다.

onPreScroll 자식 컴포넌트가 스크롤 이벤트를 처리하기 전에 발생 return으로 처리에 사용한 스크롤 값을 보낼 수 있다.

만약 파라미터로 받은 스크롤 가능한 값을 전부 return하면 스크롤을 전부 처리했다고 보기 때문에 자식 컴포넌트가 스크롤되지 않는다.

onPostScroll 자식 컴포넌트가 스크롤 이벤트를 처리하고 발생 자식 컴포넌트가 사용한 스크롤 값과 남은 스크롤 값을 받을 수 있다.

onPreFling 자식 컴포넌트에서 fling 이벤트를 처리하기 전에 발생 fling 이벤트는 스크롤과 달리 짧은 순간에 발생하기 때문에 1번만 호출된다. 해당 메소드는 suspend로 처리된다.

onPostFling 자식 컴포넌트에서 fling 이벤트를 처리하고 발생

☕NestedScrollDispatcher

NestScrollDispatcher은 구현이 복잡해서 예제가 있는 공식 문서를 참고하는 걸 추천

사용자 동작 중에서 누르는 동작에 대한 내용을 소개 High-level 단계에서 처리하는 방법이 중심으로 작성됨

Tap(Click): 누르고 떼기 Double tap: Tap 이후 일정 시간 안에 Tap Press: 누르고 있기 Long press: 일정 시간 Press

☕clickable

가장 기본적인 클릭 처리 방법

// 컴포넌트 크기 만큼 터치 가능
Modifier
    .size(100.dp)
    .background(Color.Cyan)
    .clickable {}

// 컴포넌트 크기에서 10.dp 만큼 줄어든 영역만 터치 가능
Modifier
    ...
    .padding(10.dp)
    .clickable{}

padding 속성 이후에 선언하면 패딩이 적용된 영역만 터치가 적용된다.

☕combinedClickable

combinedClickable은 clickable에서 더블 클릭과 길게 누르기가 추가됐다.

Modifier
    .combinedClickable(
        onLongClick = {},
        onDoubleClick = {},
        onClick = {}
    )

기본적으로 더블 클릭과 길게 누르기의 시간은 각각 0.3, 0.4초로 설정되어 있다. 만약 시간을 바꾸려면 ViewConfiguration 인터페이스를 구현해야 한다. 구현한 클래스를 LocalViewConfiguration에 설정하면 시간을 변경할 수 있다.

// 커스텀 ViewConfriguration
// touchSlop는 8f가 기본으로 되어 있다.
private class CustomViewConfiguration : ViewConfiguration {
    override val doubleTapMinTimeMillis: Long
        get() = 1000
    override val doubleTapTimeoutMillis: Long
        get() = 2000
    override val longPressTimeoutMillis: Long
        get() = 3000
    override val touchSlop: Float
        get() = 8f
}

// 커스텀 클래스를 설정해준다.
CompositionLocalProvider(
    LocalViewConfiguration provides CustomViewConfiguration()
) {
    // 테스트 확인용 텍스트
    var text by remember { mutableStateOf("") }

    Text(
        modifier = Modifier
            .combinedClickable(
                onLongClick = { text = "Long Clicked" },
                onDoubleClick = { text = "Double Clicked" },
                onClick = { text = "Clicked" }
            ),
        text = text,
    )
}

☕selectable

선택하는 컴포넌트를 구현할 때 사용하는 Modifier 속성 clickable로 비슷한 동작을 만들 수 있고, 실제 내부 코드를 보면 clickable을 사용하고 있다. selectable을 사용하는 이유는 UI 접근성과 테스트 때문으로 자세한 내용은 공식 문서 참조

clickable와 달리 선택된 상태를 전달해야 한다.

Modifier
    .selectable(
       selected = true or false,
       onClick = { },
    )

☕toggleable

toggleable은 다른 속성과 달리 콜백 함수로 토글 상태를 전달받는다. toggleable도 clickable로 구현이 되지만, not 연산이 자동이라 좀 더 편하다. toggleable은 내부적으로 밑에서 나올 triStateToggleable을 사용한다.

// onValueChange은 항상 value에 not 연산 결과가 나온다.
// 이 경우에는 false가 나온다.
Modifier
    .toggleable(
       value = true,
       onValueChange = { state -> },
    )

☕triStateToggleable

내부적으로 clickable을 사용한다. toggleable와 다른 점은 toggleable은 콜백으로 Boolean 타입을 주지만 triStateToggleable은 ToggleableState라는 enum 클래스를 반환한다.

ToggleableState는 On, Off, Indeterminate로 이루어져 있다. 토글 기능을 만들 때 On, Off 외에 다른 상태를 사용하고 싶을 때 사용할 수 있다.

Modifier
    .triStateToggleable(
        state = ToggleableState.Indeterminate,
        onClick = {  },
    )

☕Ripple effect

Ripple은 버튼을 눌렀을 때 살짝 어두워지는 효과를 말한다. 위에 나온 속성을 적용하면 기본 효과가 적용되는데, 디자인에 따라 변경해야할 수도 있다. 크게 2가지 방법으로 직접 만들거나 Indication을 적용하는 방법이 있다.

직접 만드는 방법은 말 그대로 클릭 상태에 따라 background 색상을 바꾸는 방법이다. 디자인에 따라 쉬울 수도 있지만, 컴포넌트마다 따로 만들어야 하는 문제가 있다.

반면 Indication을 사용하는 방법은 여러 컴포넌트에 사용할 수 있고 전체에 적용할 수도 있다.

InteractionSource: 사용자 상호작용 정보를 가지는 인터페이스, 속성마다 존재 Indication: InteractionSource에서 전달받은 정보로 시각적인 효과를 만듬

먼저 Indication을 만든다. 색상은 빨간색으로 만들었다.

private class CustomIndication: Indication {
    private class CustomIndicationInstance(
        private val isPressed: State<Boolean>,
        private val isHovered: State<Boolean>,
        private val isFocused: State<Boolean>,
    ) : IndicationInstance {
        override fun ContentDrawScope.drawIndication() {
            drawContent()
            if (isPressed.value) {
                drawRect(color = Color.Red.copy(alpha = 0.8f), size = size)
            } else if (isHovered.value || isFocused.value) {
                drawRect(color = Color.Red.copy(alpha = 0.8f), size = size)
            }
        }
    }

    @Composable
    override fun rememberUpdatedInstance(
        interactionSource: InteractionSource
    ): IndicationInstance {

        val isPressed = interactionSource.collectIsPressedAsState()
        val isHovered = interactionSource.collectIsHoveredAsState()
        val isFocused = interactionSource.collectIsFocusedAsState()

        return remember(interactionSource) {
            CustomIndicationInstance(isPressed, isHovered, isFocused)
        }
    }
}

컴포넌트 하나에 적용하려면 컴포넌트 파라미터 중에 indication에 추가하면 된다.

Modifier
    .clickable(
        interactionSource = remember { MutableInteractionSource() },
        indication = CustomIndication(),
        onClick = {}
    )

컴포넌트 전체에 적용하려면 CompositionLocalProvider를 사용한다.

CompositionLocalProvider(
    LocalIndication provides CustomIndication()
) {
    ...
    Modifier
        .clickable {}
    ...
}

더 자세한 내용은 공식 문서 참조

컴포즈에서 클릭, 드래그 같은 사용자 터치 동작을 처리하는 방법에 대한 소개 공식 문서를 기준으로 작성됨

🍩개념 정의

Pointer

• 사용자가 앱과 상호작용할 때 사용하는 물리적인 대상
• 손가락, 터치 펜, 마우스 등
• 상호작용하고 있는 Pointer의 타입은 PointerType value class에서 확인할 수 있음
• 화면 좌표를 지정할 수 있어야해서 키보드는 Pointer가 아님

Pointer event

• Low-level 단계에서 터치를 처리할 때 사용하는 개념
• PointerEvent 데이터 클래스에서 확인할 수 있음

Gesture

• Pointer event가 모여서 만들어진 동작
• 탭, 드래그, 스와이프 등

🍩처리 단계

컴포즈에서는 3가지 레벨로 터치를 처리할 수 있음 높은 레벨이 개발자에서 편한 방법

Top-level

• Button 같은 컴포넌트가 제공하는 리스너

High-level

• Modifier가 제공하는 clickable, draggable 등

Low-level

• Modifier가 제공하는 pointerInput

🍩Top-level

컴포넌트가 제공하는 API 개발자가 따로 처리하지 않아도 동작에 대한 피드백을 받을 수 있음

@Composable
fun Button(
    onClick: () -> Unit,
    ...
)

단점

• 세세한 동작을 처리하기 어려움
• 컴포넌트가 제공하지 않으면 사용 불가

🍩High-level

컴포넌트의 Modifier를 사용한 터치 동작 추가 방법 Modifier가 제공하는 clickable, scrollable, draggable 등이 있음

다음 확장 함수를 제공하는데 내용이 길어 자세한 내용은 다른 글에서 정리할 예정

누르기

• clickable, combinedClickable
• selectable
• toggable, triStateToggleable

스크롤

• horizontalScroll, verticalScroll, scrollable

드래그

• draggable
• swipeable

다중 터치

• transformable

🍩Low-level

터치를 세밀하게 처리해야 하거나 원하는 동작을 만들어야 할 때 사용 Modifier의 pointerInput 안에서 awaitPointerEventScope를 사용

이 부분도 내용이 길어져 다른 글에서 자세히 다룰 예정

Modifier
.pointerInput(Unit) {
    awaitPointerEventScope {
        val touchDown = awaitPointerEvent()

        do {
            val touchMove = awaitointerEvent()
        } while (touchMove.changes.any { it.pressed })

        val touchUp = awaitPointerEvent()
    }
}

단점

• 사용자의 모든 동작을 처리할 수 있지만 그만큼 코드와 로직이 복잡해짐
• 동작을 직접 구현해야 하기 때문에 난이도가 높은 편

그래서 컴포즈는 여러 동작을 몇 가지 메소드를 제공하고 있음

누르기

• detectTapGestures

드래그

• detectHorizontalDragGestures, dectVerticalDragGestures
• detectDragGestures, detectDragGesturesAfterLongPress

다중 터치

• detectTransformGestures

사실 적당한 제목이 생각나지 않아 이상한 제목을 붙였다.

숫자를 계단 함수처럼 일정하게 만들려고 한다. 예를 들어 23은 20으로 31은 40으로 출력하려 한다.

🍤코드

코드는 간단한 편이다. 입력을 단계만큼 나누고, 나머지로 값을 올릴지 내릴지 검사한다.

val step = 20
val input = 28
val remainder = input % step

val step = if (remainder > step / 2) {
    input + (step - remainder)
} else {
    input - remainderX
}

round()를 사용해서 구할 수도 있다.

// 소수점 2번째에서 반올림
round(x*10)/10

다만 소수점으로 계산하기 때문에 곱하고 나누는 과정이 들어간다. 원래 값이 클 수록 숫자가 타입이 허용하는 범위를 넘어갈 수 있다.

그리고 10의 제곱 단위로만 숫자를 변환할 수 있다. 위 코드처럼 간격이 20인 숫자로는 만들 수 없다.

🍤활용

코드 자체는 간단하지만 쓸 곳이 마땅히 없었는데, 오늘 쓸 일이 있어서 사용하게 됐다.

아래 코드는 Compose에서 composable 위에서 드래그 했을 때 감지하는 코드이다.

Modifier.pointerInput(Unit) {
    detectDragGestures(
        onDragStart = {},
        onDragEnd = {},
        onDragCancel = {},
        onDrag = { change, offset -> }
    )
}

위에 코드로 드래그한 좌표를 구할 수 있다.

좌표를 변환하면 픽셀, 도트 같은 좌표를 구할 수 있다. 변환한 좌표를 Canvas에 도트처럼 그릴 수 있다.

// 도트 값으로 변환하는 함수
private fun Float.toStep(): Float {
    val step = 20
    val intValue = this.toInt()
    val remainder = intValue % step

    return if (remainder > step / 2) {
        (intValue + (step - remainder)).toFloat()
    } else {
        (intValue - remainder).toFloat()
    }
}

@Composable
fun DotCanvas() {
    // 드래그 좌표들
    var points by remember { mutableStateOf(emptyList<Offset>()) }

    Canvas(
        modifier = Modifier
            .fillMaxSize()
            .pointerInput(Unit) {
                detectDragGestures(
                    onDragStart = {},
                    onDragEnd = {},
                    onDragCancel = {},
                    onDrag = { change, offset ->
                        // 드래그한 좌표를 도트 좌표로 변환하고 저장
                        val dotX = change.position.x.toStep()
                        val dotY = change.position.y.toStep()
                        points = points + Offset(dotX, dotY)
                    }
                )
            }
    ) {
        points.forEach { point ->
            // 도트 좌표 그리기
            // 원래는 사각형으로 해야하는데, 원이 코드가 적어서 원으로 했다.
            drawCircle(color = Color.Black, radius = 10f, center = point)
        }
    }
}

코틀린에서 클래스를 초기화 할 때 실행되는 순서를 정리하려 한다.

🍿init

init은 클래스를 생성하면 먼저 실행되는 것들 중 하나다. 변수 설정도 같은 종류인데 가장 위에 있는 코드부터 실행된다.

fun main() {
    // First value : test
    // First init test
    // Second value : test
    // Second init test
    Person("test")
}

class Person(name: String) {
    val firstValue = "First value : $name".also(::println)

    init {
        println("First init $name")
    }
    val secondValue = "Second value : $name".also(::println)

    init {
        println("Second init $name")
    }
}

🍿부 생성자

부 생성자로 클래스를 생성하면 변수 초기화와 init이 먼저 호출되고 그 다음에 호출된다.

fun main() {
    // Value : test
    // Init test
    // Constructor 10
    Person(10)
}

class Person(name: String) {
    val firstValue = "Value : $name".also(::println)

    constructor(age: Int): this("test") {
        println("Constructor $age")
    }

    init {
        println("Init $name")
    }
}

🍿상속

부모 클래스가 존재하면 부모 클래스의 코드가 먼저 실행된다.

fun main() {
    // Init parent test
    // Size parent 4
    // Init child test
    // Size child 4
    Person("test")
}

open class Creature(val name: String) {
    init {
        println("Init parent $name")
    }

    open val size: Int = name.length.also { println("Size parent $it") }
}

class Person(
    name: String
) : Creature(name) {

    init { println("Init child $name") }

    override val size: Int = super.name.length.also { println("Size child $it") }
}

코틀린에서는 코드 흐름과 관련된 표현식이 있다. return: 값을 반환하고 함수를 종료 break: 가장 가까운 반복문을 종료 continue: 가장 가까운 반복문의 다음 단계 진행

🌮label

그리고 코틀린에는 c의 goto 같은 것이 있다.

loop@ for (i in 0..2) {
    if(...) break@loop
}

다행히 c의 goto와 달리 반복문에만 사용할 수 있다.

🌮jump

일반적으로 goto는 코드 실행 흐름이 꼬이기 때문에 사용하면 안된다. 유일하게 사용을 고려해 볼 부분은 중첩 반복문을 탈출할 때다.

중첩된 반복문을 탈출하려면 조건문을 2개를 만드는 게 일반적이다. 하지만 goto나 label을 사용하면 코드가 간결해진다.

loop1@ for(i in 0..10) {
     loop2@ for(j in 0..10) {
         if (j == 5) break@loop1
         println("i: $i, j: $j")
     }
 }

🌮return

label은 return에도 사용할 수 있다.

(0..10).forEach {
    if (it == 5) return@forEach
    println(it)
}

반복문처럼 보이는데 break가 아니라 return을 사용하는 이유는 forEach라 그렇다. forEach가 익명 함수를 전달받아 반복문을 실행하기 때문에 return으로 함수를 종료해야 한다. forEach는 자동으로 label이 있기 때문에 main 함수가 같이 종료되지 않는다.

값을 반환하는 경우 다음 코드를 사용한다.

return@a 1

Retrofit이나 okHttp처럼 서버 응답을 테스트할 때 가짜 응답이 필요할 때가 있다. json 문자열으로 가짜 응답을 만드는데, 너무 길어지면 테스트 코드에서 관리가 힘들어진다.

그래서 별도의 json 파일을 분리하는게 깔끔한데, 문제는 androidTest가 아니라 일반 test에서는 assets, resources처럼 json 파일이 있는 곳에 접근하기가 쉽지 않다.

🧀해결

nowInAndroid에서 사용하는 방법인데 test에서도 resources에 접근할 수 있다.

private fun readJsonFile(fileName: String): String {
    val inputStream = javaClass.classLoader?.getResourceAsStream(fileName)
    return inputStream?.bufferedReader()?.use { it.readText() } ?: ""
}

주의해야할 점은 res가 아니라 test에 resources를 만들어야 한다. 패키지 구조를 안드로이드로 하면 안보이고 project로 설정해야 생성하기 쉽다.

Kotlin에서는 생성자에 기본 값을 설정할 수 있다.

class Person(
    val name: String = "test"
) { ... }

🍕Hilt inject

Hilt를 사용해서 의존성 주입을 하면 보통 다음 코드처럼 한다.

class AnalyticsAdapter @Inject constructor(
  private val service: AnalyticsService
) { ... }

그런데 생성자에 다음과 같이 default value를 설정하려고 하면 오류가 발생한다.

class AnalyticsAdapter @Inject constructor(
  private val name: String = "test",
  private val service: AnalyticsService
) { ... }

Hilt에서 String 타입으로 주입할 객체를 찾지 못해서 그런 거 같다.

🍦해결

내 경우 테스트 코드 때문에 저렇게 처리를 해야 했는데, 아래 방법으로 해결이 가능하다.

class MyNetwork(
    url: String,
    networkJson: Json,
    okHttpClientFactory: Call.Factory
) : MyNetworkDataSource {

    @Inject
    constructor(
        networkJson: Json,
        okHttpClientFactory: Call.Factory
    ) : this(
        url = BASE_URL,
        networkJson = networkJson,
        okHttpClientFactory = okHttpClientFactory
    )
}

주 생성자에는 필요한 변수를 전부 선언하고 @Inject 생성자에서는 주입받을 객체만 선언하면 된다.

주어진 영역에 딱 맞게 텍스트 크기를 조절하고 싶을 때 사용하는 기능 원본 영상을 참고했습니다.

🥐전체 코드

@Composable
fun ResizeText(
    modifier: Modifier = Modifier,
    style: TextStyle = MaterialTheme.typography.labelSmall,
    text: String
) {
    var resizedTextStyle by remember {
        mutableStateOf(style)
    }
    var shouldDraw by remember {
        mutableStateOf(false)
    }
    val defaultFontSize = MaterialTheme.typography.labelSmall.fontSize

    Text(
        modifier = modifier
            .drawWithContent {
                if (shouldDraw) {
                    drawContent()
                }
            },
        text = text,
        style = resizedTextStyle,
        softWrap = false,
        onTextLayout = { result ->
            if (result.didOverflowWidth) {
                if (style.fontSize.isUnspecified) {
                    resizedTextStyle = resizedTextStyle.copy(
                        fontSize = defaultFontSize
                    )
                }

                resizedTextStyle = resizedTextStyle.copy(
                    fontSize = resizedTextStyle.fontSize * 0.95
                )
            } else {
                shouldDraw = true
            }
        }
    )
}

🥐코드 설명

텍스트에 적용할 스타일을 저장. 기본은 입력으로 받은 스타일

var resizedTextStyle by remember {
    mutableStateOf(style)
}

크기가 완전히 정해졌는지 검사하는 변수 사실 없어도 되는데 이게 없으면 숫자가 줄어드는 걸 사용자가 보게된다. 숫자가 줄어드는 게 이상하면 크기가 고정됐을 때만 보여주게 이걸 추가해야 한다.

var shouldDraw by remember {
    mutableStateOf(false)
}
...
modifier.drawWithContent {
      if (shouldDraw) {
        drawContent()
    }
}

텍스트가 이상한 값이 된 경우, 기본으로 사용할 크기 그냥 Sp 타입을 사용해도 된다.

val defaultFontSize = MaterialTheme.typography.labelSmall.fontSize
...
if (style.fontSize.isUnspecified) {
    resizedTextStyle = resizedTextStyle.copy(
        fontSize = defaultFontSize
    )
}

Text는 기본적으로 텍스트가 주어진 영역보다 크면 자동으로 줄바꿈을 해버린다. 해당 옵션이 켜져있으면 기능이 적용되지 않아서 꺼야 한다.

softWrap = false

여기서는 텍스트가 너비를 벗어났는지만 검사했는데 높이도 검사할 수 있다.

if (result.didOverflowWidth)

텍스트 크기를 영역에 맞을 때 까지 줄이는 코드 여기서는 0.95%로 줄였지만 다른 수치를 사용해도 된다.

resizedTextStyle = resizedTextStyle.copy(
    fontSize = resizedTextStyle.fontSize * 0.95
)

코틀린에서 사용하는 숫자에 대한 내용 정리

🍈정수형

코틀린은 자바와 달리 타입을 명시적으로 선언하지 않으면 자동으로 정해준다.

val num1 = 1 // Int
val num2 = 3000000000 // Long

println(num1::class.simpleName)
println(num2::class.simpleName)

Long 타입은 뒤에 L을 추가하면 Long 타입이 된다.

val num1 = 1L // Long

참고로 선언한 타입의 범위를 벗어나는 수를 선언하면 에러가 발생한다.

val num1: Int = 3000000000 // error!

🍈실수형

코틀린에서는 실수형은 Double이 기본이고 Float는 뒤에 f, F를 붙여야 한다.

val num1 = 1.0 // Double
val num2 = 1.0f // Float

코틀린은 Double와 Float이 서로 변환이 되지 않는다. 이유는 아래에 설명이 나온다.

val num1 = 1.0 // Double
val num2:Float = num1 // error!

🍈표현

코틀린에서는 0x와 0b를 사용해 16진법과 2진법을 표현할 수 있다. 이때 타입을 따로 정하지 않으면 Int와 Long 중 숫자 크기에 맞는 타입이 선언된다. 8진법은 지원되지 않는다.

val num2 = 0xFF
val num3 = 0b11

숫자가 너무 긴 경우에는 _을 사용해 가독성을 높일 수 있다.

val num1 = 3_000_000_000
val num2 = 0xFF_EC_DE_5E
val num3 = 0b11010010_01101001_10010100_10010010

🍈원시 타입 & 래퍼 타입

코틀린에서는 === 연산자를 선언해 같은 주소를 검사할 수 있는데 숫자를 비교하면 재밌는 결과가 나온다.

val num1: Int = 100
val num2: Int = 10000

val numA1: Int = num1
val numA2: Int = num1
val numB1: Int = num2
val numB2: Int = num2

println(numA1 === numA2) // true
println(numB1 === numB2) // true

여기서 Int를 Int? 타입으로 바꾸면 이상한 결과가 나온다.

val num1: Int = 100
val num2: Int = 10000

val numA1: Int? = num1
val numA2: Int? = num1
val numB1: Int? = num2
val numB2: Int? = num2

println(numA1 === numA2) // true
println(numB1 === numB2) // false

코틀린은 JVM에 의해 컴파일되는데, JVM이 -128~127인 숫자를 참조하는 Int? 객체는 같은 객체로 처리하지만, 범위를 벗어나는 숫자를 참조하는 Int?는 다른 객체로 처리하지 때문이다.

보통 숫자는 원시 타입이라 객체가 없다고 생각할 수 있다. 코틀린에서는 원시 타입과 래퍼 타입을 따로 구분하고 있지 않다. 대신 JVM이 자바 코드로 변환할 때 숫자의 사용 방법에 따라 구분하고 있다.

다음 예시 코드를 보면 코틀린으로 작성하면 타입에 큰 신경을 안써도 된다.

val num1:Int = 10
val num2: List<Int> = listOf(10)

val numA = num1
val numB = num2.first()
val numC: Int? = num2.firstOrNull()

이걸 Androdi Studio의 Kotlin Bytecode 기능을 사용해 자바 코드로 변환하면 다음 코드가 나온다.

int num1 = true;
List num2 = CollectionsKt.listOf(10);
int numB = ((Number)CollectionsKt.first(num2)).intValue();
Integer numC = (Integer)CollectionsKt.firstOrNull(num2);

하나씩 보면 숫자를 선언만 하면 int로 처리된다.

int num1 = true;
int numB = ((Number)CollectionsKt.first(num2)).intValue();

반면 제네릭이나 nullable로 사용하면 래퍼 타입으로 변환된다.

// Number는 래터 타입으로 Integer의 추상 클래스
int numB = ((Number)CollectionsKt.first(num2)).intValue();

// Int?는 Integer로 선언된다.
Integer numC = (Integer)CollectionsKt.firstOrNull(num2);

JVM이 이런 동작을 하는 이유는 메모리 최적화 때문이라고 한다.

코틀린에서 사용하는 Int나 Double 같은 숫자 타입은 코드를 보면 클래스로 되어 있다. 숫자는 Number 추상 클래스를 상속하는데 정작 Int나 Long은 같은 정수형이여도 서로 호환되지 않는다. 다른 타입에 저장하려면 toLong() 같은 메소드를 사용해야 한다.

var num1: Int = 100
var num2: Long = 100

num2 = num1 // error
num2 = num1.toLong()

🍈실수형 비교

실수형은 부동소수점을 사용하기 때문에 컴퓨터에서 정확한 값을 알 수 없다. 그래서 IEEE754를 기준으로 표현하는데, 이래도 오차가 발생한다.

저 오차 때문에 재밌는 결과가 나온다.

숫자로 연산할 때 불가능한 연산이면 NaN이 출력된다. 이 NaN은 Double 클래스에 전역 변수로 선언되어 있고 -(0.0 / 0.0 )인 Double 타입이다. 결국 부동소수점을 가진 실수형이기 때문에 같은 NaN의 값을 비교하면 false가 나온다.

println(Double.NaN == Double.NaN) // false

0.0에도 재밌는 현상이 있는데 -0.0과 0.0을 비교하면 다음 결과가 나온다.

// 동일한 값
println(0.0 == -0.0) // true

// 동일한 값이지만, list에 넣으면 다르게 인식
println(listOf(0.0) == listOf(-0.0)) // false
println(listOf(1.0) == listOf(1.0)) // true

마지막으로 정렬을 하면 다음 결과가 나온다. NaN은 -(0.0 / 0.0 )이고 POSITIVE_INFINITY는 1.0/0.0으로 선언되어 있다.

// [-0.0, 0.0, Infinity, NaN]
println(listOf(Double.NaN, Double.POSITIVE_INFINITY, 0.0, -0.0).sorted())