@package-kr/react-native-kakao-signin 0.0.1

package/android/src/main/java/com/packagekr/kakao/RNKakaoLoginModule.kt

@@ -0,0 +1,347 @@
+package com.packagekr.kakao
+
+import android.content.pm.PackageManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.kakao.sdk.auth.TokenManagerProvider
+import com.kakao.sdk.common.KakaoSdk
+import com.kakao.sdk.common.model.ClientError
+import com.kakao.sdk.common.model.ClientErrorCause
+import com.kakao.sdk.common.util.Utility
+import com.kakao.sdk.user.UserApiClient
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+@ReactModule(name = RNKakaoSigninModule.NAME)
+class RNKakaoSigninModule(
+    reactContext: ReactApplicationContext
+) : NativeKakaoLoginSpec(reactContext) {
+
+    companion object {
+        const val NAME = "RNKakaoSignin"
+    }
+
+    init {
+        configureKakaoSdk()
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    // SDK 초기화
+    private fun configureKakaoSdk() {
+        if (KakaoSdk.isInitialized) {
+            return
+        }
+
+        val appKey = resolveMetaData("com.kakao.sdk.AppKey")
+            ?: resolveString("kakao_app_key")
+            ?: return
+
+        val customScheme = resolveString("kakao_custom_scheme")
+
+        if (customScheme.isNullOrBlank()) {
+            KakaoSdk.init(reactApplicationContext, appKey)
+            return
+        }
+
+        KakaoSdk.init(reactApplicationContext, appKey, customScheme)
+    }
+
+    // 카카오톡 로그인
+    @ReactMethod
+    override fun login(promise: Promise) {
+        val activity = currentActivity
+
+        if (activity == null) {
+            promise.reject("E_ACTIVITY_DOES_NOT_EXIST", "Activity doesn't exist")
+            return
+        }
+
+        if (!UserApiClient.instance.isKakaoTalkLoginAvailable(activity)) {
+            loginWithAccount(promise)
+            return
+        }
+
+        UserApiClient.instance.loginWithKakaoTalk(activity) { token, error ->
+            when {
+                token != null -> promise.resolve(resolveToken(token.accessToken, token.refreshToken, token.idToken, token.scopes))
+                error is ClientError && error.reason == ClientErrorCause.Cancelled ->
+                    promise.reject("E_CANCELLED_OPERATION", error.message, error)
+                error != null -> loginWithAccount(promise)
+                else -> promise.reject("E_UNKNOWN_ERROR", "Login failed")
+            }
+        }
+    }
+
+    // 카카오계정 로그인
+    @ReactMethod
+    override fun loginWithKakaoAccount(promise: Promise) {
+        loginWithAccount(promise)
+    }
+
+    // 로그아웃
+    @ReactMethod
+    override fun logout(promise: Promise) {
+        UserApiClient.instance.logout { error ->
+            if (error != null) {
+                promise.reject("E_FAILED_OPERATION", error.message, error)
+                return@logout
+            }
+
+            promise.resolve(true)
+        }
+    }
+
+    // 연결 해제
+    @ReactMethod
+    override fun unlink(promise: Promise) {
+        UserApiClient.instance.unlink { error ->
+            if (error != null) {
+                promise.reject("E_FAILED_OPERATION", error.message, error)
+                return@unlink
+            }
+
+            promise.resolve(true)
+        }
+    }
+
+    // 액세스 토큰 조회
+    @ReactMethod
+    override fun getAccessToken(promise: Promise) {
+        val token = TokenManagerProvider.instance.manager.getToken()
+
+        if (token == null) {
+            promise.resolve(null)
+            return
+        }
+
+        promise.resolve(resolveToken(token.accessToken, token.refreshToken, token.idToken, token.scopes))
+    }
+
+    // 프로필 조회
+    @ReactMethod
+    override fun getProfile(promise: Promise) {
+        UserApiClient.instance.me { user, error ->
+            if (error != null) {
+                promise.reject("E_FAILED_OPERATION", error.message, error)
+                return@me
+            }
+
+            if (user == null) {
+                promise.reject("E_PROFILE_NOT_FOUND", "Profile not found")
+                return@me
+            }
+
+            val profile = Arguments.createMap()
+            val account = user.kakaoAccount
+            val detail = account?.profile
+
+            profile.putString("id", user.id?.toString())
+            profile.putString("name", account?.name)
+            profile.putString("email", account?.email)
+            profile.putString("nickname", detail?.nickname)
+            profile.putString("profileImageUrl", detail?.profileImageUrl)
+            profile.putString("thumbnailImageUrl", detail?.thumbnailImageUrl)
+            profile.putString("phoneNumber", account?.phoneNumber)
+            profile.putString("ageRange", account?.ageRange?.toString())
+            profile.putString("birthday", account?.birthday)
+            profile.putString("birthdayType", account?.birthdayType?.toString())
+            profile.putString("birthyear", account?.birthyear)
+            profile.putString("gender", account?.gender?.toString())
+            account?.isEmailValid?.let { profile.putBoolean("isEmailValid", it) }
+            account?.isEmailVerified?.let { profile.putBoolean("isEmailVerified", it) }
+            account?.isKorean?.let { profile.putBoolean("isKorean", it) }
+            account?.hasEmail?.let { profile.putBoolean("hasEmail", it) }
+            account?.hasPhoneNumber?.let { profile.putBoolean("hasPhoneNumber", it) }
+            account?.hasBirthday?.let { profile.putBoolean("hasBirthday", it) }
+            account?.hasBirthyear?.let { profile.putBoolean("hasBirthyear", it) }
+            account?.hasAgeRange?.let { profile.putBoolean("hasAgeRange", it) }
+            account?.hasGender?.let { profile.putBoolean("hasGender", it) }
+            detail?.isDefaultImage?.let { profile.putBoolean("isDefaultImage", it) }
+            detail?.isDefaultNickname?.let { profile.putBoolean("isDefaultNickname", it) }
+            profile.putString("connectedAt", formatDate(user.connectedAt))
+            profile.putString("synchedAt", formatDate(user.synchedAt))
+            account?.isLeapMonth?.let { profile.putBoolean("isLeapMonth", it) }
+            account?.ci?.let { profile.putString("ci", it) }
+            profile.putString("ciAuthenticatedAt", formatDate(account?.ciAuthenticatedAt))
+            account?.ageRangeNeedsAgreement?.let { profile.putBoolean("ageRangeNeedsAgreement", it) }
+            account?.birthdayNeedsAgreement?.let { profile.putBoolean("birthdayNeedsAgreement", it) }
+            account?.birthyearNeedsAgreement?.let { profile.putBoolean("birthyearNeedsAgreement", it) }
+            account?.emailNeedsAgreement?.let { profile.putBoolean("emailNeedsAgreement", it) }
+            account?.genderNeedsAgreement?.let { profile.putBoolean("genderNeedsAgreement", it) }
+            account?.isKoreanNeedsAgreement?.let { profile.putBoolean("isKoreanNeedsAgreement", it) }
+            account?.phoneNumberNeedsAgreement?.let { profile.putBoolean("phoneNumberNeedsAgreement", it) }
+            account?.profileNeedsAgreement?.let { profile.putBoolean("profileNeedsAgreement", it) }
+            account?.profileNicknameNeedsAgreement?.let { profile.putBoolean("profileNicknameNeedsAgreement", it) }
+            account?.profileImageNeedsAgreement?.let { profile.putBoolean("profileImageNeedsAgreement", it) }
+            account?.nameNeedsAgreement?.let { profile.putBoolean("nameNeedsAgreement", it) }
+            account?.ciNeedsAgreement?.let { profile.putBoolean("ciNeedsAgreement", it) }
+            promise.resolve(profile)
+        }
+    }
+
+    // 배송지 조회
+    @ReactMethod
+    override fun shippingAddresses(promise: Promise) {
+        UserApiClient.instance.shippingAddresses { addresses, error ->
+            if (error != null) {
+                promise.reject("E_FAILED_OPERATION", error.message, error)
+                return@shippingAddresses
+            }
+
+            if (addresses == null) {
+                promise.reject("E_SHIPPING_ADDRESSES_NOT_FOUND", "Shipping addresses not found")
+                return@shippingAddresses
+            }
+
+            val result = Arguments.createMap()
+            result.putString("userId", addresses.userId?.toString())
+            addresses.needsAgreement?.let { result.putBoolean("needsAgreement", it) }
+
+            val array = Arguments.createArray()
+            addresses.shippingAddresses?.map { addr ->
+                Arguments.createMap().apply {
+                    putString("id", addr.id?.toString())
+                    putString("name", addr.name)
+                    addr.isDefault?.let { putBoolean("isDefault", it) }
+                    putString("updatedAt", formatDate(addr.updatedAt))
+                    putString("type", addr.type?.toString())
+                    putString("baseAddress", addr.baseAddress)
+                    putString("detailAddress", addr.detailAddress)
+                    putString("receiverName", addr.receiverName)
+                    putString("receiverPhoneNumber1", addr.receiverPhoneNumber1)
+                    putString("receiverPhoneNumber2", addr.receiverPhoneNumber2)
+                    putString("zoneNumber", addr.zoneNumber)
+                    putString("zipCode", addr.zipCode)
+                }
+            }?.forEach(array::pushMap)
+            result.putArray("shippingAddresses", array)
+
+            promise.resolve(result)
+        }
+    }
+
+    // 서비스 약관 조회
+    @ReactMethod
+    override fun serviceTerms(promise: Promise) {
+        UserApiClient.instance.serviceTerms { terms, error ->
+            if (error != null) {
+                promise.reject("E_FAILED_OPERATION", error.message, error)
+                return@serviceTerms
+            }
+
+            val result = Arguments.createMap()
+            terms?.id?.let { result.putString("userId", it.toString()) }
+
+            val array = Arguments.createArray()
+            terms?.serviceTerms?.map { term ->
+                Arguments.createMap().apply {
+                    putString("tag", term.tag)
+                    putBoolean("agreed", term.agreed)
+                    putBoolean("required", term.required)
+                    putBoolean("revocable", term.revocable)
+                    term.agreedAt?.let { putString("agreedAt", formatDate(it)) }
+                }
+            }?.forEach(array::pushMap)
+            if (array.size() > 0) {
+                result.putArray("serviceTerms", array)
+            }
+
+            promise.resolve(result)
+        }
+    }
+
+    // 카카오계정 웹 로그인
+    private fun loginWithAccount(promise: Promise) {
+        val activity = currentActivity
+
+        if (activity == null) {
+            promise.reject("E_ACTIVITY_DOES_NOT_EXIST", "Activity doesn't exist")
+            return
+        }
+
+        UserApiClient.instance.loginWithKakaoAccount(activity) { token, error ->
+            when {
+                token != null -> promise.resolve(resolveToken(token.accessToken, token.refreshToken, token.idToken, token.scopes))
+                error != null -> promise.reject(resolveErrorCode(error), error.message, error)
+                else -> promise.reject("E_UNKNOWN_ERROR", "Login failed")
+            }
+        }
+    }
+
+    // 앱 메타데이터 조회
+    private fun resolveMetaData(key: String): String? {
+        return try {
+            val packageInfo = reactApplicationContext.packageManager.getApplicationInfo(
+                reactApplicationContext.packageName,
+                PackageManager.GET_META_DATA
+            )
+
+            packageInfo.metaData?.getString(key)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    // 문자열 리소스 조회
+    private fun resolveString(name: String): String? {
+        val resourceId = reactApplicationContext.resources.getIdentifier(
+            name,
+            "string",
+            reactApplicationContext.packageName
+        )
+
+        if (resourceId == 0) {
+            return null
+        }
+
+        return reactApplicationContext.getString(resourceId)
+    }
+
+    // 토큰 응답 생성
+    private fun resolveToken(accessToken: String?, refreshToken: String?, idToken: String? = null, scopes: List<String>? = null): WritableMap {
+        val token = Arguments.createMap()
+        val current = TokenManagerProvider.instance.manager.getToken()
+
+        token.putString("accessToken", accessToken)
+        token.putString("refreshToken", refreshToken)
+        token.putString("idToken", idToken)
+        token.putString("accessTokenExpiresAt", formatDate(current?.accessTokenExpiresAt))
+        token.putString("refreshTokenExpiresAt", formatDate(current?.refreshTokenExpiresAt))
+        token.putString("appKeyHash", Utility.getKeyHash(reactApplicationContext))
+
+        val scopeArray = Arguments.createArray()
+        scopes?.forEach { scopeArray.pushString(it) }
+        token.putArray("scopes", scopeArray)
+
+        return token
+    }
+
+    // 에러 코드 변환
+    private fun resolveErrorCode(error: Throwable): String {
+        return when {
+            error is ClientError && error.reason == ClientErrorCause.Cancelled ->
+                "E_CANCELLED_OPERATION"
+            else -> "E_FAILED_OPERATION"
+        }
+    }
+
+    // 날짜 포맷 변환
+    private fun formatDate(date: Date?): String? {
+        if (date == null) {
+            return null
+        }
+
+        val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
+        formatter.timeZone = TimeZone.getTimeZone("UTC")
+        return formatter.format(date)
+    }
+}

package/android/src/main/java/com/packagekr/kakao/RNKakaoLoginPackage.kt

@@ -0,0 +1,46 @@
+package com.packagekr.kakao
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class RNKakaoSigninPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return when (name) {
+            RNKakaoSigninModule.NAME -> RNKakaoSigninModule(reactContext)
+            else -> null
+        }
+    }
+
+    // 모듈 정보 생성
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        val moduleList = arrayOf(RNKakaoSigninModule::class.java)
+        val reactModuleInfoMap = HashMap<String, ReactModuleInfo>()
+
+        for (moduleClass in moduleList) {
+            val reactModule = moduleClass.getAnnotation(ReactModule::class.java) ?: continue
+
+            reactModuleInfoMap[reactModule.name] = ReactModuleInfo(
+                reactModule.name,
+                moduleClass.name,
+                false,
+                reactModule.needsEagerInit,
+                reactModule.isCxxModule,
+                true
+            )
+        }
+
+        return ReactModuleInfoProvider { reactModuleInfoMap }
+    }
+
+    // 뷰 매니저 반환
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/ios/RNKakaoError.swift

@@ -0,0 +1,100 @@
+import Foundation
+
+import KakaoSDKCommon
+import KakaoSDKAuth
+
+enum RNKakaoError {
+  // 로그인 에러 메시지 보정
+  private static func resolveAuthMessage(
+    _ reason: AuthFailureReason,
+    _ authErrorInfo: AuthErrorInfo?,
+    _ fallback: String
+  ) -> (code: String, message: String) {
+    let description = authErrorInfo?.errorDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
+    let normalizedDescription = description?.lowercased() ?? ""
+
+    switch reason {
+    case .InvalidRequest:
+      if normalizedDescription.contains("bundle") {
+        return ("KAKAO_INVALID_BUNDLE_ID", "iOS 번들 ID 설정이 올바르지 않습니다. Kakao 콘솔의 iOS 번들 ID와 Xcode 설정을 확인해주세요.")
+      }
+      if normalizedDescription.contains("scheme") || normalizedDescription.contains("redirect") {
+        return ("KAKAO_INVALID_URL_SCHEME", "iOS URL scheme 설정이 올바르지 않습니다. Info.plist의 URL Types, KAKAO_APP_SCHEME, Kakao 콘솔 설정을 확인해주세요.")
+      }
+      if normalizedDescription.contains("client") || normalizedDescription.contains("app key") {
+        return ("KAKAO_INVALID_APP_KEY", "KAKAO_APP_KEY 값이 올바르지 않습니다. Kakao 네이티브 앱 키와 Info.plist 설정을 확인해주세요.")
+      }
+      return ("KAKAO_INVALID_REQUEST", "로그인 요청이 올바르지 않습니다. Kakao iOS 앱 설정과 전달 파라미터를 확인해주세요.")
+
+    case .InvalidClient:
+      return ("KAKAO_INVALID_CLIENT", "카카오 iOS 앱 설정이 올바르지 않습니다. KAKAO_APP_KEY, 번들 ID, iOS 플랫폼 등록값을 확인해주세요.")
+
+    case .AccessDenied:
+      return ("KAKAO_ACCESS_DENIED", "사용자가 카카오 로그인을 취소했거나 접근 권한을 거부했습니다.")
+
+    case .InvalidScope:
+      return ("KAKAO_INVALID_SCOPE", "유효하지 않은 동의 항목(scope)입니다. 요청한 동의 항목과 Kakao 콘솔 설정을 확인해주세요.")
+
+    case .Misconfigured:
+      return ("KAKAO_MISCONFIGURED", "카카오 iOS 설정이 올바르지 않습니다. 번들 ID, URL scheme, KAKAO_APP_KEY, Kakao 콘솔 설정을 확인해주세요.")
+
+    case .Unauthorized:
+      return ("KAKAO_UNAUTHORIZED", "카카오 로그인 권한이 없습니다. 앱 권한과 플랫폼 설정을 확인해주세요.")
+
+    case .InvalidGrant:
+      return ("KAKAO_INVALID_GRANT", "인가 정보가 유효하지 않습니다. 다시 로그인해주세요.")
+
+    case .ServerError:
+      return ("KAKAO_SERVER_ERROR", "카카오 서버 오류가 발생했습니다. 잠시 후 다시 시도해주세요.")
+
+    default:
+      return ("KAKAO_AUTH_ERROR", description ?? authErrorInfo?.error.rawValue ?? fallback)
+    }
+  }
+
+  // SDK 에러 해석
+  static func parse(_ error: Error) -> (code: String, message: String) {
+    guard let sdkError = error as? SdkError else {
+      return ("KAKAO_ERROR", error.localizedDescription)
+    }
+
+    switch sdkError {
+    // 클라이언트 에러
+    case .ClientFailed(let reason, let errorMessage):
+      switch reason {
+      case .Cancelled:
+        return ("KAKAO_CANCELLED", "사용자가 로그인을 취소했습니다.")
+      case .NotSupported:
+        return ("KAKAO_NOT_SUPPORTED", "지원하지 않는 기능입니다.")
+      case .BadParameter:
+        return ("KAKAO_BAD_PARAMETER", "잘못된 파라미터입니다. \(errorMessage ?? "")")
+      case .TokenNotFound:
+        return ("KAKAO_TOKEN_NOT_FOUND", "로그인이 필요합니다.")
+      case .IllegalState:
+        return ("KAKAO_ILLEGAL_STATE", "잘못된 상태입니다. \(errorMessage ?? "")")
+      default:
+        return ("KAKAO_CLIENT_ERROR", errorMessage ?? error.localizedDescription)
+      }
+
+    // API 에러
+    case .ApiFailed(let reason, let errorInfo):
+      switch reason {
+      case .InvalidAccessToken:
+        return ("KAKAO_UNAUTHORIZED", "인증이 만료되었습니다. 다시 로그인해주세요.")
+      case .Permission, .InsufficientScope:
+        return ("KAKAO_FORBIDDEN", "권한이 없습니다. 동의 항목을 확인해주세요.")
+      case .ApiLimitExceed:
+        return ("KAKAO_RATE_LIMIT", "요청이 너무 많습니다. 잠시 후 다시 시도해주세요.")
+      default:
+        return ("KAKAO_API_ERROR", errorInfo?.msg ?? error.localizedDescription)
+      }
+
+    // 인증 에러
+    case .AuthFailed(let reason, let authErrorInfo):
+      return resolveAuthMessage(reason, authErrorInfo, error.localizedDescription)
+
+    default:
+      return ("KAKAO_ERROR", error.localizedDescription)
+    }
+  }
+}

package/ios/RNKakaoLogin-Bridging-Header.h

@@ -0,0 +1 @@
+#import <React/RCTBridgeModule.h>

package/ios/RNKakaoLogin.h

@@ -0,0 +1,8 @@
+@class RNKakaoSignin;
+
+@interface RNKakaoSignin : NSObject
+- (RNKakaoSignin *)returnSwiftClassInstance;
++ (BOOL)isKakaoTalkLoginUrl:(NSURL *)url;
++ (BOOL)handleOpenUrl:(NSURL *)url;
+@end
+

package/ios/RNKakaoLogin.mm

@@ -0,0 +1,13 @@
+#import <React/RCTBridgeModule.h>
+#import <RNKakaoSigninSpec/RNKakaoSigninSpec.h>
+
+@interface RCT_EXTERN_MODULE(RNKakaoSignin, NSObject)
+
+RCT_EXTERN_METHOD(login:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+RCT_EXTERN_METHOD(loginWithKakaoAccount:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+RCT_EXTERN_METHOD(logout:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+RCT_EXTERN_METHOD(unlink:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+RCT_EXTERN_METHOD(getProfile:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+RCT_EXTERN_METHOD(getAccessToken:(RCTPromiseResolveBlock *)resolve rejecter:(RCTPromiseRejectBlock *)reject);
+
+@end