epochday 라는게 있습니다. 프로그램 하시는 분들은 아시겠지만 날짜를 1970.1.1. 부터 몇일째 되는 날인지 확인하는 개념입니다.

그런데 계산기로 계산하기는 귀찮고 해서 ai에게 물어 봤습니다.

• MS의 챗 GPT입니다.

2024.12.15. 로 보고 하고 있습니다.

• 구글 제미나이 입니다.

• 퍼플랙씨티입니다.

• 일론 머스크의 그록입니다.

• 차이나의 딥씩입니다.

• 모든 AI의 답이 다르고 다수결도 되지 않습니다. 실제 정답은 2025.2.13.로 는 모든 AI는 틀렸습니다.

• 왜 이따구로 처리 될까요 ?

• 여러번 격은건데 AI의 더하기는 형편 없습니다. 실제로는 닝겐들이 올려논 정보를 이리 저리 조합하는데 1과 1은 같다가 거짓으로 인식 할 수 있는게 실수(Floatting Pointer)계산 컴퓨터입니다.

• filezilla 파일질라 클라이언트

  클라이언트는 무료

미디어플레이어

• IINA 인이니아

xcode에서 git remote에서 clone을 하려는데 username does not match previous request (-1) 라는 에러가 계속되었다.

이유는 알겠는데 정확한 해결책을 찾지 못했다. 그러나 임시 방편으로 가능한 방법을 기록해 두겠다.

1. 추측되는 이유는 xcode에서 ~/.ssh/id_ed25519 파일로 인증을 하지 못하고 있어서 그런것 같다.
2. 강제로 개인키을 지정해 주어야겠는데 xcode에서는 어떻게 해야 할지 ...
3. 결국 다음 방법을 사용했다.

1. 터미널에서 ~/.ssh 폴더를 임시로 ~/ssh 로 이름을 변경해두었다.

-> xcode에서는 .ssh폴더를 찾지 못하게 하기 위해서임.

1. xcode에서 url을 기반으로 clone을 한다. ssh://user@server.url:22/path을 주소창에 지정한다.
2. 가져오기clone를 시도한다. (위 1번을 해두었기 때문에 .ssh폴더를 찾지 못해 결국 id/password 방식으로 하려한다)
3. 터미널에서 ~/ssh를 다시 ~/.ssh로 변경한다.
4. xcode에서 id/password방식에서 개인키 방식으로 변경하고 아래의 선택버튼으로 ~/.ssh/id_ed25519를 선택해 개인키를 강제로 지정한다.

이 방법으로 해결은 되었는데 더 좋은 방법이 있으면 지식을 나누어 주었으면 감사하겠다.

kotlin compose 상태에서 변수의 감시는 중요하다.

1. 함수를 이용하는 법

가장 간단하며 stream 이 아니기 때문에 suspend 상태에서 호출할 필요가 없다.

2. Cold Stream 를 이용하는법 -> 구독이 있는경우만 값을 방출

Cold Stream : 특정 시점에서만 데이터를 처리하거나, 값의 비교가 필요할 때 호출하는 방식에 적합합니다.

flow

3. Hot Stream : 구독이 없는 경우에도 방출

Hot Stream을 사용하여 값을 감시하는 방법은 StateFlow 또는 SharedFlow를 활용하는 것입니다. 이전에 설명했던 내용과 관련해, Hot Stream은 데이터 소비자가 없어도 값을 방출하며, 이를 통해 실시간 데이터 감시가 가능합니다.

StateFlow , SharedFlow

   // Viewmodel
private val _orgUser = MutableStateFlow(PersonEntity())

private val _user = MutableStateFlow(PersonEntity())
val user: StateFlow<PersonEntity> get() = _user

fun initInfoVM(personEntity: PersonEntity) {
    _user.value = personEntity
    _orgUser.value = personEntity
  }


fun isModified(): Boolean {
    return _user.value != _orgUser.value
  }

val isModifiedFlow = combine(_orgUser, _user) { orgUser, user ->
    orgUser != user // 두 값이 다르면 true, 같으면 false
  }.distinctUntilChanged() // 중복 방지 (값이 변경될 때만 방출)

  // StateFlow로 변경 상태를 감지
val isModified: StateFlow<Boolean> = combine(_orgUser, _user) { orgUser, user ->
    orgUser != user
  }.stateIn(
    scope = CoroutineScope(Dispatchers.Default), // CoroutineScope 필요
    started = SharingStarted.WhileSubscribed(5000L), // 구독 중일 때만 활성화
    initialValue = false // 초기값 설정
  )

compose 내에서 호출법

//1번의 경우 if (vm.isModified()) 함수로 호출
//2번의 경우 
val isModifyed = vm.isModifiedFlow.collectAsState(false) // 로 감시

.gitignore 이 적용되지 않는 경우가 있다. 그전 캐쉬를 지우고 다시 커밋 하는 방법이다.

git rm -r --cached .
git add .
git commit -m "fix .gitignore a untracked files apply."

원래 맥에서는 문장의 시작으로 이동: ⌘ + ← 이고 문장의 끝으로 이동: ⌘ + → 이다. Home과 End 키를 문장 이동 기능으로 사용할 수 있도록 매핑을 변경하는 방법입니다.

1. 터미널 열기: 응용 프로그램 > 유틸리티 > 터미널.
2. KeyBindings 폴더 만들기:

   cd ~/Library
   mkdir KeyBindings
   cd KeyBindings

3. DefaultKeyBinding.dict 파일 생성:

   vi DefaultKeyBinding.dict

4. 아래 내용 입력:

   /* Remap Home / End keys to be correct */
   "\UF729" = "moveToBeginningOfLine:"; /* Home */
   "\UF72B" = "moveToEndOfLine:"; /* End */
   "$\UF729" = "moveToBeginningOfLineAndModifySelection:"; /* Shift + Home */
   "$\UF72B" = "moveToEndOfLineAndModifySelection:"; /* Shift + End */

5. 파일 저장 후 종료: esc, :, wq, enter 입력.
6. 재부팅 이나 재 로그인: 설정이 적용되도록 시스템을 재부팅합니다. 이렇게 하면 Home과 End 키가 문장 내에서의 이동으로 작동하게 됩니다.

settings.gradle.kts 설정

dependencyResolutionManagement {
  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
  repositories {
    google()
    mavenCentral()
    maven { url=uri("https://jitpack.io") }
    maven { url=uri ("https://oss.sonatype.org/content/repositories/snapshots/") }
  }
}

maven { url=uri ("https://oss.sonatype.org/content/repositories/snapshots/") }를 추가

libs.versions.toml 에서

[versions]
lottieCompose = "6.6.0"
[libraries]
lottie-compose = { module = "com.airbnb.android:lottie-compose", version.ref = "lottieCompose" }

build.gradle.kts(모듈단위)

dependencies {
...
  // lottie
  implementation (libs.lottie.compose)
  }

사용

// compose
// 선언
val composition by rememberLottieComposition(
    LottieCompositionSpec.Url("https://lottie.host/4add9811-6ad1-4021-9a41-b72f1f9e014a/eqSh7vm4jN.lottie")
  )
  val lottieAnimatable = rememberLottieAnimatable()
  LaunchedEffect(composition) {
    lottieAnimatable.animate(
      composition = composition,
      iterations = LottieConstants.IterateForever
    )
  }

// 적용
LottieAnimation(
      composition = composition,
      progress = lottieAnimatable.progress,
      modifier = Modifier.fillMaxSize()
    )

// stop
GoogleAuthButton(signInVm) { auth: FirebaseAuth ->
        CoroutineScope(Dispatchers.Main).launch {
          lottieAnimatable.snapTo(progress = 0f)
        }
        doSigned(auth)
      }// GoogleAuthButton

중요 나갈때 stop 하지 않으면 scope 내에서 악영향을 줌.

이런 에러가 나면 메니페스토에 아래와 같이 수정하면 됨.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          xmlns:tools="http://schemas.android.com/tools">
    <application>
        <property
            android:name="android.adservices.AD_SERVICES_CONFIG"
            android:resource="@xml/gma_ad_services_config"
            tools:replace="android:resource" />
    </application>
</manifest>

아마 아직도 sqlite 만을 사용하는 개발자가 있을지 모르겠다. 나는 sqlite 에서 room 으로 옮겨온지가 꽤 지나서 sqlite는 이제 가물거린다. 언젠가는 room 설정도 가물거릴까 걱정하는 마음에 현제 사용하는 설정을 기록해 두려한다.

libs.versions.toml

[versions]
room = "2.6.1"
[libraries]
androidx-room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" }
androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }

build.gradle.kts(:app)

plugins {
//...
    alias(libs.plugins.ksp)
  // Existing plugins
  kotlin("plugin.serialization") version "2.0.21"
}
android{
ksp {
    arg(RoomSchemaArgProvider(File(projectDir, "schemas")))
  }
}
dependencies {
  //room database
  // https://developer.android.com/jetpack/androidx/releases/room?hl=ko
  implementation(libs.androidx.room.runtime)
  ksp(libs.androidx.room.compiler)
  implementation(libs.androidx.room.ktx)
}

class RoomSchemaArgProvider(
  @get:InputDirectory
  @get:PathSensitive(PathSensitivity.RELATIVE)
  val schemaDir: File
) : CommandLineArgumentProvider {
  @Suppress("RETURN_TYPE_MISMATCH_ON_OVERRIDE") // Kotlin 의 Iterable 와 override 한 java 의 Iterable를 다른것으로 인식하는 버그 수정
  override fun asArguments(): Iterable<String> {
    return listOf("room.schemaLocation=${schemaDir.path}") // ksp
  }
}

Database 객체설정

@TypeConverters(Converters::class)
@Database(
  version = 1,
  entities = [
    LunaInfoEntity::class, SpcdEntity::class, ScheduleEntity::class, ShiftEntity::class,
    ShiftPatternEntity::class,ShiftAddonEntity::class,
    UserEntity::class,
             ],
  exportSchema = false // Todo !!! 배포시 true 로 변경
)

abstract class EodeunCalendarMemo : RoomDatabase() {
  companion object {
    @Volatile  // 중요 정보로 Ram 을 이용함
    private var INSTANCE: EodeunCalendarMemo? = null

    /**
     * Get instance
     * if the INSTANCE is not null, then return it,
     * if it is, then create the database and save in instance variable then return it.
     *
     * @param context
     * @return
     */
    fun getInstance(context: Context): EodeunCalendarMemo {
      return INSTANCE ?: synchronized(this) {
        val instance = Room.databaseBuilder(
          context.applicationContext, EodeunCalendarMemo::class.java, "EodeunCalendarMemo.db"
        ).fallbackToDestructiveMigration() // todo !!! 배포시 삭제. 스키마 관리 포기 하고 강제로 진행
          .build()
        INSTANCE = instance
        instance // return instance
      } //
    } // fun
  } // companion object

  abstract fun lunaInfoDao(): LunaInfoDao
  abstract fun spcdDao(): SpcdDao
  abstract fun scheduleDao(): ScheduleDao
  abstract fun shiftDao(): ShiftDao
  abstract fun shiftPatternDao(): ShiftPatternDao
  abstract fun userDao(): UserDao
  abstract fun shiftAddOnDao(): ShiftAddonDao
}

convertor

Room은 Int,String,Long 같은 프라임타입만 지원하기에 저장시 변환해서 저장해야 한다.

Room에서 지원하는 Type

• NULL
• INTEGER (Int, Long)
• REAL (Float, Double)
• TEXT (String)
• BLOB (ByteArray)

class Converters {

  @TypeConverter
  fun intToTermTime(value: Int): TermTime {
    return TermTime(value)
  }

  @TypeConverter
  fun termTimeToInt(value: TermTime): Int {
    return value.toInt()
  }

  @TypeConverter
  fun uLongToLong(value:ULong):Long = value.toLong()

  @TypeConverter
  fun longToULong(value:Long):ULong = value.toULong()

  @TypeConverter
  fun listStringToString(value: List<String>): String = Gson().toJson(value)

  @TypeConverter
  fun stringToShiftEntity(value: String?): ShiftEntity? {
    return value?.let { Gson().fromJson(it, ShiftEntity::class.java) }
  }

  @TypeConverter
  fun shiftEntityToString(value: ShiftEntity?): String? {
    return value?.let { Gson().toJson(it) }
  }

  @TypeConverter
  fun stringToShiftEvent(value: String?): ShiftEvent? {
    return value?.let { Gson().fromJson(it, ShiftEvent::class.java) }
  }

  @TypeConverter
  fun shiftEntityToString(value: ShiftEvent?): String? {
    return value?.let { Gson().toJson(it) }
  } // shiftEntityToString

  @TypeConverter
  fun shiftEventListToString(value: List<ShiftEvent>): String {
    return Gson().toJson(value)
  } // List<ShiftEvent> -> String

  @TypeConverter
  fun stringToShiftEventList(value: String): List<ShiftEvent> {
    return Gson().fromJson(
      value, object : TypeToken<List<ShiftEvent>>() {}.type
    ) // return Gson().fromJson(value, Array<ShiftEvent>::class.java).toList() // Array -> List 로 기능은 같은데 메모리를 약간 더 씀
  } // String -> List<ShiftEvent>

  @TypeConverter
  fun shiftPatternToString(value: ShiftPattern?): String? {
    return value?.let { Gson().toJson(it) }
  } // ShiftPattern -> String

  @TypeConverter
  fun stringToShiftPattern(value: String?): ShiftPattern? {
    return value?.let { Gson().fromJson(it, ShiftPattern::class.java) }
  }

  @TypeConverter
  fun workHistoryItemListToString(value: List<WorkHistoryItem>): String? {
    return value.let { Gson().toJson(it) }
  }

  @TypeConverter
  fun stringToWorkHistoryItemList(value: String?): List<WorkHistoryItem>? {
    return Gson().fromJson(
      value, object : TypeToken<List<WorkHistoryItem>>() {}.type
    )
  }
}

@Entity

Table 을 @Entity(tableName="String")으로 저장한다.

@Entity(tableName = "luna_info_table")
data class LunaInfoEntity(
  @PrimaryKey(autoGenerate = true)
  val rowId: Long = 0L, // 값이 0 이면 자동 증가
  // 양력 epoch 값
  val epoch: Long = 0L,
  // 음력정보
  val lunLeapmonth: Boolean = false, // 음력 평달 여부
  val lunYear: Int = 0,
  val lunMonth: Int = 0,
  val lunDay: Int = 0,
  val solLeapyear: Boolean = false,
  //  val solYear: Int = 0,
  //  val solMonth: Int = 0,
  //  val solDay: Int = 0,
  val lunIljin: String = "",
  val lunNday: Int = 0,
  val lunSecha: String = "",
  val lunWolgeon: String = "",
  val solJd: Long = 0L,
  //  val solWeek: String = ""
) {
  fun toLog(): String {
    val solDate = LocalDate.ofEpochDay(epoch)
    return "solYMD:${solDate.year}.${solDate.monthValue}.${solDate.dayOfMonth}.(${solDate.dayOfWeek}요일[${if (solLeapyear) "윤" else "평"}년])는 " +
            "lunYMD:${lunYear}.${lunMonth}.${lunDay}.(${if (lunLeapmonth) "윤" else "평"}달) (lunIljin:${lunIljin}/lunSecha:${lunSecha}/lunWolgeon:${lunWolgeon})"
  }

  fun toLunaShort():String{
    return "${lunMonth}.${lunDay}."
  }

  fun toLabel(): String {
    return " ${lunYear}년 (${if (lunLeapmonth) "윤" else "평"}) ${lunMonth}월 ${lunDay}일"
  }

  fun toGanJi(): String {
    return "${lunSecha}년 ${lunWolgeon}월 ${lunIljin}일"
  }
}

@Dao

DataAccessObject 는 Interface로 선언한다.

@Dao
interface LunaInfoDao {

  @Insert(onConflict = OnConflictStrategy.REPLACE)
  suspend fun insert(lunaInfoEntity: LunaInfoEntity): Long

  @Query("SELECT EXISTS (SELECT * FROM  luna_info_table WHERE epoch  = :epoch) ")
  suspend fun isExists(epoch:DateLong): Boolean

  @Query("SELECT * FROM  luna_info_table WHERE epoch = :epoch ")
  fun readFlow(epoch:DateLong): Flow<LunaInfoEntity?>

  @Query("SELECT * FROM  luna_info_table WHERE epoch = :dateLong ")
  suspend fun read(dateLong: DateLong): LunaInfoEntity?

  @Query("SELECT * FROM  luna_info_table WHERE epoch = :epoch ")
  fun fetch(epoch:DateLong): Flow<LunaInfoEntity?>

  @Query("SELECT * FROM luna_info_table ")
  fun fetchAll(): Flow<List<LunaInfoEntity>>
}

Repository

DB 는 Repository 를 경유해서 접근한다. repository 를 interface로 하여 구현체를 별도로 관리한다.

interface LunaRepo {
  suspend fun isExist(dateLong: DateLong): Boolean
  fun fetchFlow(dateLong: DateLong): Flow<LunaInfoEntity?>
  suspend fun isExistMonth(year: Int, month: Int)
}

Repo 구현체 실제처리를 구현하고 간단한 처리를 담당해서 상단의 Viewmodel에서 처리하도록 돕니다.

class LunaRepoImpl @Inject constructor(
  private val lunaDb: LunaDBRepo
) : LunaRepo {
  override suspend fun isExist(dateLong: DateLong): Boolean {
    return lunaDb.isExist(dateLong)
  }

  override fun fetchFlow(dateLong: DateLong): Flow<LunaInfoEntity?> {
    return lunaDb.fetchFlow(dateLong)
  }

  private val _requestedLunaYearMonths = mutableListOf<Int>()

  override suspend fun isExistMonth(year: Int, month: Int) {
    val seed = year * 12 + month
    if (_requestedLunaYearMonths.contains(seed)) return //
    _requestedLunaYearMonths.add(seed)
    if (lunaDb.isExist(
        LocalDate.of(year, month, 1).toEpochDay()
      )
    ) return // Api로 부터 holiday 를 가져 오도록 함
    try {
      DataGoKr.getLunCalInfo(year, month).response?.body?.items?.item?.forEach { it: LunaItem? ->
        it?.let { lunaDb.insert(it.toEntity()) }
      } //forEach
    } catch (e: Exception) {
      Log.e("Jim", "${e.message}")
    } //try-catch
  } //
}

Injection

코드주입을 위해 Hilt를 사용하게 되는데 그 주입설정이다.

@InstallIn(SingletonComponent::class)
@Module
object Injections {

  //   DB 와 관련된 인젝션들
  @Singleton
  @Provides
  fun providesAppDB(@ApplicationContext context: Context): EodeunCalendarMemo {
    return EodeunCalendarMemo.getInstance(context = context)
  }

  /* Dao 와 관련된 인젝션들 */
  @Singleton
  @Provides
  fun provideLunaInfoDao(db: EodeunCalendarMemo): LunaInfoDao {
    return db.lunaInfoDao()
  }

  @Singleton
  @Provides
  fun provideSpcdDao(db: EodeunCalendarMemo): SpcdDao {
    return db.spcdDao()
  }

  @Singleton
  @Provides
  fun provideScheduleDao(db: EodeunCalendarMemo): ScheduleDao {
    return db.scheduleDao()
  }

  @Singleton
  @Provides
  fun provideShiftDao(db: EodeunCalendarMemo): ShiftDao {
    return db.shiftDao()
  }

  @Singleton
  @Provides
  fun provideShiftPatternDao(db: EodeunCalendarMemo): ShiftPatternDao {
    return db.shiftPatternDao()
  }

  @Singleton
  @Provides
  fun provideShiftAddonDao(db: EodeunCalendarMemo): ShiftAddonDao {
    return db.shiftAddOnDao()
  }

  @Singleton
  @Provides
  fun provideUserDao(db: EodeunCalendarMemo): UserDao {
    return db.userDao()
  }

  /**
  Repository 주입
   */

  // It is DB repository
  @Singleton
  @Provides
  fun provideLunaInfoRepository(dao: LunaInfoDao): LunaDBRepo {
    return LunaDBRepoImpl(dao)
  } // LunaDb

  // It is not DB repository (over DB)
  @Singleton
  @Provides
  fun provideLunaRepository(lunaDBRepo: LunaDBRepo): LunaRepo {
    return LunaRepoImpl(lunaDBRepo)
  } // Luna

  // it is DB repository
  @Singleton
  @Provides
  fun provideSpcdRepository(dao: SpcdDao): SpcdDBRepo {
    return SpcdDBRepoImpl(dao)
  }  // SpcdDB

  // It is not DB repository (over DB)
  @Singleton
  @Provides
  fun provideHolidayRepository(spcdRepo: SpcdDBRepo): SpcdRepo {
    return SpcdRepoImpl(spcdRepo)
  } //Spcd

  @Singleton
  @Provides
  fun provideShiftRepository(shiftDao: ShiftDao): ShiftRepo {
    return ShiftRepoImpl(shiftDao)
  }

  @Singleton
  @Provides
  fun provideScheduleRepository(scheduleDao: ScheduleDao): ScheduleRepo {
    return ScheduleRepoImpl(scheduleDao)
  }

  @Singleton
  @Provides
  fun provideShiftPatternRepository(dao: ShiftPatternDao): ShiftPatternRepo {
    return ShiftPatternRepoImpl(dao)
  }

  @Singleton
  @Provides
  fun provideShiftAddonRepository(dao: ShiftAddonDao): ShiftAddonRepo {
    return ShiftAddonRepoImpl(dao)
  }

  @Singleton
  @Provides
  fun provideUserRepository(dao: UserDao): UserRepo {
    return UserRepoImpl(dao)
  }

  /**
   * Viewmodel 주입
   */

  @Singleton
  @Provides
  fun provideCoreViewmodel(
    spcdRepo: SpcdRepo,
    lunaRepo: LunaRepo,
    userRepo: UserRepo,
    scheduleRepo: ScheduleRepo
  ): CoreVM {
    return CoreVM(spcdRepo, lunaRepo, userRepo, scheduleRepo)
  }
}

객체의 비교는 생성된 객체 instance 의 비교로 되기 때문에 객체 값을 개별로 비교하게 되는 번거러움이 있다.

class TermTime(private val value: Int=1440/*00:00~24:00*/) {

  /**
   * Equals
   * ```
   * val a = TermTime(1)
   * val b = TermTime(1)
   * assert(a == b)  // 이제 true가 됩니다.
   * ```
   *
   * @param other
   * @return
   */
  override fun equals(other: Any?): Boolean {
    if (this === other) return true
    if (other !is TermTime) return false
    return value == other.value
  }

  override fun hashCode(): Int {
    return value
  }

이렇게 equals(other: Any?)를 override 해야 한다 other의 Any? 의 자료형에 유의하자 특정자료형으로 선언하면 새로운 function 으로 인식한다.

Execution failed for task ':app:mergeDebugAndroidTestJavaResource'.

A failure occurred while executing com.android.build.gradle.internal.tasks.MergeJavaResWorkAction

6 files found with path 'META-INF/LICENSE.md'.
Adding a packaging block may help, please refer to
https://developer.android.com/reference/tools/gradle-api/8.7/com/android/build/api/dsl/Packaging
for more information

위와 같은 에러가 발생할때

해결하는 법

// build.gradle.kts(Module :app)
android{
packaging {
    resources {
      excludes += "/META-INF/{AL2.0,LGPL2.1}"
      excludes += "META-INF/LICENSE.md" // <- 추가 
      excludes += "META-INF/LICENSE-notice.md" <- 추가
    }
   }
}

settings.gradle.kts 에 maven { url 'https://jitpack.io' } 추가하는 법

pluginManagement {
  repositories {
    google {
      content {
        includeGroupByRegex("com\\.android.*")
        includeGroupByRegex("com\\.google.*")
        includeGroupByRegex("androidx.*")
      }
    }
    mavenCentral()
    gradlePluginPortal()
  }
  resolutionStrategy {
    eachPlugin {
      if (requested.id.id == "com.google.android.gms.oss-licenses-plugin") {
        useModule("com.google.android.gms:oss-licenses-plugin:${requested.version}")
      } // if
    } //eachPlugin
  }//repositories
}//plugins

dependencyResolutionManagement {
  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
  repositories {
    google()
    mavenCentral()
    maven { url=uri("https://jitpack.io") }
  }
}

rootProject.name = "EodunCalendarMemo"
include(":app")

하면 20 인 경우 2 하고 0 이 다움즐에 나오는 버그가 생긴다. 그럴 때softWrap = false를 사용하면 2줄로 넘어 가는 문제를 방지 할 수 있다. softWrap는 기본값이 true 이다.

Text(
    text = "$date",
    style = MaterialTheme.typography.displaySmall.copy(color = color),
    modifier = Modifier.sharedElement(
      state = rememberSharedContentState(key = "date.id${dateId}"),
      animatedVisibilityScope = animatedVisibilityScope
    )// sharedElement
    .softWrap = false
  ) // text

화면을 캡쳐해서 동영상을 첨부할 때 간단하게 사용하는 프로그램을 소개한다.

스크린toGif 홈페이지로 사용법을

최근 1시간 이내 만 보기

# 1시간 이내에 발생한 "error" 메시지 출력
sudo grep -i error /var/log/* | grep -E "$(date -d '-1 hour' +%Y-%m-%d\T%H:%M:%S)..$(date +%Y-%m-%d\T%H:%M:%S)"

# 다른거
sudo find /var/log -type f -mtime -1 -exec grep -i error {} \;

• room db에서는 목록에 정의된 Int, Long, String, Boolean ... 등 자료형이 아니면 typeconverter 가 가능해야 하는데 그런게 없다면 이런 에러가 발생하는데 발생위치를 바로 지적하지 못하기 때문에 좀 찾아야 한다. 내경우는 ULong 과 Long 으로 인해서 발생했다.

  //.entity
  @Entity(tableName = "date_box")
  data class DateBoxEntity(
  @PrimaryKey(autoGenerate = false)
  val dateLong: Long,
  var color: ULong,
  var holiday: String,
  var luna: String,
  var memo: String,
  var work: String,
  )

  위 소스에서 var color: ULong,의 ULong 은 Room 에서 알지못하는 자료형이라 에러가 나서 ULong을 Long으로 변환하고 적용시 color.value = Color(value.color.toULong())이렇게 변환토록 했다. 아니면 TypeConvetor 로 ULong 과 Long을 변환토록 해봤는데 Error가 KSP가 먼저 접근해서 인지 에러가 고쳐지지 않았다.

//.converter

@TypeConverter
fun longToULong(value: Long): ULong = value.toULong()

@TypeConverter
fun uLongToLong(value: ULong): Long = value.toLong()

//.entity

@Entity
data class test(
@Primary
val rid : Long

//.dao
@Insert 

3. 해결책 : insert 에 onConflict = OnConflictStrategy.REPLACE 를 추가한다.

   //.entity
   

@Entity data class test( @PrimaryKey(autoGenerate = false) val rid : Long

```kotlin
//.dao
  @Insert(onConflict = OnConflictStrategy.REPLACE)
  suspend fun insert(entity: DateBoxEntity): Long

Android 개발을 하던중 Log.d 로 로그를 남기는 경우, release버젼에서는 log 코드가 남는것을 원하지 않를 때가 있다. 이럴때 PorGuard 의 설정으로 Log.d 의 내용을 삭제 하는 방법이 있다.

• release 버젼과 debug 버젼에 각각 다른 proguard-rules 을 적용한다.

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

• 다음 내용을 proguard-rules-release.pro 에 추가 하낟. ```java

• assumenosideeffects class android.util.Log { public static boolean isLoggable(java.lang.String, int); public static int v(...); public static int i(...); public static int w(...); public static int d(...); public static int e(...); }

음... OK