900 lines
37 KiB
Kotlin
900 lines
37 KiB
Kotlin
package com.example.shiftalarm
|
|
|
|
import android.Manifest
|
|
import android.app.AlarmManager
|
|
import android.app.PendingIntent
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.content.pm.PackageManager
|
|
import android.os.Build
|
|
import android.os.Bundle
|
|
import android.view.GestureDetector
|
|
import android.view.MotionEvent
|
|
import android.view.animation.AccelerateDecelerateInterpolator
|
|
import android.widget.Toast
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.core.app.ActivityCompat
|
|
import androidx.core.content.ContextCompat
|
|
import androidx.work.ExistingPeriodicWorkPolicy
|
|
import androidx.work.PeriodicWorkRequestBuilder
|
|
import androidx.work.WorkManager
|
|
import androidx.lifecycle.lifecycleScope
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.withContext
|
|
import androidx.activity.enableEdgeToEdge
|
|
import androidx.core.view.ViewCompat
|
|
import androidx.core.view.WindowInsetsCompat
|
|
import com.example.shiftalarm.databinding.ActivityMainBinding
|
|
import java.time.LocalDate
|
|
import java.time.YearMonth
|
|
import java.time.format.DateTimeFormatter
|
|
import java.util.concurrent.TimeUnit
|
|
import androidx.recyclerview.widget.GridLayoutManager
|
|
import android.graphics.Bitmap
|
|
import android.graphics.Canvas
|
|
import android.util.Log
|
|
import kotlin.math.abs
|
|
|
|
class MainActivity : AppCompatActivity() {
|
|
|
|
private lateinit var binding: ActivityMainBinding
|
|
private val PREFS_NAME = "ShiftAlarmPrefs"
|
|
private val KEY_TEAM = "selected_team"
|
|
private var currentViewMonth: YearMonth = YearMonth.now(ShiftCalculator.SEOUL_ZONE)
|
|
private var currentViewTeam: String = "A"
|
|
private lateinit var gestureDetector: GestureDetector
|
|
private var calendarAdapter: CalendarAdapter? = null
|
|
private var isAnimatingMonth = false
|
|
|
|
override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {
|
|
super.onConfigurationChanged(newConfig)
|
|
// Smooth transition for theme change
|
|
finish()
|
|
startActivity(Intent(this, javaClass))
|
|
overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out)
|
|
}
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
enableEdgeToEdge()
|
|
super.onCreate(savedInstanceState)
|
|
binding = ActivityMainBinding.inflate(layoutInflater)
|
|
setContentView(binding.root)
|
|
|
|
ViewCompat.setOnApplyWindowInsetsListener(binding.root) { v, insets ->
|
|
val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
|
|
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
|
|
insets
|
|
}
|
|
|
|
setupCalendar()
|
|
setupWorker()
|
|
setupSwipeGesture()
|
|
AppUpdateManager.checkUpdate(this, silent = true)
|
|
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
currentViewTeam = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
|
|
// Default to Shift Calendar mode (checkbox unchecked)
|
|
binding.cbShowHolidays.isChecked = false
|
|
|
|
binding.btnSettings.setOnClickListener {
|
|
startActivity(Intent(this, SettingsActivity::class.java))
|
|
}
|
|
|
|
binding.prevMonth.setOnClickListener {
|
|
animateMonthTransition(-1)
|
|
}
|
|
|
|
binding.monthTitle.setOnClickListener {
|
|
showMonthYearPicker()
|
|
}
|
|
|
|
binding.nextMonth.setOnClickListener {
|
|
animateMonthTransition(1)
|
|
}
|
|
|
|
binding.btnToday.setOnClickListener {
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
currentViewTeam = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
currentViewMonth = YearMonth.now(ShiftCalculator.SEOUL_ZONE)
|
|
updateCalendar()
|
|
}
|
|
|
|
binding.cbShowHolidays.setOnCheckedChangeListener { _, _ ->
|
|
updateCalendar()
|
|
}
|
|
|
|
binding.alarmInfoBar.setOnClickListener {
|
|
val intent = Intent(this, SettingsActivity::class.java)
|
|
intent.putExtra("TARGET_TAB", 1) // 1 is Alarm tab
|
|
startActivity(intent)
|
|
}
|
|
|
|
// Tide Location Cycle Logic
|
|
val tideLocations = listOf("군산", "변산", "여수", "태안")
|
|
binding.btnTideLocation.setOnClickListener {
|
|
val currentLoc = prefs.getString("selected_tide_location", "군산") ?: "군산"
|
|
val nextIndex = (tideLocations.indexOf(currentLoc) + 1) % tideLocations.size
|
|
val nextLoc = tideLocations[nextIndex]
|
|
|
|
prefs.edit().putString("selected_tide_location", nextLoc).apply()
|
|
binding.btnTideLocation.text = nextLoc
|
|
updateCalendar()
|
|
}
|
|
|
|
// setupWorker(), checkRoot() 등은 이미 호출됨
|
|
}
|
|
|
|
private fun updateTideButtonVisibility() {
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
val showTide = prefs.getBoolean("show_tide", false)
|
|
val currentLoc = prefs.getString("selected_tide_location", "군산") ?: "군산"
|
|
|
|
if (showTide) {
|
|
binding.btnTideLocation.visibility = android.view.View.VISIBLE
|
|
binding.btnTideLocation.text = currentLoc
|
|
} else {
|
|
binding.btnTideLocation.visibility = android.view.View.GONE
|
|
}
|
|
}
|
|
|
|
private fun setupSwipeGesture() {
|
|
gestureDetector = GestureDetector(this, object : GestureDetector.SimpleOnGestureListener() {
|
|
private val SWIPE_THRESHOLD = 100
|
|
private val SWIPE_VELOCITY_THRESHOLD = 100
|
|
|
|
override fun onDown(e: MotionEvent): Boolean {
|
|
return true
|
|
}
|
|
|
|
override fun onFling(
|
|
e1: MotionEvent?,
|
|
e2: MotionEvent,
|
|
velocityX: Float,
|
|
velocityY: Float
|
|
): Boolean {
|
|
if (e1 == null) return false
|
|
|
|
val diffX = e2.x - e1.x
|
|
val diffY = e2.y - e1.y
|
|
|
|
if (abs(diffX) > abs(diffY)) {
|
|
if (abs(diffX) > SWIPE_THRESHOLD && abs(velocityX) > SWIPE_VELOCITY_THRESHOLD) {
|
|
if (diffX > 0) {
|
|
// Swipe Right -> Previous Month
|
|
animateMonthTransition(-1)
|
|
} else {
|
|
// Swipe Left -> Next Month
|
|
animateMonthTransition(1)
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
})
|
|
|
|
binding.calendarGrid.addOnItemTouchListener(object : androidx.recyclerview.widget.RecyclerView.OnItemTouchListener {
|
|
override fun onInterceptTouchEvent(rv: androidx.recyclerview.widget.RecyclerView, e: MotionEvent): Boolean {
|
|
gestureDetector.onTouchEvent(e)
|
|
return false
|
|
}
|
|
override fun onTouchEvent(rv: androidx.recyclerview.widget.RecyclerView, e: MotionEvent) {}
|
|
override fun onRequestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {}
|
|
})
|
|
|
|
binding.calendarContainer.setOnTouchListener { _, event ->
|
|
gestureDetector.onTouchEvent(event)
|
|
true
|
|
}
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
currentViewTeam = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
|
|
updateTideButtonVisibility()
|
|
updateCalendar()
|
|
|
|
// 통합 권한 체크: 권한 플로우가 진행 중이 아닐 때만 실행 (모달 루프 방지)
|
|
if (!AlarmPermissionUtil.isPermissionFlowActive) {
|
|
AlarmPermissionUtil.checkAndRequestAllPermissions(this)
|
|
}
|
|
|
|
// 설정 변경 시 즉시 반영을 위한 강제 동기화 (30일 스케줄링)
|
|
lifecycleScope.launch {
|
|
syncAllAlarms(this@MainActivity)
|
|
}
|
|
|
|
// 연차 정보 업데이트
|
|
lifecycleScope.launch {
|
|
val repo = ShiftRepository(this@MainActivity)
|
|
val annualLeave = repo.getAnnualLeave()
|
|
annualLeave?.let {
|
|
binding.tvAnnualLeave.text = "연차: ${formatRemainingDays(it.remainingDays)}"
|
|
} ?: run {
|
|
binding.tvAnnualLeave.text = "연차: --"
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun showMonthYearPicker() {
|
|
val dialogView = layoutInflater.inflate(R.layout.dialog_month_year_picker, null)
|
|
val yearPicker = dialogView.findViewById<android.widget.NumberPicker>(R.id.yearPicker)
|
|
val monthPicker = dialogView.findViewById<android.widget.NumberPicker>(R.id.monthPicker)
|
|
|
|
val currentYear = currentViewMonth.year
|
|
val currentMonth = currentViewMonth.monthValue
|
|
|
|
yearPicker.minValue = 2010
|
|
yearPicker.maxValue = 2050
|
|
yearPicker.value = currentYear
|
|
yearPicker.wrapSelectorWheel = false
|
|
|
|
monthPicker.minValue = 1
|
|
monthPicker.maxValue = 12
|
|
monthPicker.value = currentMonth
|
|
monthPicker.displayedValues = arrayOf("1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월")
|
|
|
|
val dialog = androidx.appcompat.app.AlertDialog.Builder(this, R.style.OneUI8_Dialog)
|
|
.setView(dialogView)
|
|
.create()
|
|
|
|
// Internal button click handlers
|
|
dialogView.findViewById<android.widget.Button>(R.id.btnCancel).setOnClickListener {
|
|
dialog.dismiss()
|
|
}
|
|
dialogView.findViewById<android.widget.Button>(R.id.btnConfirm).setOnClickListener {
|
|
currentViewMonth = YearMonth.of(yearPicker.value, monthPicker.value)
|
|
updateCalendar()
|
|
dialog.dismiss()
|
|
}
|
|
|
|
dialog.show()
|
|
|
|
// 90% Screen Width for One UI 8.0 feel
|
|
val width = (resources.displayMetrics.widthPixels * 0.9).toInt()
|
|
dialog.window?.setLayout(width, android.view.ViewGroup.LayoutParams.WRAP_CONTENT)
|
|
dialog.window?.setDimAmount(0.6f)
|
|
}
|
|
|
|
private fun dpToPx(dp: Float): Int {
|
|
return (dp * resources.displayMetrics.density).toInt()
|
|
}
|
|
|
|
private fun setupCalendar() {
|
|
binding.calendarGrid.layoutManager = GridLayoutManager(this, 7)
|
|
binding.calendarGrid.itemAnimator = null
|
|
updateCalendar()
|
|
}
|
|
|
|
private suspend fun loadCalendarDataForMonth(targetMonth: YearMonth) {
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
val selectedTeam = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
val factory = prefs.getString("selected_factory", "Jeonju") ?: "Jeonju"
|
|
val today = LocalDate.now(ShiftCalculator.SEOUL_ZONE)
|
|
|
|
val db = AppDatabase.getDatabase(this@MainActivity)
|
|
val dao = db.shiftDao()
|
|
val repo = ShiftRepository(this@MainActivity)
|
|
|
|
// 전체 사용자 알람 로드 (일원화된 Room DB 사용)
|
|
val allCustomAlarms = repo.getAllCustomAlarms()
|
|
|
|
// 디스플레이 업데이트
|
|
if (currentViewTeam == selectedTeam) {
|
|
val shiftForMyTeam = withContext(Dispatchers.IO) { repo.getShift(today, selectedTeam, factory) }
|
|
updateAlarmTimeDisplay(today, shiftForMyTeam, factory, allCustomAlarms)
|
|
binding.alarmTimeText.visibility = android.view.View.VISIBLE
|
|
} else {
|
|
binding.alarmTimeText.visibility = android.view.View.GONE
|
|
}
|
|
|
|
// Load overrides and memos for the month
|
|
val monthStr = targetMonth.toString()
|
|
val overrides = withContext(Dispatchers.IO) {
|
|
dao.getOverridesForMonth(factory, currentViewTeam, monthStr).associateBy { overrideItem -> overrideItem.date }
|
|
}
|
|
val memos = withContext(Dispatchers.IO) {
|
|
dao.getMemosForMonth(monthStr).associateBy { memoItem -> memoItem.date }
|
|
}
|
|
|
|
val days = generateDaysForMonthWithData(targetMonth, currentViewTeam, factory, overrides, memos)
|
|
|
|
val availableHeight = binding.calendarGrid.height
|
|
val calcRowHeight = if (availableHeight > 0) availableHeight / 5 else 0
|
|
|
|
if (calendarAdapter == null || binding.calendarGrid.adapter == null) {
|
|
val newAdapter = CalendarAdapter(days, object : CalendarAdapter.OnDayClickListener {
|
|
override fun onDayClick(date: LocalDate, currentShift: String) {
|
|
showDaySettingsDialog(date, currentShift)
|
|
}
|
|
}, binding.cbShowHolidays.isChecked)
|
|
if (calcRowHeight > 0) {
|
|
newAdapter.rowHeight = calcRowHeight
|
|
}
|
|
calendarAdapter = newAdapter
|
|
binding.calendarGrid.adapter = newAdapter
|
|
} else {
|
|
calendarAdapter?.let { ad ->
|
|
ad.days = days
|
|
ad.showHolidays = binding.cbShowHolidays.isChecked
|
|
if (calcRowHeight > 0) {
|
|
ad.rowHeight = calcRowHeight
|
|
}
|
|
ad.notifyDataSetChanged()
|
|
}
|
|
}
|
|
|
|
binding.monthTitle.text = targetMonth.format(DateTimeFormatter.ofPattern("yyyy년 MM월"))
|
|
|
|
if (calcRowHeight == 0) {
|
|
binding.calendarGrid.post {
|
|
val h = binding.calendarGrid.height
|
|
if (h > 0) {
|
|
val rH = h / 5
|
|
calendarAdapter?.let {
|
|
if (it.rowHeight != rH) {
|
|
it.rowHeight = rH
|
|
it.notifyDataSetChanged()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update Header Status Text with Permission Warning if needed
|
|
val shiftForViewingTeam = withContext(Dispatchers.IO) { repo.getShift(today, currentViewTeam, factory) }
|
|
val teamSuffix = if (currentViewTeam == selectedTeam) "" else " (${currentViewTeam}반)"
|
|
|
|
if (currentViewTeam == selectedTeam && !AlarmPermissionUtil.getExactAlarmStatus(this@MainActivity)) {
|
|
binding.todayStatusText.text = "⚠️ 정확한 알람 권한이 필요합니다 (설정 필요)"
|
|
binding.todayStatusText.setTextColor(androidx.core.content.ContextCompat.getColor(this@MainActivity, R.color.warning_red))
|
|
} else {
|
|
val prefix = "오늘의 근무: "
|
|
val fullText = "$prefix$shiftForViewingTeam$teamSuffix"
|
|
val spannable = android.text.SpannableStringBuilder(fullText)
|
|
|
|
val shiftColorRes = when (shiftForViewingTeam) {
|
|
"주간", "주" -> R.color.shift_ju
|
|
"석간", "석" -> R.color.shift_seok
|
|
"야간", "야" -> R.color.shift_ya
|
|
"주간 맞교대" -> R.color.shift_jumat
|
|
"야간 맞교대" -> R.color.shift_yamat
|
|
"휴무", "휴가" -> R.color.shift_off
|
|
"월차", "연차" -> R.color.secondary
|
|
"반월", "반년" -> R.color.shift_red
|
|
"교육" -> R.color.primary
|
|
else -> R.color.text_primary
|
|
}
|
|
val shiftColor = androidx.core.content.ContextCompat.getColor(this@MainActivity, shiftColorRes)
|
|
val startIndex = prefix.length
|
|
val endIndex = startIndex + shiftForViewingTeam.length
|
|
|
|
spannable.setSpan(
|
|
android.text.style.ForegroundColorSpan(shiftColor),
|
|
startIndex,
|
|
endIndex,
|
|
android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
|
|
)
|
|
spannable.setSpan(
|
|
android.text.style.StyleSpan(android.graphics.Typeface.BOLD),
|
|
startIndex,
|
|
endIndex,
|
|
android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
|
|
)
|
|
|
|
binding.todayStatusText.text = spannable
|
|
binding.todayStatusText.setTextColor(androidx.core.content.ContextCompat.getColor(this@MainActivity, R.color.text_secondary))
|
|
}
|
|
|
|
// Update Annual Leave display
|
|
val annualLeave = withContext(Dispatchers.IO) { repo.getAnnualLeave() }
|
|
annualLeave?.let {
|
|
binding.tvAnnualLeave.text = "연차: ${formatRemainingDays(it.remainingDays)}"
|
|
} ?: run {
|
|
binding.tvAnnualLeave.text = "연차: --"
|
|
}
|
|
|
|
// Update Shift Summary Chips (v2.2.0)
|
|
val juCount = days.count { it.date != null && (it.shift == "주간" || it.shift == "주") }
|
|
val seokCount = days.count { it.date != null && (it.shift == "석간" || it.shift == "석") }
|
|
val yaCount = days.count { it.date != null && (it.shift == "야간" || it.shift == "야") }
|
|
val monthlyOvertime = withContext(Dispatchers.IO) { repo.getMonthlyOvertimeHours(targetMonth) }
|
|
|
|
binding.chipJu.text = "주간 ${juCount}일"
|
|
binding.chipSeok.text = "석간 ${seokCount}일"
|
|
binding.chipYa.text = "야간 ${yaCount}일"
|
|
binding.chipOvertime.text = "연장 ${monthlyOvertime}h"
|
|
|
|
updateOtherTeamsLayout(today, factory, prefs)
|
|
}
|
|
|
|
private fun updateCalendar() {
|
|
lifecycleScope.launch {
|
|
loadCalendarDataForMonth(currentViewMonth)
|
|
}
|
|
}
|
|
|
|
private fun updateOtherTeamsLayout(today: LocalDate, factory: String, prefs: android.content.SharedPreferences) {
|
|
val teamColors = mapOf(
|
|
"A" to R.color.team_a_color,
|
|
"B" to R.color.team_b_color,
|
|
"C" to R.color.team_c_color,
|
|
"D" to R.color.team_d_color
|
|
)
|
|
val container = binding.otherTeamsContainer
|
|
container.removeAllViews()
|
|
|
|
val rowLayout = android.widget.LinearLayout(this).apply {
|
|
orientation = android.widget.LinearLayout.HORIZONTAL
|
|
layoutParams = android.widget.LinearLayout.LayoutParams(
|
|
android.widget.LinearLayout.LayoutParams.MATCH_PARENT,
|
|
android.widget.LinearLayout.LayoutParams.WRAP_CONTENT
|
|
)
|
|
}
|
|
|
|
val allTeams = if (factory == "Nonsan") listOf("A", "B", "C") else listOf("A", "B", "C", "D")
|
|
|
|
lifecycleScope.launch {
|
|
for (t in allTeams) {
|
|
val shift = ShiftCalculator.getShift(today, t, factory)
|
|
val shortShift = when(shift) {
|
|
"주간" -> "주"
|
|
"석간" -> "석"
|
|
"야간" -> "야"
|
|
"주간 맞교대" -> "주맞"
|
|
"야간 맞교대" -> "야맞"
|
|
"휴무", "휴가" -> "휴"
|
|
else -> shift.take(1)
|
|
}
|
|
|
|
val textView = android.widget.TextView(this@MainActivity).apply {
|
|
text = "${t}반 ($shortShift)"
|
|
setPadding(0, 24, 0, 24)
|
|
textSize = 12f
|
|
gravity = android.view.Gravity.CENTER
|
|
setTypeface(null, android.graphics.Typeface.BOLD)
|
|
|
|
if (currentViewTeam == t) {
|
|
setTextColor(android.graphics.Color.WHITE)
|
|
setBackgroundResource(R.drawable.bg_pill_rect_selected)
|
|
} else {
|
|
setTextColor(androidx.core.content.ContextCompat.getColor(context, teamColors[t]!!))
|
|
setBackgroundResource(R.drawable.bg_pill_rect_unselected)
|
|
}
|
|
|
|
layoutParams = android.widget.LinearLayout.LayoutParams(0, android.widget.LinearLayout.LayoutParams.WRAP_CONTENT, 1f).apply {
|
|
setMargins(4, 0, 4, 0)
|
|
}
|
|
|
|
setOnClickListener {
|
|
if (currentViewTeam != t) {
|
|
currentViewTeam = t
|
|
updateCalendar()
|
|
showCustomToast(context, "${t}반 근무표를 표시합니다.")
|
|
}
|
|
}
|
|
}
|
|
rowLayout.addView(textView)
|
|
}
|
|
container.addView(rowLayout)
|
|
}
|
|
}
|
|
|
|
private fun generateDaysForMonthWithData(
|
|
month: YearMonth,
|
|
team: String,
|
|
factory: String,
|
|
overrides: Map<String, ShiftOverride>,
|
|
memos: Map<String, DailyMemo>
|
|
): List<DayShift> {
|
|
val daysInMonth = month.lengthOfMonth()
|
|
val firstDayOfMonth = month.atDay(1).dayOfWeek.value % 7
|
|
val actualDayCount = firstDayOfMonth + daysInMonth
|
|
val targetCells = if (actualDayCount <= 35) 35 else 42
|
|
|
|
val dayList = mutableListOf<DayShift>()
|
|
|
|
for (i in 0 until firstDayOfMonth) {
|
|
dayList.add(DayShift(null, null))
|
|
}
|
|
|
|
for (day in 1..daysInMonth) {
|
|
val date = month.atDay(day)
|
|
val dateStr = date.toString()
|
|
|
|
val shift = overrides[dateStr]?.shift ?: ShiftCalculator.getShift(date, team, factory)
|
|
val memo = memos[dateStr]
|
|
val hasMemo = memo != null
|
|
val memoContent = memo?.content
|
|
|
|
dayList.add(DayShift(date, shift, hasMemo, memoContent))
|
|
}
|
|
|
|
while (dayList.size < targetCells) {
|
|
dayList.add(DayShift(null, null))
|
|
}
|
|
return dayList
|
|
}
|
|
|
|
private fun getAlarmsStrForDate(date: LocalDate, shift: String, allAlarms: List<CustomAlarm>): List<String> {
|
|
val alarmTimes = mutableListOf<String>()
|
|
val isOff = shift == "휴무" || shift == "휴가"
|
|
|
|
// 교육으로 변경된 경우 원래 근무의 알람을 표시
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
val matchShift = if (shift == "교육") {
|
|
val team = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
val factory = prefs.getString("selected_factory", "Jeonju") ?: "Jeonju"
|
|
ShiftCalculator.getShift(date, team, factory)
|
|
} else {
|
|
shift
|
|
}
|
|
|
|
for (alarm in allAlarms) {
|
|
if (alarm.isEnabled && (alarm.shiftType == "기타" || (!isOff && alarm.shiftType == matchShift))) {
|
|
if (!alarmTimes.contains(alarm.time)) {
|
|
alarmTimes.add(alarm.time)
|
|
}
|
|
}
|
|
}
|
|
|
|
alarmTimes.sort()
|
|
return alarmTimes
|
|
}
|
|
|
|
private fun updateAlarmTimeDisplay(date: LocalDate, shift: String, factory: String, allAlarms: List<CustomAlarm>) {
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
// 0. Check Master Switch
|
|
if (!ShiftAlarmDefaults.isMasterAlarmEnabled(prefs)) {
|
|
binding.alarmTimeText.text = "전체 알람 꺼짐"
|
|
binding.alarmTimeText.visibility = android.view.View.VISIBLE
|
|
binding.alarmTimeText.setTextColor(androidx.core.content.ContextCompat.getColor(this, R.color.shift_red))
|
|
binding.alarmTimeText.setTypeface(null, android.graphics.Typeface.BOLD)
|
|
return
|
|
}
|
|
|
|
val todayStr = getAlarmsStrForDate(date, shift, allAlarms).firstOrNull() ?: "없음"
|
|
val tomorrowDate = date.plusDays(1)
|
|
val repo = ShiftRepository(this)
|
|
|
|
lifecycleScope.launch(Dispatchers.IO) {
|
|
val tomorrowShiftFull = repo.getShift(tomorrowDate, currentViewTeam, factory)
|
|
val tomorrowAlarms = getAlarmsStrForDate(tomorrowDate, tomorrowShiftFull, allAlarms)
|
|
val tomorrowStr = tomorrowAlarms.firstOrNull() ?: "없음"
|
|
|
|
withContext(Dispatchers.Main) {
|
|
if (!ShiftAlarmDefaults.isMasterAlarmEnabled(prefs)) {
|
|
binding.alarmTimeText.text = "전체 알람 꺼짐"
|
|
binding.alarmTimeText.setTextColor(androidx.core.content.ContextCompat.getColor(this@MainActivity, R.color.shift_red))
|
|
return@withContext
|
|
}
|
|
|
|
val todayLabel = "오늘: $todayStr"
|
|
val tomorrowLabel = "내일: $tomorrowStr"
|
|
|
|
binding.alarmTimeText.text = "$todayLabel | $tomorrowLabel"
|
|
binding.alarmTimeText.visibility = android.view.View.VISIBLE
|
|
binding.alarmTimeText.setTypeface(null, android.graphics.Typeface.BOLD)
|
|
binding.alarmTimeText.setTextColor(androidx.core.content.ContextCompat.getColor(this@MainActivity, R.color.text_primary))
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun showDaySettingsDialog(date: LocalDate, currentShift: String) {
|
|
val dialogView = layoutInflater.inflate(R.layout.dialog_day_settings, null)
|
|
val dialog = androidx.appcompat.app.AlertDialog.Builder(this)
|
|
.setView(dialogView)
|
|
.create()
|
|
dialog.window?.setBackgroundDrawableResource(android.R.color.transparent)
|
|
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
val factory = prefs.getString("selected_factory", "Jeonju") ?: "Jeonju"
|
|
val team = prefs.getString(KEY_TEAM, "A") ?: "A"
|
|
|
|
// Set Title - One UI Style Header
|
|
val titleText = dialogView.findViewById<android.widget.TextView>(R.id.dialogTitle)
|
|
val subtitleText = dialogView.findViewById<android.widget.TextView>(R.id.dialogSubtitle)
|
|
|
|
subtitleText.text = if (date == LocalDate.now()) "오늘의 근무" else "${date.monthValue}월 ${date.dayOfMonth}일 근무"
|
|
titleText.text = "$currentShift"
|
|
|
|
// Button Handlers
|
|
val actionMap = mapOf(
|
|
R.id.btnJu to "주간",
|
|
R.id.btnJuMat to "주간 맞교대",
|
|
R.id.btnSeok to "석간",
|
|
R.id.btnYa to "야간",
|
|
R.id.btnYaMat to "야간 맞교대",
|
|
R.id.btnOff to "휴무",
|
|
R.id.btnWolcha to "월차",
|
|
R.id.btnYeoncha to "연차",
|
|
R.id.btnBanwol to "반월",
|
|
R.id.btnBannyeon to "반년",
|
|
R.id.btnEdu to "교육",
|
|
R.id.btnManual to "직접 입력",
|
|
R.id.btnReset to "원래대로"
|
|
)
|
|
|
|
fun applyStrokeStyle(viewId: Int, shiftType: String) {
|
|
val view = dialogView.findViewById<android.widget.TextView>(viewId)
|
|
val colorRes = when(shiftType) {
|
|
"주간" -> R.color.shift_ju
|
|
"석간" -> R.color.shift_seok
|
|
"야간" -> R.color.shift_ya
|
|
"주간 맞교대" -> R.color.shift_jumat
|
|
"야간 맞교대" -> R.color.shift_yamat
|
|
"휴무", "휴가" -> R.color.shift_off
|
|
"월차", "연차" -> R.color.secondary
|
|
"반월", "반년" -> R.color.shift_red
|
|
"교육" -> R.color.primary
|
|
"원래대로" -> R.color.text_secondary
|
|
else -> R.color.shift_gray
|
|
}
|
|
val color = androidx.core.content.ContextCompat.getColor(this, colorRes)
|
|
|
|
view.setTextColor(color)
|
|
|
|
// Create Stroke Drawable Programmatically
|
|
val drawable = android.graphics.drawable.GradientDrawable()
|
|
drawable.shape = android.graphics.drawable.GradientDrawable.OVAL
|
|
drawable.setColor(android.graphics.Color.TRANSPARENT)
|
|
val density = resources.displayMetrics.density
|
|
drawable.setStroke((1.5 * density).toInt(), color)
|
|
|
|
view.background = drawable
|
|
}
|
|
|
|
actionMap.forEach { (id, type) -> applyStrokeStyle(id, type) }
|
|
|
|
// Memo Handling
|
|
val etMemo = dialogView.findViewById<android.widget.EditText>(R.id.etMemo)
|
|
val repo = ShiftRepository(this)
|
|
lifecycleScope.launch {
|
|
val existingMemo = repo.getMemo(date)
|
|
etMemo.setText(existingMemo ?: "")
|
|
}
|
|
|
|
for ((id, action) in actionMap) {
|
|
dialogView.findViewById<android.view.View>(id).setOnClickListener {
|
|
lifecycleScope.launch {
|
|
val content = etMemo.text.toString().trim()
|
|
repo.setMemo(date, content) // Save memo even when shift button clicked
|
|
handleDaySettingAction(date, action, team, factory)
|
|
dialog.dismiss()
|
|
}
|
|
}
|
|
}
|
|
|
|
val saveAndCloseMemo = {
|
|
val content = etMemo.text.toString().trim()
|
|
lifecycleScope.launch {
|
|
repo.setMemo(date, content)
|
|
updateCalendar()
|
|
}
|
|
dialog.dismiss()
|
|
}
|
|
|
|
dialogView.findViewById<android.view.View>(R.id.btnQuickSaveMemo).setOnClickListener {
|
|
saveAndCloseMemo()
|
|
Toast.makeText(this@MainActivity, "메모가 저장되었습니다.", Toast.LENGTH_SHORT).show()
|
|
}
|
|
|
|
dialogView.findViewById<android.view.View>(R.id.btnClearMemo).setOnClickListener {
|
|
etMemo.setText("")
|
|
lifecycleScope.launch {
|
|
repo.setMemo(date, "")
|
|
updateCalendar()
|
|
Toast.makeText(this@MainActivity, "메모가 삭제되었습니다.", Toast.LENGTH_SHORT).show()
|
|
}
|
|
}
|
|
|
|
dialogView.findViewById<android.view.View>(R.id.btnClose).setOnClickListener {
|
|
saveAndCloseMemo()
|
|
}
|
|
|
|
// Auto-save when dialog is dismissed (e.g., Back key or touching outside)
|
|
dialog.setOnDismissListener {
|
|
val content = etMemo.text.toString().trim()
|
|
lifecycleScope.launch {
|
|
repo.setMemo(date, content)
|
|
updateCalendar()
|
|
}
|
|
}
|
|
|
|
dialog.show()
|
|
|
|
// Keyboard adjust resize
|
|
dialog.window?.setSoftInputMode(android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
|
|
}
|
|
|
|
private suspend fun handleDaySettingAction(date: LocalDate, selected: String, team: String, factory: String) {
|
|
val repo = ShiftRepository(this)
|
|
val prefs = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
|
|
|
|
|
|
when (selected) {
|
|
"원래대로" -> {
|
|
repo.clearOverride(date, team, factory)
|
|
repo.setMemo(date, "") // Clear memo too on reset
|
|
android.widget.Toast.makeText(this, "원래 근무로 복구되었습니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
syncAllAlarms(this)
|
|
updateCalendar()
|
|
repo.updateRemainingAnnualLeave()
|
|
}
|
|
"직접 입력" -> {
|
|
showCustomInputDialog(date, repo, team, factory)
|
|
}
|
|
"주간", "석간", "야간", "주간 맞교대", "야간 맞교대" -> {
|
|
// Standard Shifts -> Override Shift WITHOUT manual time
|
|
repo.setOverride(date, selected, team, factory)
|
|
updateCalendar()
|
|
// Alarms are handled by syncAllAlarms/CustomAlarms during updateCalendar
|
|
syncAllAlarms(this)
|
|
android.widget.Toast.makeText(this, "${date} [$selected]로 설정되었습니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
"휴무" -> {
|
|
// Standard Off
|
|
repo.setOverride(date, selected, team, factory)
|
|
updateCalendar()
|
|
syncAllAlarms(this)
|
|
android.widget.Toast.makeText(this, "${selected}로 설정되었습니다. 알람이 해제됩니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
"교육" -> {
|
|
// 교육은 원래 근무 알람을 유지
|
|
repo.setOverride(date, selected, team, factory)
|
|
updateCalendar()
|
|
syncAllAlarms(this)
|
|
android.widget.Toast.makeText(this, "교육으로 기록되었습니다. 원래 근무 알람이 유지됩니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
else -> {
|
|
// New Types: 월차, 연차, 반월, 반년 -> Saved as Override with no time
|
|
repo.setOverride(date, selected, team, factory)
|
|
// 연차 계산을 먼저 수행하고 달력 업데이트
|
|
repo.updateRemainingAnnualLeave()
|
|
updateCalendar()
|
|
syncAllAlarms(this)
|
|
android.widget.Toast.makeText(this, "${selected}(으)로 기록되었습니다. 알람이 해제됩니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun showCustomInputDialog(date: LocalDate, repo: ShiftRepository, team: String, factory: String) {
|
|
val layout = android.widget.LinearLayout(this).apply {
|
|
orientation = android.widget.LinearLayout.VERTICAL
|
|
setPadding(50, 40, 50, 10)
|
|
}
|
|
|
|
val etMemoInput = android.widget.EditText(this).apply {
|
|
hint = "메모 내용 (예: 회식, 교육, 출장)"
|
|
maxLines = 1
|
|
filters = arrayOf(android.text.InputFilter.LengthFilter(20))
|
|
}
|
|
|
|
layout.addView(etMemoInput)
|
|
|
|
androidx.appcompat.app.AlertDialog.Builder(this)
|
|
.setTitle("${date.monthValue}월 ${date.dayOfMonth}일 메모 입력")
|
|
.setView(layout)
|
|
.setPositiveButton("확인") { _, _ ->
|
|
val content = etMemoInput.text.toString().trim()
|
|
|
|
if (content.isNotEmpty()) {
|
|
lifecycleScope.launch {
|
|
// Direct Input -> Set as Memo.
|
|
// We do NOT change the shift (keep default or existing override).
|
|
// If user wants to change shift, they should use the specific buttons.
|
|
repo.setMemo(date, content)
|
|
updateCalendar()
|
|
android.widget.Toast.makeText(this@MainActivity, "메모가 저장되었습니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
} else {
|
|
android.widget.Toast.makeText(this, "입력이 취소되었습니다.", android.widget.Toast.LENGTH_SHORT).show()
|
|
}
|
|
}
|
|
.setNegativeButton("취소", null)
|
|
.show()
|
|
}
|
|
|
|
|
|
private fun setupWorker() {
|
|
val workRequest = PeriodicWorkRequestBuilder<AlarmWorker>(24, TimeUnit.HOURS)
|
|
.setInitialDelay(calculateDelayToMidnight(), TimeUnit.MILLISECONDS)
|
|
.build()
|
|
|
|
WorkManager.getInstance(this).enqueueUniquePeriodicWork(
|
|
"DailyShiftCheck",
|
|
ExistingPeriodicWorkPolicy.KEEP,
|
|
workRequest
|
|
)
|
|
}
|
|
|
|
private fun calculateDelayToMidnight(): Long {
|
|
val seoulZone = java.time.ZoneId.of("Asia/Seoul")
|
|
val now = java.time.LocalDateTime.now(seoulZone)
|
|
val midnight = now.plusDays(1).withHour(0).withMinute(0).withSecond(1)
|
|
return java.time.Duration.between(now, midnight).toMillis()
|
|
}
|
|
|
|
private fun animateMonthTransition(direction: Int) {
|
|
if (isAnimatingMonth) return
|
|
val card = binding.calendarCard
|
|
val snapshot = binding.calendarOverlaySnapshot
|
|
val width = card.width.toFloat()
|
|
|
|
val nextMonth = if (direction > 0) {
|
|
currentViewMonth.plusMonths(1)
|
|
} else {
|
|
currentViewMonth.minusMonths(1)
|
|
}
|
|
|
|
if (width == 0f) {
|
|
currentViewMonth = nextMonth
|
|
updateCalendar()
|
|
return
|
|
}
|
|
|
|
isAnimatingMonth = true
|
|
|
|
// 1. Capture bitmap snapshot of current calendar card
|
|
try {
|
|
val bitmap = Bitmap.createBitmap(card.width, card.height, Bitmap.Config.ARGB_8888)
|
|
val canvas = Canvas(bitmap)
|
|
card.draw(canvas)
|
|
snapshot.setImageBitmap(bitmap)
|
|
snapshot.visibility = android.view.View.VISIBLE
|
|
snapshot.alpha = 1.0f
|
|
snapshot.scaleX = 1.0f
|
|
snapshot.scaleY = 1.0f
|
|
snapshot.translationX = 0f
|
|
} catch (e: Exception) {
|
|
Log.w("MainActivity", "Failed to capture snapshot for month transition", e)
|
|
}
|
|
|
|
// 2. Position top card offscreen before loading
|
|
card.translationX = if (direction > 0) width else -width
|
|
currentViewMonth = nextMonth
|
|
|
|
// 3. Load next month's data BEFORE starting slide animation to eliminate any flicker
|
|
lifecycleScope.launch {
|
|
loadCalendarDataForMonth(currentViewMonth)
|
|
|
|
val fluidInterpolator = androidx.core.view.animation.PathInterpolatorCompat.create(0.22f, 1.0f, 0.36f, 1.0f)
|
|
val duration = 280L
|
|
|
|
card.animate()
|
|
.translationX(0f)
|
|
.setDuration(duration)
|
|
.setInterpolator(fluidInterpolator)
|
|
.withEndAction {
|
|
snapshot.visibility = android.view.View.GONE
|
|
snapshot.setImageDrawable(null)
|
|
isAnimatingMonth = false
|
|
}
|
|
.start()
|
|
|
|
snapshot.animate()
|
|
.scaleX(0.94f)
|
|
.scaleY(0.94f)
|
|
.alpha(0.35f)
|
|
.translationX(if (direction > 0) -width * 0.22f else width * 0.22f)
|
|
.setDuration(duration)
|
|
.setInterpolator(fluidInterpolator)
|
|
.start()
|
|
}
|
|
}
|
|
|
|
private fun formatRemainingDays(days: Float): String {
|
|
return if (days == days.toInt().toFloat()) {
|
|
// 정수인 경우
|
|
days.toInt().toString()
|
|
} else {
|
|
// 소숫점이 있는 경우 (0.5 등)
|
|
String.format("%.1f", days)
|
|
}
|
|
}
|
|
}
|