...
dependencyResolutionManagement {
    ...
    repositories {
        ...
        maven { url = uri("https://devrepo.kakao.com/nexus/repository/kakaomap-releases/") }
    }
}

...

...

dependencies {
    ...
    // kakao map
    implementation(libs.kakao.maps)
}

...

import com.kakao.sdk.common.util.Utility

var keyHash = Utility.getKeyHash(this)

try {
    val info = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES)
    for (signature in info.signatures) {
        val md = MessageDigest.getInstance("SHA")
        md.update(signature.toByteArray())
        val key = Base64.encodeToString(md.digest(), Base64.DEFAULT)
        Log.d("KeyHash", "key hash: $key")
    }
} catch (e: Exception) {
    Log.e("KeyHash", "키 해시 가져오기 실패", e)
}

import java.util.Properties

...

val localProperties = Properties().apply {
    val localPropertiesFile = rootProject.file("local.properties")
    if (localPropertiesFile.exists()) {
        load(localPropertiesFile.inputStream())
    }
}

android {
    ...

    defaultConfig {
        ...
        buildConfigField("String", "KAKAO_NATIVE_APP_KEY", "${localProperties["kakao_native_app_key"]}")
        manifestPlaceholders["KAKAO_NATIVE_APP_KEY"] = localProperties["kakao_native_app_key"] ?: ""
    }
    ...
}

@HiltAndroidApp
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        try {
            KakaoMapSdk.init(this, BuildConfig.KAKAO_NATIVE_APP_KEY)
        } catch (e: Exception) {
            Log.e("KakaoMapSdk", "카카오맵 SDK init 실패", e)
        }
    }
}

var mapView by remember { mutableStateOf<MapView?>(null) }

AndroidView(
    modifier = modifier
        .fillMaxSize(),
    factory = { context ->
        MapView(context).also { mapView = it }.apply {
            layoutParams = ViewGroup.LayoutParams(
                ...
            )
            start(
                ...
            )
        }
    }
)

val mapView = MapView(context)
mapView.layoutParams = ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)
mapView.start(callback1, callback2)
return mapView

MapView(context).apply {
    layoutParams = ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)
    start(callback1, callback2)
}

MapView(context).also { mapView = it }

layoutParams = ViewGroup.LayoutParams(
    ViewGroup.LayoutParams.MATCH_PARENT,
    ViewGroup.LayoutParams.MATCH_PARENT,
)

mapView.start(
    object : MapLifeCycleCallback() {
        ...
    },

    object : KakaoMapReadyCallback() {
        ...
    }
)

object : MapLifeCycleCallback() { 
    ...
}

start(
    object : MapLifeCycleCallback() {
        override fun onMapDestroy() {
            // 지도 api가 정상적으로 종료될 때 호출
        }

        override fun onMapError(error: Exception) {
            // 인증 실패 및 지도 사용 중 에러가 발생할 때 호출됨
         
        }
    },
    ...
    }
)

start(
    ...
    object : KakaoMapReadyCallback() {
        override fun onMapReady(kakaoMap: KakaoMap) {
            // 인증 후 API가 정상적으로 실행될 때 호출됨
        }
        override fun getPosition(): LatLng {
            // 지도 시작 시 위치 좌표를 설정
            return LatLng.from(37.406960, 127.115587)
        }
        override fun getZoomLevel(): Int {
             // 지도 시작 시 확대/축소 줌 레벨 설정
            return 15
        }
    }
)

DisposableEffect(key1, key2, ...) {  // 키가 변경될 때마다 재실행
    // 설정 코드 (effect setup)
    
    onDispose {
        // 정리 코드 (cleanup)
    }
}

// 1. LifecycleOwner에서 lifecycle 가져오기
val lifecycleOwner = LocalLifecycleOwner.current  // Compose에서 현재 LifecycleOwner 가져오기
val lifecycle = lifecycleOwner.lifecycle          // Lifecycle 객체 접근

// 2. Observer 생성
val observer = object : DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {}      // 생성될 때
    override fun onStart(owner: LifecycleOwner) {}       // 시작될 때
    override fun onResume(owner: LifecycleOwner) {}      // 화면에 보일 때
    override fun onPause(owner: LifecycleOwner) {}       // 화면에서 사라질 때
    override fun onStop(owner: LifecycleOwner) {}        // 정지될 때
    override fun onDestroy(owner: LifecycleOwner) {}     // 파괴될 때
}

// 3. Observer 등록
lifecycle.addObserver(observer)

// 4. Observer 제거
lifecycle.removeObserver(observer)

    val lifecycleOwner = LocalLifecycleOwner.current

    DisposableEffect(lifecycleOwner) {
        val observer = object : DefaultLifecycleObserver {
            override fun onResume(owner: LifecycleOwner) {
                mapView?.resume()
            }

            override fun onPause(owner: LifecycleOwner) {
                mapView?.pause()
            }
        }

        lifecycleOwner.lifecycle.addObserver(observer)

        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

package com.hm.picplz.ui.screen.search_photographer

import android.util.Log
import android.view.ViewGroup
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.viewinterop.AndroidView
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner
import com.kakao.vectormap.*


@Composable
fun KakaoMapView(
    modifier: Modifier = Modifier,
    onMapReady: (KakaoMap) -> Unit = {}
) {
    var mapView by remember { mutableStateOf<MapView?>(null) }

    AndroidView(
        modifier = modifier
            .fillMaxSize(),
        factory = { context ->
            MapView(context).also { mapView = it }.apply {
                layoutParams = ViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.MATCH_PARENT,
                    ViewGroup.LayoutParams.MATCH_PARENT,
                )
                start(
                    object : MapLifeCycleCallback() {
                        override fun onMapDestroy() {
                            // 지도 api가 정상적으로 종료될 때 호출
                        }

                        override fun onMapError(error: Exception) {
                            // 인증 실패 및 지도 사용 중 에러가 발생할 때 호출됨
                            Log.e("KakaoMapView", "Map Error: ${error.message}")
                            error.printStackTrace()
                            if (error is MapAuthException) {
                                when (error.errorCode) {
                                    -1 -> Log.e("KakaoMapView", "인증 과정 중 원인을 알 수 없는 에러가 발생한 상태")
                                    -2 -> Log.e("KakaoMapView", "통신 연결 시도 중 발생하는 에러")
                                    -3 -> Log.e(
                                        "KakaoMapView",
                                        "통신 연결 중 SocketTimeoutException 에러가 발생한 경우"
                                    )

                                    -4 -> Log.e(
                                        "KakaoMapView",
                                        "통신 시도 중 ConnectTimeoutException 에러가 발생한 경우"
                                    )

                                    400 -> Log.e(
                                        "KakaoMapView",
                                        "일반적인 오류. 주로 API에 필요한 필수 파라미터와 관련하여 서버가 클라이언트 오류를 감지해 요청을 처리하지 못한 상태입니다."
                                    )

                                    401 -> Log.e(
                                        "KakaoMapView",
                                        "인증 오류. 해당 리소스에 유효한 인증 자격 증명이 없어 요청에 실패한 상태"
                                    )

                                    403 -> Log.e(
                                        "KakaoMapView",
                                        "권한 오류. 서버에 요청이 전달되었지만, 권한 때문에 거절된 상태"
                                    )

                                    429 -> Log.e(
                                        "KakaoMapView",
                                        "쿼터 초과. 정해진 사용량이나 초당 요청 한도를 초과한 경우"
                                    )

                                    499 -> Log.e(
                                        "KakaoMapView",
                                        "통신 실패 오류. 인터넷 연결 상태 확인이 필요한 경우"
                                    )
                                }
                            }
                        }
                    },
                    object : KakaoMapReadyCallback() {
                        override fun onMapReady(kakaoMap: KakaoMap) {
                            // 인증 후 API가 정상적으로 실행될 때 호출됨
                            onMapReady(kakaoMap)
                            Log.e("KakaoMapView", "카카오 맵 준비 완료")

                        }

                        override fun getPosition(): LatLng {
                            // 지도 시작 시 위치 좌표를 설정
                            return LatLng.from(37.406960, 127.115587)
                        }

                        override fun getZoomLevel(): Int {
                            // 지도 시작 시 확대/축소 줌 레벨 설정
                            return 15
                        }
                    }
                )
            }
        }
    )

    val lifecycleOwner = LocalLifecycleOwner.current

    DisposableEffect(lifecycleOwner) {
        val observer = object : DefaultLifecycleObserver {
            override fun onResume(owner: LifecycleOwner) {
                mapView?.resume()
            }

            override fun onPause(owner: LifecycleOwner) {
                mapView?.pause()
            }
        }

        lifecycleOwner.lifecycle.addObserver(observer)

        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }
}