import net.pterodactylus.util.notify.*
import java.util.concurrent.*
import java.util.concurrent.atomic.*
+import javax.inject.*
/**
* Handler for [SoneLockedEvent]s and [SoneUnlockedEvent]s that can schedule notifications after
* a certain timeout.
*/
-class SoneLockedHandler(private val notificationManager: NotificationManager, private val notification: ListNotification<Sone>, private val executor: ScheduledExecutorService) {
+class SoneLockedHandler @Inject constructor(
+ private val notificationManager: NotificationManager,
+ @Named("soneLocked") private val notification: ListNotification<Sone>,
+ @Named("notification") private val executor: ScheduledExecutorService) {
private val future: AtomicReference<ScheduledFuture<*>> = AtomicReference()
@Subscribe
fun soneLocked(soneLockedEvent: SoneLockedEvent) {
synchronized(future) {
- future.get()?.also { cancelPreviousFuture(it, soneLockedEvent.sone) }
- future.set(executor.schedule(showNotification(soneLockedEvent.sone), 5, TimeUnit.MINUTES))
+ notification.add(soneLockedEvent.sone)
+ future.get()?.also(this::cancelPreviousFuture)
+ future.set(executor.schedule(::showNotification, 5, TimeUnit.MINUTES))
}
}
@Subscribe
fun soneUnlocked(soneUnlockedEvent: SoneUnlockedEvent) {
synchronized(future) {
- future.get()?.also { cancelPreviousFuture(it, soneUnlockedEvent.sone) }
+ notification.remove(soneUnlockedEvent.sone)
+ future.get()?.also(::cancelPreviousFuture)
}
}
- private fun cancelPreviousFuture(future: ScheduledFuture<*>, sone: Sone) {
- notification.remove(sone)
+ private fun cancelPreviousFuture(future: ScheduledFuture<*>) {
future.cancel(true)
}
- private fun showNotification(sone: Sone): () -> Unit = {
- notification.add(sone)
+ private fun showNotification() {
notificationManager.addNotification(notification)
}