refactor: :core:core-common에 순수 유틸리티/확장함수(JamoUtils, SimpleTransliterater, DataUtils, typeAlias) 이동

- :core:core-database 분리를 위한 선행 작업으로 :app 비의존 유틸리티 4종을 :core:core-common으로 이동:
  * utils/JamoUtils.kt
  * utils/SimpleTransliterater.kt
  * utils/DataUtils.kt
  * common/typeAlias.kt
- 검증: ./gradlew :app:compileDebugKotlin 빌드 성공 확인 (6s)
This commit is contained in:
2026-11-16 13:18:50 +09:00
parent 3e214f740e
commit 7ce291c2b7
4 changed files with 0 additions and 0 deletions
@@ -1,13 +0,0 @@
package bums.lunatic.launcher.common
typealias DismissCalback = ()->Unit
typealias BLOCK = ()->Unit
inline fun Boolean.letTrue(block: BLOCK) {
if (this) {
block.invoke()
} else {
// elseblock.invoke()
}
}
@@ -1,134 +0,0 @@
package bums.lunatic.launcher.utils
import android.content.ContentResolver
import android.net.Uri
import android.provider.ContactsContract
import android.provider.ContactsContract.PhoneLookup
import java.util.Calendar
import java.util.Date
data class KakaoPayTransitHistory(
val dateTime: String,
val transportType: String,
val transportName: String,
val balance: Int
)
fun KakaoPublicTransfer(raw : String) : KakaoPayTransitHistory {
val dateTimeRegex = Regex("""사용일시\s*:\s*([^\n]+)""")
val transportTypeRegex = Regex("""이용수단\s*:\s*([^\n]+)""")
val transportNameRegex = Regex("""이용수단명\s*:\s*([^\n]+)""")
val balanceRegex = Regex("""잔액\s*:\s*([\d,]+)""")
val dateTime = dateTimeRegex.find(raw)?.groups?.get(1)?.value?.trim() ?: ""
val transportType = transportTypeRegex.find(raw)?.groups?.get(1)?.value?.trim() ?: ""
val transportName = transportNameRegex.find(raw)?.groups?.get(1)?.value?.trim() ?: ""
val balance = balanceRegex.find(raw)?.groups?.get(1)?.value?.replace(",", "")?.toInt() ?: 0
return KakaoPayTransitHistory(dateTime, transportType, transportName, balance)
}
fun afterDay(date: Long): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(Date(date))
cal.add(Calendar.HOUR_OF_DAY, 23)
cal.add(Calendar.MINUTE, 53)
return cal.timeInMillis
}
fun before30Min(date: Date): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(date)
cal.add(Calendar.MINUTE, -30)
return cal.timeInMillis
}
fun beforeOneDay(): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(Date())
// cal.add(Calendar.DAY_OF_YEAR, -1)
cal.add(Calendar.HOUR_OF_DAY, -4)
return cal.timeInMillis
}
fun beforeDay(day: Int): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(Date())
cal.add(Calendar.DAY_OF_YEAR, Math.abs(day) * -1)
return cal.timeInMillis
}
fun beforeDayBy(date : Date, day: Int): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(date)
cal.add(Calendar.DAY_OF_YEAR, Math.abs(day) * -1)
return cal.timeInMillis
}
fun make0H(date: Date?): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(date)
cal.set(Calendar.HOUR, 1)
return cal.timeInMillis
}
fun afterDay(date: Date?, day: Int): Long {
val cal: Calendar = Calendar.getInstance()
cal.setTime(date)
cal.add(Calendar.DAY_OF_YEAR, Math.abs(day) * 1)
return cal.timeInMillis
}
fun getContactName(contentResolver: ContentResolver, phoneNumber: String?): String? {
var contactName: String? = null
if (phoneNumber != null && phoneNumber.length > 0) {
val cr = contentResolver
val uri = Uri.withAppendedPath(ContactsContract.PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phoneNumber))
val cursor =
cr.query(uri, arrayOf(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME), null, null, null)
?: return null
if (cursor.moveToFirst()) {
contactName = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME))
}
if (cursor != null && !cursor.isClosed) {
cursor.close()
}
}
return contactName
}
fun getContactId(contentResolver: ContentResolver, phoneNumber: String?): String? {
val cr = contentResolver
val uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phoneNumber))
val cursor =
cr.query(uri, arrayOf(PhoneLookup._ID), null, null, null)
?: return null
var contactName: String? = null
if (cursor.moveToFirst()) {
contactName = cursor.getString(cursor.getColumnIndexOrThrow(PhoneLookup._ID))
}
if (cursor != null && !cursor.isClosed) {
cursor.close()
}
return contactName
}
fun DoubleArray.inRange(src : Double) : Boolean {
try {
if (this.max() >= src && this.min() >= src) {
return true
}
} catch (e : Exception) {
}
return false
}
@@ -1,41 +0,0 @@
package bums.lunatic.launcher.utils
import android.annotation.SuppressLint
object JamoUtils {
val CHOSUNG = listOf(
"ㄱ", "ㄲ", "ㄴ", "ㄷ", "ㄸ", "ㄹ", "ㅁ", "ㅂ", "ㅃ",
"ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ",
)
val JUNGSUNG = listOf(
"ㅏ", "ㅐ", "ㅑ", "ㅒ", "ㅓ", "ㅔ", "ㅕ", "ㅖ", "ㅗ", "ㅘ",
"ㅙ", "ㅚ", "ㅛ", "ㅜ", "ㅝ", "ㅞ", "ㅟ", "ㅠ", "ㅡ", "ㅢ", "ㅣ",
)
val JONGSUNG = listOf(
"", "ㄱ", "ㄲ", "ᆪ", "ᆫ", "ᆬ", "ᆭ", "ㄷ",
"ㄹ", "ᆰ", "ᆱ", "ᆲ", "ᆳ", "ᆴ", "ᆵ", "ᆶ", "ㅁ", "ㅂ", "ᆹ", "ᆺ", "ᆻ", "ᆼ",
"ᆽ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ",
)
fun split(target: String?): List<String> {
if (target.isNullOrEmpty()) return arrayListOf()
return target.split("")
.filter(String::isNotEmpty)
.map(JamoUtils::splitOne)
.toList()
}
@SuppressLint("SuspiciousIndentation")
fun splitOne(target: String): String {
val codePoint = Character.codePointAt(target, 0)
return if (codePoint in 0xAC00..0xD79D) {
val startValue = codePoint - 0xAC00
val jong = startValue % 28
val jung = (startValue - jong) / 28 % 21
val cho = ((startValue - jong) / 28 - jung) / 21
CHOSUNG[cho]
} else {
""
}
}
}
@@ -1,461 +0,0 @@
package bums.lunatic.launcher.utils
import java.util.Locale
object SimpleTransliterater {
// 기존 키보드 매핑 상수 유지
private val EN_KEY = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
private val KO_KEY = "ㅂㅈㄷㄱㅅㅛㅕㅑㅐㅔㅁㄴㅇㄹㅎㅗㅓㅏㅣㅋㅌㅊㅍㅠㅜㅡㅃㅉㄸㄲㅆㅛㅕㅑㅒㅖㅁㄴㅇㄹㅎㅗㅓㅏㅣㅋㅌㅊㅍㅠㅜㅡ"
// 자모 상수
private val CHOSUNG = listOf("ㄱ", "ㄲ", "ㄴ", "ㄷ", "ㄸ", "ㄹ", "ㅁ", "ㅂ", "ㅃ", "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ")
// 로마자 변환을 위한 초성 매핑 (발음 기반 검색용)
private val CHOSUNG_EN = listOf("g", "kk", "n", "d", "tt", "l", "m", "b", "pp", "s", "ss", "", "j", "jj", "ch", "k", "t", "p", "h")
private val JUNGSUNG = listOf("ㅏ", "ㅐ", "ㅑ", "ㅒ", "ㅓ", "ㅔ", "ㅕ", "ㅖ", "ㅗ", "ㅘ", "ㅙ", "ㅚ", "ㅛ", "ㅜ", "ㅝ", "ㅞ", "ㅟ", "ㅠ", "ㅡ", "ㅢ", "ㅣ")
private val JUNGSUNG_EN = listOf("a", "ae", "ya", "yae", "eo", "e", "yeo", "ye", "o", "wa", "wae", "oe", "yo", "u", "wo", "we", "wi", "yu", "eu", "ui", "i")
private val JONGSUNG = listOf("", "ㄱ", "ㄲ", "ㄳ", "ㄴ", "ㄵ", "ㄶ", "ㄷ", "ㄹ", "ㄺ", "ㄻ", "ㄼ", "ㄽ", "ㄾ", "ㄿ", "ㅀ", "ㅁ", "ㅂ", "ㅄ", "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ")
private val JONGSUNG_EN = listOf("", "k", "kk", "ks", "n", "nj", "nh", "t", "l", "lk", "lm", "lb", "ls", "lt", "lp", "lh", "m", "p", "ps", "t", "ss", "ng", "t", "t", "k", "t", "p", "h")
private fun mapKoToEn(ko: String): String {
// 복합 자모 처리 (예: ㄶ -> ne)
val map = mapOf("ㄳ" to "rt", "ㄵ" to "sw", "ㄶ" to "sg", "ㄺ" to "fr", "ㄻ" to "fa", "ㄼ" to "fq", "ㄽ" to "ft", "ㄾ" to "fx", "ㄿ" to "fv", "ㅀ" to "fg", "ㅄ" to "qt", "ㅘ" to "hk", "ㅙ" to "hl", "ㅚ" to "ho", "ㅝ" to "nj", "ㅞ" to "nl", "ㅟ" to "np", "ㅢ" to "ml")
if (map.containsKey(ko)) return map[ko]!!
val idx = KO_KEY.indexOf(ko)
return if (idx != -1) EN_KEY[idx % 52].toString() else ko
}
fun makeSearchIndex(text: String): String {
val sb = StringBuilder()
val lowerText = text.lowercase(Locale.getDefault()).trim()
sb.append(lowerText).append("|") // 1. 원본
sb.append(makeChosung(text)).append("|") // 2. 초성
if (isKorean(text)) {
sb.append(hangulToRoman(text)).append("|") // 3. 한글 -> 영어 (카카오 -> kakao)
} else if (isEnglish(text)) {
// [NEW] 4. 영어 -> 한글 발음 (Instagram -> 인스타그램, 인스타)
val hangulPronunciation = englishToHangul(text)
sb.append(hangulPronunciation).append("|")
sb.append(makeChosung(hangulPronunciation)).append("|") // 발음의 초성도 추가 (인스타그램 -> ㅇㅅㅌㄱㄹ)
}
return sb.toString()
}
/**
* [유사도 계산] (Levenshtein Distance 알고리즘)
* 두 문자열이 얼마나 유사한지 0.0 ~ 1.0 사이의 점수로 반환합니다.
* 1.0이면 완전 일치, 0.0이면 완전 불일치.
*/
fun getSimilarity(s1: String, s2: String): Double {
val longer = if (s1.length > s2.length) s1 else s2
val shorter = if (s1.length > s2.length) s2 else s1
if (longer.isEmpty()) return 1.0 // 둘 다 공백이면 일치
val distance = levenshteinDistance(longer, shorter)
return (longer.length - distance).toDouble() / longer.length.toDouble()
}
// 편집 거리(Levenshtein Distance) 계산 함수
private fun levenshteinDistance(lhs: CharSequence, rhs: CharSequence): Int {
val m = lhs.length
val n = rhs.length
val dp = Array(m + 1) { IntArray(n + 1) }
for (i in 0..m) dp[i][0] = i
for (j in 0..n) dp[0][j] = j
for (i in 1..m) {
for (j in 1..n) {
val cost = if (lhs[i - 1] == rhs[j - 1]) 0 else 1
dp[i][j] = kotlin.math.min(
dp[i - 1][j] + 1,
kotlin.math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost)
)
}
}
return dp[m][n]
}
fun koToEn(input: String): String {
val sb = StringBuilder()
for (char in input) {
val code = char.code
if (code in 0xAC00..0xD7AF) { // 완성형 한글
val base = code - 0xAC00
val cho = base / 21 / 28
val jung = (base / 28) % 21
val jong = base % 28
sb.append(mapKoToEn(CHOSUNG[cho]))
sb.append(mapKoToEn(JUNGSUNG[jung]))
if (jong != 0) sb.append(mapKoToEn(JONGSUNG[jong]))
} else {
sb.append(mapKoToEn(char.toString()))
}
}
return sb.toString()
}
/**
* [검색 메인 함수]
* 앱 이름(target)과 검색어(query)를 비교하여 매칭 여부를 반환합니다.
*/
fun match(target: String, query: String): Boolean {
if (query.isEmpty()) return true
val t = target.trim()
val q = query.trim()
// 1. 기본 포함 여부 (대소문자 무시)
if (t.contains(q, ignoreCase = true)) return true
// 2. 한글 초성 검색 (예: '카카오톡' -> 'ㅋㅋ')
// 검색어가 모두 한글 자음(초성)으로만 구성되어 있는지 확인
if (isAllChosung(q)) {
val targetChosung = makeChosung(t)
if (targetChosung.contains(q)) return true
}
// 3. 영한 발음 검색 (예: 영어 앱 'Instagram'을 한글 '인스타'로 검색)
// 검색어(한글)를 로마자로 변환하여 영어 앱 이름과 비교
if (isKorean(q) && isEnglish(t)) {
val romanQuery = hangulToRoman(q)
if (t.lowercase(Locale.getDefault()).contains(romanQuery)) return true
}
// 4. (선택사항) 영타 오타 보정 (예: '안녕'을 'dkssud'로 쳤을 때)
// 이미 EnToKo.kt가 있다면 그곳의 로직을 사용할 수도 있습니다.
val korFromEngKey = enToKo(q) // dkssud -> 안녕
if (t.contains(korFromEngKey, ignoreCase = true)) return true
return false
}
/**
* 문자열에서 초성만 추출합니다. (예: "홍길동" -> "ㅎㄱㄷ")
*/
fun makeChosung(input: String): String {
val sb = StringBuilder()
for (char in input) {
val code = char.code
if (code in 0xAC00..0xD7AF) {
val choIndex = (code - 0xAC00) / 28 / 21
sb.append(CHOSUNG[choIndex])
} else {
sb.append(char) // 한글이 아니면 그대로 둠
}
}
return sb.toString()
}
/**
* 한글 문자열을 로마자(발음)로 변환합니다. (예: "인스타" -> "inseuta")
* 단순 매핑 방식이므로 완벽한 발음기호는 아니지만 검색용으로 유용합니다.
*/
fun hangulToRoman(input: String): String {
val sb = StringBuilder()
for (char in input) {
val code = char.code
if (code in 0xAC00..0xD7AF) {
val base = code - 0xAC00
val choIndex = base / 28 / 21
val jungIndex = (base / 28) % 21
val jongIndex = base % 28
sb.append(CHOSUNG_EN[choIndex])
sb.append(JUNGSUNG_EN[jungIndex])
// 종성은 앞 글자의 받침이 뒷 글자의 초성과 이어지는 연음 법칙 등을 고려하지 않고 단순 매핑
if (jongIndex > 0 && jongIndex < JONGSUNG_EN.size) {
sb.append(JONGSUNG_EN[jongIndex])
}
} else {
sb.append(char)
}
}
return sb.toString()
}
// 검색어가 초성(자음)으로만 이루어졌는지 확인
private fun isAllChosung(text: String): Boolean {
for (char in text) {
if (char.code !in 0x3131..0x314E) { // ㄱ ~ ㅎ 범위
return false
}
}
return true
}
private fun isKorean(text: String): Boolean {
for (char in text) {
if (char.code in 0xAC00..0xD7AF) return true
}
return false
}
private fun isEnglish(text: String): Boolean {
for (char in text) {
if (char.code in 0x41..0x5A || char.code in 0x61..0x7A) return true
}
return false
}
// 기존의 영타 -> 한타 변환 함수 (그대로 유지)
fun enToKo(input: String): String {
val sb = StringBuilder()
for (char in input) {
val idx = EN_KEY.indexOf(char)
if (idx != -1) sb.append(KO_KEY[idx]) else sb.append(char)
}
return sb.toString()
}
private val APP_NAME_DICT = mapOf(
"gemini" to "제미나이",
"gmail" to "지메일",
"instagram" to "인스타그램",
"youtube" to "유튜브",
"facebook" to "페이스북",
"chrome" to "크롬",
"google" to "구글",
"kakaotalk" to "카카오톡",
"kakao" to "카카오",
"naver" to "네이버",
"toss" to "토스",
"kb" to "국민",
"shinhan" to "신한",
"coupang" to "쿠팡",
"baemin" to "배달의민족",
"netflix" to "넷플릭스",
"zoom" to "줌",
"slack" to "슬랙",
"discord" to "디스코드",
"spotify" to "스포티파이",
// 추가 글로벌 앱
"tiktok" to "틱톡",
"whatsapp" to "왓츠앱",
"telegram" to "텔레그램",
"snapchat" to "스냅챗",
"pinterest" to "핀터레스트",
"x" to "엑스", // X (舊 Twitter)
"threads" to "스레즈",
"chatgpt" to "챗지피티",
"github" to "깃허브",
"gitlab" to "깃랩",
"notion" to "노션",
"figma" to "피그마",
"discord" to "디스코드",
"zoom" to "줌",
"messenger" to "메신저",
"googlemaps" to "구글맵스",
"googlephotos" to "구글포토",
"googlecalendar" to "구글캘린더",
"googlepay" to "구글페이",
// 국내 앱 / 서비스
"kakao_map" to "카카오맵",
"kakao_t" to "카카오티",
"kakaopay" to "카카오페이",
"baedalchon" to "배달의민족", // baemin alias
"kurly" to "컬리",
"marketkurly" to "컬리",
"ssg" to "이마트몰",
"emart24" to "이마트24",
"lotteon" to "롯데온",
"ssgpay" to "쓱페이",
"happybean" to "해피빈",
"wibee" to "위비",
"tonerd" to "토너먼트", // 예: 토너먼트 앱
"bubble" to "버블",
"papago" to "파파고",
"cashwalk" to "캐시워크",
"kakao_health" to "카카오헬스케어",
"minwon24" to "민원24",
"kbpay" to "KB페이",
"shinhan_sbank" to "신한은행",
"woori" to "우리",
"ibk" to "기업은행",
"nh" to "농협",
"kb_card" to "KB국민카드",
"shinhancard" to "신한카드",
"wooricard" to "우리카드",
"cardfactory" to "카드팩토리",
"magazine_n" to "매거진엔",
"cultureland" to "컬쳐랜드",
"happymoney" to "해피머니",
"smilepay" to "스마일페이",
"ssg_point" to "쓱포인트",
"kakaotaxi" to "카카오택시", // kakao_t alias
"kakao_bus" to "카카오버스",
"kakao_navigation" to "카카오내비",
// 게임·엔터 관련
"cyberpunk2077" to "사이버펑크2077",
"gta" to "GTA",
"pubg" to "배틀그라운드",
"pubgm" to "배틀그라운드 모바일",
"leagueoflegends" to "리그오브레전드",
"leagueoflegends_mobile" to "리그오브레전드 와일드 리프트",
"honkai" to "붕괴",
"genshin" to "원신",
"honkai_star_rail" to "붕괴 스타레일",
"miy" to "미야오츠츠미", // 예: 특정 게임, 필요 시 조정
"among_us" to "어몽 어스",
"minecraft" to "마인크래프트",
"genshin_impact" to "원신 임팩트",
"tiktok_live" to "틱톡 라이브",
"twitch" to "트위치",
"twitchtv" to "트위치티비",
"twitchapp" to "트위치앱",
// 음악·스트리밍
"soundcloud" to "사운드클라우드",
"deezer" to "디저",
"melon" to "멜론",
"flo" to "플로",
"bugs" to "벅스",
"vibe" to "바이브",
"genie" to "지니",
"youtube_music" to "유튜브 뮤직",
"spotify" to "스포티파이",
"pandora" to "판도라",
"apple_music" to "애플뮤직",
// 교통·공공
"kakao_bus" to "카카오버스",
"kakao_subway" to "카카오지하철",
"ktx" to "케이티엑스",
"korail" to "코레일",
"snackbar" to "스낵바", // 예: 카카오톡 플러스친구 등
)
// 영어 자음 -> 한글 초성 매핑
private val ENG_TO_CHO = mapOf(
'b' to "ㅂ", 'c' to "ㅋ", 'd' to "ㄷ", 'f' to "ㅍ", 'g' to "ㄱ",
'h' to "ㅎ", 'j' to "ㅈ", 'k' to "ㅋ", 'l' to "ㄹ", 'm' to "ㅁ",
'n' to "ㄴ", 'p' to "ㅍ", 'q' to "ㅋ", 'r' to "ㄹ", 's' to "ㅅ",
't' to "ㅌ", 'v' to "ㅂ", 'w' to "ㅇ", 'x' to "ㅋ", 'y' to "ㅇ", 'z' to "ㅈ"
)
// 영어 모음 -> 한글 중성 매핑
private val ENG_TO_JUNG = mapOf(
'a' to "ㅏ", 'e' to "ㅔ", 'i' to "ㅣ", 'o' to "ㅗ", 'u' to "ㅜ",
'y' to "ㅣ" // y는 모음으로 쓰일 때도 있음
)
/**
* [영어 -> 한글 발음 변환 메인 함수]
* 예: "Instagram" -> "인스타그램" (사전 매칭)
* 예: "Test" -> "테스트" (규칙 변환)
*/
fun englishToHangul(text: String): String {
val lower = text.lowercase(Locale.getDefault())
// 1단계: 사전에 있는 단어인지 확인 (가장 정확)
APP_NAME_DICT[lower]?.let { return it }
// 2단계: 사전에 없다면 규칙 기반으로 변환 시도
return convertEngToKorRule(lower)
}
/**
* 규칙 기반 영한 변환기 (간이 버전)
* 자음+모음 -> 글자 조합
* 자음+자음 -> 'ㅡ' 추가
*/
private fun convertEngToKorRule(text: String): String {
val sb = StringBuilder()
var i = 0
val len = text.length
while (i < len) {
val curr = text[i]
// 영어가 아니면 그냥 통과
if (curr !in 'a'..'z') {
sb.append(curr)
i++
continue
}
// 자음인지 모음인지 확인
if (isVowel(curr)) {
// 모음으로 시작하면 'ㅇ' 붙여서 출력 (예: apple -> 애플)
val jung = ENG_TO_JUNG[curr] ?: "ㅏ"
sb.append(combineHangul("ㅇ", jung, ""))
i++
} else {
// 자음인 경우
val cho = ENG_TO_CHO[curr] ?: "ㄱ"
// 다음 글자 확인
if (i + 1 < len) {
val next = text[i + 1]
if (isVowel(next)) {
// 자음 + 모음 -> 합체 (예: t + e -> 테)
val jung = ENG_TO_JUNG[next] ?: "ㅏ"
// 다다음 글자가 받침이 될 수 있는지 확인 (간단한 종성 처리)
var jong = ""
if (i + 2 < len) {
val next2 = text[i + 2]
if (!isVowel(next2) && next2 != 'y') { // 자음이면 받침 후보
// 단, 그 뒤에 또 모음이 오면 받침이 아님 (예: te-s-t -> 's'는 받침 아님)
if (i + 3 >= len || !isVowel(text[i + 3])) {
jong = getJongsung(next2)
if (jong.isNotEmpty()) i++ // 받침으로 썼으니 인덱스 증가
}
}
}
sb.append(combineHangul(cho, jung, jong))
i += 2
} else {
// 자음 + 자음 -> 'ㅡ' 추가 (예: s + t -> 스)
sb.append(combineHangul(cho, "ㅡ", ""))
i++
}
} else {
// 마지막이 자음으로 끝남 -> 'ㅡ' 추가 (예: ...t -> 트)
// (받침으로 넣을 수도 있지만, 검색용으로는 풀어서 쓰는게 매칭률이 높음)
sb.append(combineHangul(cho, "ㅡ", ""))
i++
}
}
}
return sb.toString()
}
private fun isVowel(c: Char): Boolean {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'
}
// 종성(받침) 매핑 (제한적)
private fun getJongsung(c: Char): String {
return when (c) {
'n' -> "ㄴ"; 'm' -> "ㅁ"; 'l' -> "ㄹ"; 'k' -> "ㄱ"; 'p' -> "ㅂ"; 't' -> "ㅅ"; 'g' -> "ㅇ" // ng 약식
else -> ""
}
}
// 초성, 중성, 종성 문자열을 받아 한글 한 글자로 합치는 함수
private fun combineHangul(cho: String, jung: String, jong: String): String {
val choIdx = CHOSUNG.indexOf(cho)
val jungIdx = JUNGSUNG.indexOf(jung)
val jongIdx = JONGSUNG.indexOf(jong)
if (choIdx == -1 || jungIdx == -1) return cho // 실패 시 그냥 자음 반환
// 한글 유니코드 공식: 0xAC00 + (초성 * 21 + 중성) * 28 + 종성
val code = 0xAC00 + (choIdx * 21 + jungIdx) * 28 + (if (jongIdx != -1) jongIdx else 0)
return code.toChar().toString()
}
}