diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 4f2cf1a..714367a 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -1,6 +1,8 @@ - + + + + + + + + updateAllWidgets(context) + } + } + override fun onUpdate( context: Context, appWidgetManager: AppWidgetManager, @@ -18,40 +38,141 @@ class SimpleWidget : AppWidgetProvider() { for (appWidgetId in appWidgetIds) { updateAppWidget(context, appWidgetManager, appWidgetId) } + // Selbstheilung: stellt sicher, dass immer ein Wochenwechsel-Alarm existiert + scheduleNextWeekChange(context) + } + + override fun onEnabled(context: Context) { + // Erstes Widget wurde platziert + scheduleNextWeekChange(context) + } + + override fun onDisabled(context: Context) { + // Letztes Widget wurde entfernt + cancelWeekChange(context) } companion object { + const val ACTION_WEEK_CHANGED = "de.schanbro.weekfocus.ACTION_WEEK_CHANGED" + + private const val PREFS_NAME = "WeekFocusPrefs" + private const val KEY_WORDS = "words_key" + private const val KEY_WEEK = "current_week_key" + private const val KEY_WORD = "current_word" + + /** + * Aktualisiert alle Widget-Instanzen und plant den nächsten Wochenwechsel. + */ + fun updateAllWidgets(context: Context) { + val appWidgetManager = AppWidgetManager.getInstance(context) + val componentName = ComponentName(context, SimpleWidget::class.java) + val appWidgetIds = appWidgetManager.getAppWidgetIds(componentName) + if (appWidgetIds.isEmpty()) return + + for (appWidgetId in appWidgetIds) { + updateAppWidget(context, appWidgetManager, appWidgetId) + } + scheduleNextWeekChange(context) + } + fun updateAppWidget( context: Context, appWidgetManager: AppWidgetManager, appWidgetId: Int ) { - // 1. SharedPreferences auslesen - val sharedPrefs = context.getSharedPreferences("WeekFocusPrefs", Context.MODE_PRIVATE) - val savedSet = sharedPrefs.getStringSet("words_key", emptySet()) ?: emptySet() - val wordList = savedSet.toList() + val displayText = resolveWordOfWeek(context) + ?: context.getString(R.string.msg_no_words) - // 2. Aktuelle Kalenderwoche & Jahr bestimmen - val calendar = Calendar.getInstance() - val weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR) - val year = calendar.get(Calendar.YEAR) - - // 3. Wort für die aktuelle Kalenderwoche auswählen - val displayText = if (wordList.isNotEmpty()) { - // Kombinierter Seed aus Jahr und Kalenderwoche - val seed = (year * 100 + weekOfYear).toLong() - val random = Random(seed) - val randomIndex = random.nextInt(wordList.size) - wordList[randomIndex] - } else { - context.getString(R.string.msg_no_words) - } - - // 4. RemoteViews aktualisieren val views = RemoteViews(context.packageName, R.layout.widget_main) views.setTextViewText(R.id.appwidget_text, displayText) appWidgetManager.updateAppWidget(appWidgetId, views) } + + /** + * ISO-Kalenderwoche (Montag = Wochenbeginn, unabhängig von der Geräte-Locale) + * kombiniert mit dem zugehörigen Wochenjahr, z.B. 202641. + * + * Das Wochenjahr (nicht das Kalenderjahr!) verhindert, dass sich der Wert + * um Neujahr mitten in der Woche ändert. + */ + internal fun weekKeyFor(date: LocalDate): Int { + val weekBasedYear = date.get(IsoFields.WEEK_BASED_YEAR) + val week = date.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR) + return weekBasedYear * 100 + week + } + + /** + * Liefert das Wort der aktuellen Woche. + * + * - Die Liste wird sortiert, damit die Reihenfolge deterministisch ist + * (ein Set hat keine garantierte Reihenfolge). + * - Das gewählte Wort wird pro Woche gespeichert. Dadurch ändert sich das Wort + * nicht, wenn Wörter hinzugefügt oder gelöscht werden. Nur wenn das aktuelle + * Wort selbst gelöscht wird, wird neu gewählt. + */ + private fun resolveWordOfWeek(context: Context): String? { + val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) + val words = (prefs.getStringSet(KEY_WORDS, emptySet()) ?: emptySet()).sorted() + + if (words.isEmpty()) { + prefs.edit().remove(KEY_WEEK).remove(KEY_WORD).apply() + return null + } + + val weekKey = weekKeyFor(LocalDate.now()) + val storedWord = prefs.getString(KEY_WORD, null) + if (prefs.getInt(KEY_WEEK, -1) == weekKey && storedWord != null && storedWord in words) { + return storedWord + } + + val currentMonday = LocalDate.now().with(DayOfWeek.MONDAY) + val weeksSinceEpoch = ChronoUnit.WEEKS.between(LocalDate.ofEpochDay(4), currentMonday) // 5.1.1970 war ein Montag + val word = words[(weeksSinceEpoch % words.size).toInt()] + + prefs.edit() + .putInt(KEY_WEEK, weekKey) + .putString(KEY_WORD, word) + .apply() + return word + } + + /** + * Plant einen Alarm für den nächsten Montag, 00:00 Uhr (lokale Zeit). + * Bewusst ohne Exact-Alarm-Berechtigung: Eine Verzögerung von wenigen Minuten + * ist für ein Wochenwort unkritisch. + */ + private fun scheduleNextWeekChange(context: Context) { + val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return + + val triggerAtMillis = LocalDate.now() + .with(TemporalAdjusters.next(DayOfWeek.MONDAY)) // "next" schließt heute aus + .atStartOfDay(ZoneId.systemDefault()) + .toInstant() + .toEpochMilli() + + alarmManager.setAndAllowWhileIdle( + AlarmManager.RTC_WAKEUP, + triggerAtMillis, + weekChangePendingIntent(context) + ) + } + + private fun cancelWeekChange(context: Context) { + val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return + alarmManager.cancel(weekChangePendingIntent(context)) + } + + private fun weekChangePendingIntent(context: Context): PendingIntent { + val intent = Intent(context, SimpleWidget::class.java).apply { + action = ACTION_WEEK_CHANGED + } + return PendingIntent.getBroadcast( + context, + 0, + intent, + PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE + ) + } } } \ No newline at end of file