From 8126286609d11c37c1ea53d037e67c75fb7a874e Mon Sep 17 00:00:00 2001
From: Duarte Barbosa <duartebarbosapt@gmail.com>
Date: Wed, 5 Feb 2025 00:48:10 +0000
Subject: [PATCH 1/3] New Timer Overlay that shows up real count while watching

Fixed the counter getting count twice

Some code cleanup / refactor
---
 .../com/scrolless/app/di/ProviderModule.kt    |  17 ++
 .../app/features/home/HomeFragment.kt         |  21 +-
 .../app/overlay/TimerOverlayManager.kt        |  27 +++
 .../app/overlay/TimerOverlayManagerImpl.kt    | 192 ++++++++++++++++++
 .../com/scrolless/app/provider/AppProvider.kt |   4 +
 .../scrolless/app/provider/AppProviderImpl.kt |  17 ++
 .../app/provider/UsageTrackerImpl.kt          |   1 +
 .../scrolless/app/services/BlockController.kt |  74 +++----
 .../app/services/BlockControllerImpl.kt       |  93 +++++++++
 .../ScrollessBlockAccessibilityService.kt     |  49 +++--
 .../services/handlers/DayLimitBlockHandler.kt |   4 +-
 app/src/main/res/layout/fragment_home.xml     |  14 +-
 app/src/main/res/layout/overlay_timer.xml     |  38 ++++
 app/src/main/res/values/dimens.xml            |   1 +
 app/src/main/res/values/strings.xml           |   1 +
 .../framework/extensions/LongExtension.kt     |  22 ++
 .../framework/extensions/ViewExtension.kt     |  67 ++++++
 17 files changed, 573 insertions(+), 69 deletions(-)
 create mode 100644 app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
 create mode 100644 app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
 create mode 100644 app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
 create mode 100644 app/src/main/res/layout/overlay_timer.xml

diff --git a/app/src/main/java/com/scrolless/app/di/ProviderModule.kt b/app/src/main/java/com/scrolless/app/di/ProviderModule.kt
index bd4d1ef..79b08dc 100644
--- a/app/src/main/java/com/scrolless/app/di/ProviderModule.kt
+++ b/app/src/main/java/com/scrolless/app/di/ProviderModule.kt
@@ -5,6 +5,8 @@
 package com.scrolless.app.di
 
 import android.content.Context
+import com.scrolless.app.overlay.TimerOverlayManager
+import com.scrolless.app.overlay.TimerOverlayManagerImpl
 import com.scrolless.app.provider.AppProvider
 import com.scrolless.app.provider.AppProviderImpl
 import com.scrolless.app.provider.NavigationProvider
@@ -15,6 +17,8 @@ import com.scrolless.app.provider.ThemeProvider
 import com.scrolless.app.provider.ThemeProviderImpl
 import com.scrolless.app.provider.UsageTracker
 import com.scrolless.app.provider.UsageTrackerImpl
+import com.scrolless.app.services.BlockController
+import com.scrolless.app.services.BlockControllerImpl
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -52,4 +56,17 @@ class ProviderModule {
     fun provideUsageTrackerImpl(
         appProvider: AppProvider
     ): UsageTracker = UsageTrackerImpl(appProvider)
+
+    @Provides
+    @Singleton
+    fun provideBlockController(
+        usageTracker: UsageTracker
+    ): BlockController = BlockControllerImpl(usageTracker)
+
+    @Provides
+    @Singleton
+    fun provideTimerOverlayManager(
+        usageTracker: UsageTracker,
+        appProvider: AppProvider
+    ): TimerOverlayManager = TimerOverlayManagerImpl(usageTracker, appProvider)
 }
diff --git a/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt b/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
index 4bdd1a2..2da3eb3 100644
--- a/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
+++ b/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
@@ -21,11 +21,8 @@ import com.scrolless.app.provider.AppProvider
 import com.scrolless.app.provider.UsageTracker
 import com.scrolless.app.services.ScrollessBlockAccessibilityService
 import com.scrolless.framework.extensions.*
-import com.scrolless.framework.extensions.formatTime
-import com.scrolless.framework.extensions.observeFlow
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
-
 @AndroidEntryPoint
 class HomeFragment : BaseFragment<FragmentHomeBinding>() {
     companion object {
@@ -40,6 +37,7 @@ class HomeFragment : BaseFragment<FragmentHomeBinding>() {
     lateinit var usageTracker: UsageTracker
 
     override fun onViewReady(bundle: Bundle?) {
+
         observeFlow(appProvider.blockConfigFlow) { config ->
             updateUIForBlockOption(config.blockOption)
             updateInfoText(usageTracker.dailyUsageInMemory, config.timeLimit)
@@ -128,6 +126,23 @@ class HomeFragment : BaseFragment<FragmentHomeBinding>() {
         if (!isAccessibilityServiceEnabled(requireContext())) {
             openAccessibilitySettings(requireContext())
         }
+
+        setTimerOverlayCheckBoxListener()
+    }
+
+    /**
+     * Sets up the listener for the timer overlay checkbox.
+     *
+     * Initializes the checkbox state from appProvider.timerOverlayEnabled
+     *  and updates it when the checkbox is toggled.
+     */
+    private fun setTimerOverlayCheckBoxListener() {
+
+        binding.checkBoxTimerOverlay.isChecked = appProvider.timerOverlayEnabled
+
+        binding.checkBoxTimerOverlay.setOnCheckedChangeListener { _, isChecked ->
+            appProvider.timerOverlayEnabled = isChecked
+        }
     }
 
     override fun onResume() {
diff --git a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
new file mode 100644
index 0000000..d177adf
--- /dev/null
+++ b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
@@ -0,0 +1,27 @@
+package com.scrolless.app.overlay
+
+import android.content.Context
+import android.graphics.PixelFormat
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowManager
+import android.widget.TextView
+import androidx.appcompat.view.ContextThemeWrapper
+import com.scrolless.app.R
+import com.scrolless.app.provider.AppProvider
+import com.scrolless.app.provider.UsageTracker
+import com.scrolless.framework.extensions.getReadableTime
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+interface TimerOverlayManager {
+    fun attachServiceContext(context: Context)
+    fun show()
+    fun hide()
+}
diff --git a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
new file mode 100644
index 0000000..39c2929
--- /dev/null
+++ b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
@@ -0,0 +1,192 @@
+package com.scrolless.app.overlay
+
+import android.content.Context
+import android.graphics.PixelFormat
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowManager
+import android.widget.TextView
+import androidx.appcompat.view.ContextThemeWrapper
+import com.scrolless.app.R
+import com.scrolless.app.provider.AppProvider
+import com.scrolless.app.provider.UsageTracker
+import com.scrolless.framework.extensions.fadeOutWithBounceAnimation
+import com.scrolless.framework.extensions.getReadableTime
+import jakarta.inject.Inject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.isActive
+
+/**
+ * Implementation of TimerOverlayManager that displays a timer overlay on top of the brain rot content.
+ */
+class TimerOverlayManagerImpl @Inject constructor(
+    private val usageTracker: UsageTracker,
+    private val appProvider: AppProvider
+) : TimerOverlayManager {
+
+    private var overlayView: View? = null
+    private var timerTextView: TextView? = null
+
+    // Job for updating the timer text
+    private var timerUpdateJob: Job? = null
+
+    private lateinit var layoutParams: WindowManager.LayoutParams
+
+    // Store the last known overlay position (persisted in appProvider)
+    private var positionX = appProvider.timerOverlayPositionX
+    private var positionY = appProvider.timerOverlayPositionY
+
+    private val coroutineScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+    private lateinit var serviceContext: Context
+    private var windowManager: WindowManager? = null
+
+    /**
+     * Attaches the service context used to interact with the window manager.
+     */
+    override fun attachServiceContext(context: Context) {
+        serviceContext = context
+        windowManager = serviceContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    }
+
+    /**
+     * Displays the timer overlay on screen, if it's not already visible.
+     */
+    override fun show() {
+
+        // If already showing, do nothing
+        if (overlayView != null) return
+
+        // Offset the start time by 1 second to account for delays.
+        val startTimeMillis = System.currentTimeMillis() - 1000
+
+        // Inflate the overlay view using the app's theme
+        val themedContext = ContextThemeWrapper(serviceContext, R.style.AppTheme)
+        val inflater = LayoutInflater.from(themedContext)
+        overlayView = inflater.inflate(R.layout.overlay_timer, null)
+        timerTextView = overlayView?.findViewById(R.id.timerTextView)
+
+        // Set up layout parameters for the overlay window
+        layoutParams = WindowManager.LayoutParams(
+            WindowManager.LayoutParams.WRAP_CONTENT,
+            WindowManager.LayoutParams.WRAP_CONTENT,
+            WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
+            PixelFormat.TRANSLUCENT,
+        ).apply {
+            gravity = Gravity.TOP or Gravity.END
+            x = positionX
+            y = positionY
+        }
+
+        // Start invisible for a quick fade-in effect.
+        overlayView?.alpha = 0f
+        windowManager?.addView(overlayView, layoutParams)
+
+        overlayView?.animate()
+            ?.alpha(1f)
+            ?.setDuration(200)
+            ?.start()
+
+        enableDragging()
+        startTimer(startTimeMillis)
+    }
+
+    /**
+     * Hides the timer overlay with an animation, then removes it from the window.
+     */
+    override fun hide() {
+        stopTimer()
+
+        val currentView = overlayView ?: return
+
+        // Update the timer text with the total daily usage before hiding.
+        val totalTime = usageTracker.getDailyUsage()
+        timerTextView?.text = totalTime.getReadableTime()
+
+        currentView.fadeOutWithBounceAnimation {
+            currentView.visibility = View.GONE
+            windowManager?.removeView(currentView)
+            overlayView = null
+            timerTextView = null
+        }
+    }
+
+    /**
+     * Starts the coroutine to update the timer text every second.
+     *
+     * @param startTimeMillis The starting point for the timer
+     */
+    private fun startTimer(startTimeMillis: Long) {
+
+        // Cancel any existing timer before starting a new one
+        stopTimer()
+
+        timerUpdateJob = coroutineScope.launch(Dispatchers.Main) {
+            while (isActive) {
+                val elapsed = System.currentTimeMillis() - startTimeMillis
+                timerTextView?.text = elapsed.getReadableTime()
+                delay(1000)
+            }
+        }
+    }
+
+    /**
+     * Cancels any active timer job.
+     */
+    private fun stopTimer() {
+        timerUpdateJob?.cancel()
+        timerUpdateJob = null
+    }
+
+
+    /**
+     * Enables dragging of the overlay view, updating and persisting position to [appProvider].
+     */
+    private fun enableDragging() {
+        overlayView?.setOnTouchListener(
+            object : View.OnTouchListener {
+                private var initialX = 0
+                private var initialY = 0
+                private var initialTouchX = 0f
+                private var initialTouchY = 0f
+
+                override fun onTouch(view: View, motionEvent: MotionEvent): Boolean {
+                    when (motionEvent.action) {
+                        MotionEvent.ACTION_DOWN -> {
+                            initialX = layoutParams.x
+                            initialY = layoutParams.y
+                            initialTouchX = motionEvent.rawX
+                            initialTouchY = motionEvent.rawY
+                            return true
+                        }
+
+                        MotionEvent.ACTION_MOVE -> {
+                            layoutParams.x = initialX - (motionEvent.rawX - initialTouchX).toInt()
+                            layoutParams.y = initialY + (motionEvent.rawY - initialTouchY).toInt()
+                            windowManager?.updateViewLayout(overlayView, layoutParams)
+                            return true
+                        }
+
+                        MotionEvent.ACTION_UP -> {
+                            positionX = layoutParams.x
+                            positionY = layoutParams.y
+
+                            // Persist final position to appProvider
+                            appProvider.timerOverlayPositionX = positionX
+                            appProvider.timerOverlayPositionY = positionY
+                        }
+                    }
+                    return false
+                }
+            },
+        )
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/scrolless/app/provider/AppProvider.kt b/app/src/main/java/com/scrolless/app/provider/AppProvider.kt
index b79e0f6..2115103 100644
--- a/app/src/main/java/com/scrolless/app/provider/AppProvider.kt
+++ b/app/src/main/java/com/scrolless/app/provider/AppProvider.kt
@@ -20,4 +20,8 @@ interface AppProvider {
      */
     var blockConfig: BlockConfig
     val blockConfigFlow: StateFlow<BlockConfig>
+
+    var timerOverlayEnabled: Boolean
+    var timerOverlayPositionX: Int
+    var timerOverlayPositionY: Int
 }
diff --git a/app/src/main/java/com/scrolless/app/provider/AppProviderImpl.kt b/app/src/main/java/com/scrolless/app/provider/AppProviderImpl.kt
index 9a0a56c..3d0b8e6 100644
--- a/app/src/main/java/com/scrolless/app/provider/AppProviderImpl.kt
+++ b/app/src/main/java/com/scrolless/app/provider/AppProviderImpl.kt
@@ -22,6 +22,11 @@ class AppProviderImpl(context: Context) : AppProvider {
         private const val PREF_INTERVAL_LENGTH = "interval_length"
         private const val PREF_LAST_RESET_DAY = "last_reset_day"
         private const val PREF_TOTAL_DAILY_USAGE = "total_daily_usage"
+
+        // Timer overlay
+        private const val PREF_TIMER_OVERLAY_ENABLED = "timer_overlay_enabled"
+        private const val PREF_TIMER_POSITION_X = "timer_overlay_position_x"
+        private const val PREF_TIMER_POSITION_Y = "timer_overlay_position_y"
     }
 
     override val cacheManager = CacheManager(context, PREF_PACKAGE_NAME)
@@ -61,6 +66,18 @@ class AppProviderImpl(context: Context) : AppProvider {
         get() = cacheManager.read(PREF_TOTAL_DAILY_USAGE, 0)
         set(value) = cacheManager.write(PREF_TOTAL_DAILY_USAGE, value)
 
+    override var timerOverlayEnabled: Boolean
+        get() = cacheManager.read(PREF_TIMER_OVERLAY_ENABLED, false)
+        set(value) = cacheManager.write(PREF_TIMER_OVERLAY_ENABLED, value)
+
+    override var timerOverlayPositionX: Int
+        get() = cacheManager.read(PREF_TIMER_POSITION_X, 16)
+        set(value) = cacheManager.write(PREF_TIMER_POSITION_X, value)
+
+    override var timerOverlayPositionY: Int
+        get() = cacheManager.read(PREF_TIMER_POSITION_Y, 16)
+        set(value) = cacheManager.write(PREF_TIMER_POSITION_Y, value)
+
     private fun readBlockConfigFromCache(): BlockConfig {
         val blockOption = cacheManager.read(PREF_BLOCK_OPTION, BlockOption.NothingSelected)
         val timeLimit = cacheManager.read(PREF_TIME_LIMIT, 20000L)
diff --git a/app/src/main/java/com/scrolless/app/provider/UsageTrackerImpl.kt b/app/src/main/java/com/scrolless/app/provider/UsageTrackerImpl.kt
index 2c2b5a7..ecec796 100644
--- a/app/src/main/java/com/scrolless/app/provider/UsageTrackerImpl.kt
+++ b/app/src/main/java/com/scrolless/app/provider/UsageTrackerImpl.kt
@@ -47,6 +47,7 @@ class UsageTrackerImpl @Inject constructor(
         if (currentDay != lastDay) {
             dailyUsageInMemory = 0L
             appProvider.lastResetDay = currentDay
+            save()
         }
     }
 
diff --git a/app/src/main/java/com/scrolless/app/services/BlockController.kt b/app/src/main/java/com/scrolless/app/services/BlockController.kt
index 8d68eb6..044b749 100644
--- a/app/src/main/java/com/scrolless/app/services/BlockController.kt
+++ b/app/src/main/java/com/scrolless/app/services/BlockController.kt
@@ -5,60 +5,36 @@
 package com.scrolless.app.services
 
 import com.scrolless.app.features.home.BlockConfig
-import com.scrolless.app.features.home.BlockOption
-import com.scrolless.app.provider.AppProvider
-import com.scrolless.app.provider.UsageTracker
-import com.scrolless.app.services.handlers.BlockAllBlockHandler
-import com.scrolless.app.services.handlers.DayLimitBlockHandler
-import com.scrolless.app.services.handlers.IntervalTimerBlockHandler
-import com.scrolless.app.services.handlers.NothingSelectedBlockHandler
-import com.scrolless.app.services.handlers.TemporaryUnblockBlockHandler
 
-class BlockController(
-    private val appProvider: AppProvider,
-    private val usageTracker: UsageTracker
-) {
-
-    private var handler: BlockOptionHandler = createHandlerForConfig(appProvider.blockConfig)
+interface BlockController {
 
     /**
-     * Updates the block option, creating a new handler and performing any necessary resets.
+     * Initializes the controller with a configuration.
+     *
+     * @param blockConfig Configuration for blocking options.
      */
-    fun setBlockConfigOption(newOption: BlockConfig) {
-        handler = createHandlerForConfig(newOption)
-        initializeForOption() // Re-run initialization logic if needed
-    }
-
-    private fun createHandlerForConfig(config: BlockConfig): BlockOptionHandler = when (config.blockOption) {
-        BlockOption.BlockAll -> BlockAllBlockHandler()
-        BlockOption.DayLimit -> DayLimitBlockHandler(config.timeLimit)
-        BlockOption.IntervalTimer -> IntervalTimerBlockHandler(
-            config.timeLimit,
-            config.intervalLength,
-        )
-
-        BlockOption.TemporaryUnblock -> TemporaryUnblockBlockHandler(config.timeLimit)
-        BlockOption.NothingSelected -> NothingSelectedBlockHandler()
-    }
+    fun init(blockConfig: BlockConfig)
 
-    fun onEnterBlockedContent(): Boolean {
-        usageTracker.checkDailyReset()
-
-        // If handler says block now, return true
-        return handler.onEnterContent(usageTracker)
-    }
-
-    fun onPeriodicCheck(elapsedTime: Long): Boolean = handler.onPeriodicCheck(usageTracker, elapsedTime)
+    /**
+     * Called when entering brain rot content.
+     *
+     * @return `true` if blocking is required.
+     */
+    fun onEnterBlockedContent(): Boolean
 
-    fun onExitBlockedContent(sessionTime: Long) {
-        handler.onExitContent(usageTracker, sessionTime)
-    }
+    /**
+     * Called periodically to perform any checks on the handler
+     *  for example to check if any time limit has been reached.
+     *
+     * @param elapsedTime Time elapsed since the last check.
+     * @return `true` if the content should remain blocked.
+     */
+    fun onPeriodicCheck(elapsedTime: Long): Boolean
 
-    fun initializeForOption() {
-        usageTracker.load() // Make sure we have the latest data
-        usageTracker.checkDailyReset() // In case day changed
-        if (appProvider.blockConfig.blockOption == BlockOption.IntervalTimer) {
-            usageTracker.checkDailyReset() // or do any additional interval logic here
-        }
-    }
+    /**
+     * Called when exiting brain rot content.
+     *
+     * @param sessionTime Duration of the session.
+     */
+    fun onExitBlockedContent(sessionTime: Long)
 }
diff --git a/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt b/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
new file mode 100644
index 0000000..9d73124
--- /dev/null
+++ b/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2025, Scrolless
+ * All rights reserved.
+ */
+package com.scrolless.app.services
+
+import com.scrolless.app.features.home.BlockConfig
+import com.scrolless.app.features.home.BlockOption
+import com.scrolless.app.provider.UsageTracker
+import com.scrolless.app.services.handlers.BlockAllBlockHandler
+import com.scrolless.app.services.handlers.DayLimitBlockHandler
+import com.scrolless.app.services.handlers.IntervalTimerBlockHandler
+import com.scrolless.app.services.handlers.NothingSelectedBlockHandler
+import com.scrolless.app.services.handlers.TemporaryUnblockBlockHandler
+
+/**
+ * Implementation of [BlockController] that uses a [BlockOptionHandler] to handle blocking logic.
+ *
+ * @property usageTracker Tracks usage data and handles daily resets.
+ */
+class BlockControllerImpl(
+    private val usageTracker: UsageTracker
+) : BlockController {
+
+    private lateinit var handler: BlockOptionHandler
+
+    /**
+     * Initializes the controller with a configuration.
+     * Sets up the correct handler and refreshes usage data.
+     *
+     * @param blockConfig Configuration for blocking options.
+     */
+    override fun init(blockConfig: BlockConfig) {
+
+        handler = createHandlerForConfig(blockConfig)
+        usageTracker.load() // Make sure we have the latest data
+        usageTracker.checkDailyReset() // In case day changed
+        if (blockConfig.blockOption == BlockOption.IntervalTimer) {
+            usageTracker.checkDailyReset() // or do any additional interval logic here
+        }
+    }
+
+    /**
+     * Chooses a [BlockOptionHandler] based on the [BlockConfig].
+     *
+     * @param config The blocking configuration.
+     * @return A handler matching the configuration.
+     */
+    private fun createHandlerForConfig(config: BlockConfig): BlockOptionHandler =
+        when (config.blockOption) {
+            BlockOption.BlockAll -> BlockAllBlockHandler()
+            BlockOption.DayLimit -> DayLimitBlockHandler(config.timeLimit)
+            BlockOption.IntervalTimer -> IntervalTimerBlockHandler(
+                config.timeLimit,
+                config.intervalLength,
+            )
+
+            BlockOption.TemporaryUnblock -> TemporaryUnblockBlockHandler(config.timeLimit)
+            BlockOption.NothingSelected -> NothingSelectedBlockHandler()
+        }
+
+    /**
+     * Called when entering brain rot content.
+     * Checks usage and decides if the content should be immediately blocked.
+     *
+     * @return `true` if blocking is required.
+     */
+    override fun onEnterBlockedContent(): Boolean {
+        usageTracker.checkDailyReset()
+
+        // If handler says block now, return true
+        return handler.onEnterContent(usageTracker)
+    }
+
+    /**
+     * Called periodically to perform any checks on the handler
+     *  for example to check if any time limit has been reached.
+     *
+     * @param elapsedTime Time elapsed since the last check.
+     * @return `true` if the content should remain blocked.
+     */
+    override fun onPeriodicCheck(elapsedTime: Long): Boolean =
+        handler.onPeriodicCheck(usageTracker, elapsedTime)
+
+    /**
+     * Called when exiting brain rot content.
+     *
+     * @param sessionTime Duration of the session.
+     */
+    override fun onExitBlockedContent(sessionTime: Long) {
+        handler.onExitContent(usageTracker, sessionTime)
+    }
+}
diff --git a/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt b/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
index 7c6de3e..e170818 100644
--- a/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
+++ b/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
@@ -12,6 +12,8 @@ import android.os.Looper
 import android.view.accessibility.AccessibilityEvent
 import android.view.accessibility.AccessibilityNodeInfo
 import com.scrolless.app.features.home.BlockOption
+import com.scrolless.app.overlay.TimerOverlayManager
+import com.scrolless.app.overlay.TimerOverlayManagerImpl
 import com.scrolless.app.provider.AppProvider
 import com.scrolless.app.provider.UsageTracker
 import dagger.hilt.android.AndroidEntryPoint
@@ -42,16 +44,20 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     @Inject
     lateinit var usageTracker: UsageTracker
 
-    private val blockController by lazy { BlockController(appProvider, usageTracker) }
+    @Inject
+    lateinit var blockController: BlockController
 
-    private var currentOnVideos = false
-    private var timeStartOnBrainRot: Long = 0L
+    @Inject
+    lateinit var timerOverlayManager: TimerOverlayManager
 
     private var active = true
+    private var currentOnVideos = false
+    private var timeStartOnBrainRot: Long = 0L
 
     private val blockedViews = setOf(
         "com.google.android.youtube:id/reel_player_page_container",
         "com.instagram.android:id/clips_viewer_view_pager",
+        // TODO Tiktok is not supported yet
     )
 
     private val videoCheckRunnable = object : Runnable {
@@ -68,16 +74,17 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     override fun onServiceConnected() {
+
         super.onServiceConnected()
         configureServiceInfo()
 
-        // Initialize block logic
-        blockController.initializeForOption()
+        // Make sure the timer overlay manager has the service's context
+        timerOverlayManager.attachServiceContext(this)
 
         // Observe changes to the block config
         serviceScope.launch {
             appProvider.blockConfigFlow.collect { newConfig ->
-                blockController.setBlockConfigOption(newConfig)
+                blockController.init(newConfig)
                 active = (newConfig.blockOption != BlockOption.NothingSelected)
             }
         }
@@ -100,8 +107,7 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
         }
     }
 
-    override fun onInterrupt() {
-    }
+    override fun onInterrupt() = Unit
 
     override fun onDestroy() {
         super.onDestroy()
@@ -113,22 +119,33 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     private fun configureServiceInfo() {
+
         val info = AccessibilityServiceInfo().apply {
+
             eventTypes = AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
             feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC
             notificationTimeout = 100
+
             flags =
-                AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS or AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS
+                AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS or
+                AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS
         }
         serviceInfo = info
     }
 
-    private fun detectBlockedContent(rootNode: AccessibilityNodeInfo): Boolean = blockedViews.any { id ->
-        rootNode.findAccessibilityNodeInfosByViewId(id).isNotEmpty()
-    }
+    private fun detectBlockedContent(rootNode: AccessibilityNodeInfo): Boolean =
+        blockedViews.any { id ->
+            rootNode.findAccessibilityNodeInfosByViewId(id).isNotEmpty()
+        }
 
     private fun onBlockedContentEntered() {
         if (!currentOnVideos) {
+
+            // If timer overlay is enabled, show it
+            if (appProvider.timerOverlayEnabled) {
+                timerOverlayManager.show()
+            }
+
             currentOnVideos = true
             timeStartOnBrainRot = System.currentTimeMillis()
             startPeriodicCheck()
@@ -143,7 +160,9 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     private fun onBlockedContentExited() {
+
         if (currentOnVideos) {
+            
             val sessionTime = System.currentTimeMillis() - timeStartOnBrainRot
 
             // Add to usage in memory
@@ -154,6 +173,12 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
 
             currentOnVideos = false
             stopPeriodicCheck()
+
+            if (appProvider.timerOverlayEnabled) {
+                timerOverlayManager.hide()
+            }
+
+            usageTracker.save()
         }
     }
 
diff --git a/app/src/main/java/com/scrolless/app/services/handlers/DayLimitBlockHandler.kt b/app/src/main/java/com/scrolless/app/services/handlers/DayLimitBlockHandler.kt
index 6e3f6bc..1c00235 100644
--- a/app/src/main/java/com/scrolless/app/services/handlers/DayLimitBlockHandler.kt
+++ b/app/src/main/java/com/scrolless/app/services/handlers/DayLimitBlockHandler.kt
@@ -18,7 +18,5 @@ class DayLimitBlockHandler(private val timeLimit: Long) : BlockOptionHandler {
         return (usageTracker.getDailyUsage() + elapsedTime) >= timeLimit
     }
 
-    override fun onExitContent(usageTracker: UsageTracker, sessionTime: Long) {
-        usageTracker.addToDailyUsage(sessionTime)
-    }
+    override fun onExitContent(usageTracker: UsageTracker, sessionTime: Long) {}
 }
diff --git a/app/src/main/res/layout/fragment_home.xml b/app/src/main/res/layout/fragment_home.xml
index 3fd4b87..3b132d8 100644
--- a/app/src/main/res/layout/fragment_home.xml
+++ b/app/src/main/res/layout/fragment_home.xml
@@ -147,16 +147,26 @@
         app:layout_constraintStart_toEndOf="@id/temporary_unblock_button"
         app:layout_constraintTop_toTopOf="@id/temporary_unblock_button" />
 
+    <CheckBox
+        android:id="@+id/checkBoxTimerOverlay"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Show Timer Overlay"
+        android:textColor="@color/accent_color"
+        android:textSize="14sp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/interval_timer_button" />
+
     <Button
         android:id="@+id/btn_rate_us"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_marginTop="8dp"
         android:text="Rate Us on Play Store"
         android:textColor="@android:color/white"
         android:textSize="14sp"
         app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toBottomOf="@id/temporary_unblock_button" />
+        app:layout_constraintTop_toBottomOf="@+id/checkBoxTimerOverlay" />
 
     <TextView
         android:id="@+id/tv_usage_title"
diff --git a/app/src/main/res/layout/overlay_timer.xml b/app/src/main/res/layout/overlay_timer.xml
new file mode 100644
index 0000000..fcea91c
--- /dev/null
+++ b/app/src/main/res/layout/overlay_timer.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content">
+
+    <com.google.android.material.card.MaterialCardView
+        android:id="@+id/timerCardView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_margin="8dp"
+        app:cardBackgroundColor="#AA000000"
+        app:cardCornerRadius="16dp"
+        app:cardElevation="8dp"
+        app:cardPreventCornerOverlap="false"
+        app:cardUseCompatPadding="true"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        app:strokeColor="@android:color/white"
+        app:strokeWidth="1dp">
+
+        <TextView
+            android:id="@+id/timerTextView"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_margin="12dp"
+            android:text="00:00:00"
+            android:textColor="@android:color/white"
+            android:textSize="18sp"
+            android:textStyle="bold"
+            android:shadowColor="@color/semi_transparent_black"
+            android:shadowDx="0"
+            android:shadowDy="2"
+            android:shadowRadius="3"
+            android:contentDescription="@string/timer_content_description" />
+    </com.google.android.material.card.MaterialCardView>
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml
index 0f5292e..fcffda8 100644
--- a/app/src/main/res/values/dimens.xml
+++ b/app/src/main/res/values/dimens.xml
@@ -52,4 +52,5 @@
     <dimen name="preview_dot_size">24dp</dimen>
     <dimen name="between_row_padding">8dp</dimen>
     <dimen name="placeholders_padding">48dp</dimen>
+    <dimen name="activity_vertical_margin">16dp</dimen>
 </resources>
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index c1e5337..93cf336 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -15,4 +15,5 @@
     <string name="day_limit">Day Limit</string>
     <string name="temporary_block">Temporary Block</string>
     <string name="interval_timer">Interval Timer</string>
+    <string name="timer_content_description">Elapsed Time</string>
 </resources>
\ No newline at end of file
diff --git a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
index 257d7db..ce67b33 100644
--- a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
+++ b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
@@ -4,6 +4,13 @@
  */
 package com.scrolless.framework.extensions
 
+import java.time.Duration
+import java.util.Locale
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+
 fun Long.formatDurationFromSeconds(): String {
     val seconds = this % 60
     val minutes = (this / 60) % 60
@@ -43,6 +50,21 @@ fun Long.formatTime(): String {
     }
 }
 
+
+fun Long.getReadableTime(): String {
+    val duration = this.milliseconds
+    val hours = duration.inWholeHours
+    val minutes = (duration - hours.hours).inWholeMinutes
+    val seconds = (duration - hours.hours - minutes.minutes).inWholeSeconds
+
+    return if (hours > 0) {
+        String.format("%02d:%02d:%02d", hours, minutes, seconds)
+    } else {
+        String.format("%02d:%02d", minutes, seconds)
+    }
+}
+
+
 fun Int.formatDurationFromSeconds(): String {
     val seconds = this % 60
     val minutes = (this / 60) % 60
diff --git a/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt b/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
index c71a208..919c560 100644
--- a/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
+++ b/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
@@ -4,6 +4,10 @@
  */
 package com.scrolless.framework.extensions
 
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
 import android.content.Context
 import android.os.SystemClock
 import android.view.HapticFeedbackConstants
@@ -76,6 +80,69 @@ fun View.fadeOut() {
         .start()
 }
 
+
+/**
+ * Extension function for View that runs a hide animation sequence:
+ * 1. Scale down from 1.0 to 0.9 over 100 ms.
+ * 2. Pause for 100 ms.
+ * 3. Scale up from 0.9 to 1.1 over 200 ms.
+ * 4. Pause for 400 ms.
+ * 5. Fade out and shrink (scale to 0 and alpha to 0) over 200 ms.
+ *
+ * @param onAnimationEnd Called when the entire animation sequence finishes.
+ */
+fun View.fadeOutWithBounceAnimation(onAnimationEnd: () -> Unit) {
+
+    val view = this;
+
+    // Inline helper: create a dummy animator that effectively pauses.
+    fun pause(duration: Long) = ObjectAnimator.ofFloat(this, "alpha", this.alpha, this.alpha).apply {
+        this.duration = duration
+    }
+
+    // 1. Scale down from 1.0 to 0.9 in 100 ms.
+    val scaleDown = AnimatorSet().apply {
+        playTogether(
+            ObjectAnimator.ofFloat(view, "scaleX", 1f, 0.9f).apply { duration = 100 },
+            ObjectAnimator.ofFloat(view, "scaleY", 1f, 0.9f).apply { duration = 100 }
+        )
+    }
+
+    // 2. Pause for 100 ms.
+    val pause1 = pause(100)
+
+    // 3. Scale up from 0.9 to 1.1 in 200 ms.
+    val scaleUp = AnimatorSet().apply {
+        playTogether(
+            ObjectAnimator.ofFloat(view, "scaleX", 0.9f, 1.1f).apply { duration = 200 },
+            ObjectAnimator.ofFloat(view, "scaleY", 0.9f, 1.1f).apply { duration = 200 }
+        )
+    }
+
+    // 4. Pause for 400 ms.
+    val pause2 = pause(400)
+
+    // 5. Fade out and shrink (scale to 0 and alpha to 0) in 200 ms.
+    val fadeOut = AnimatorSet().apply {
+        playTogether(
+            ObjectAnimator.ofFloat(view, "scaleX", 1.1f, 0f).apply { duration = 200 },
+            ObjectAnimator.ofFloat(view, "scaleY", 1.1f, 0f).apply { duration = 200 },
+            ObjectAnimator.ofFloat(view, "alpha", 1f, 0f).apply { duration = 200 }
+        )
+    }
+
+    // Chain the animations sequentially.
+    AnimatorSet().apply {
+        playSequentially(scaleDown, pause1, scaleUp, pause2, fadeOut)
+        addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+                onAnimationEnd()
+            }
+        })
+        start()
+    }
+}
+
 val Context.inflater: LayoutInflater get() = LayoutInflater.from(this)
 
 fun ViewGroup.inflate(layoutRes: Int): View =

From 7be70b91d3c414f52be7c0ce6f6da2f8924310d3 Mon Sep 17 00:00:00 2001
From: Duarte Barbosa <duartebarbosapt@gmail.com>
Date: Wed, 5 Feb 2025 19:50:35 +0000
Subject: [PATCH 2/3] New javadoc and fixed spotless errors

---
 .../app/features/home/HomeFragment.kt         |   2 -
 .../app/overlay/TimerOverlayManager.kt        |  22 +--
 .../app/overlay/TimerOverlayManagerImpl.kt    |  11 +-
 .../app/services/BlockControllerImpl.kt       |   1 -
 .../ScrollessBlockAccessibilityService.kt     |   7 -
 app/src/main/res/layout/overlay_timer.xml     |   4 +
 app/src/main/res/values/colors.xml            |   1 +
 .../kotlin/com/scrolless/app/KotlinAndroid.kt |   2 +-
 .../framework/extensions/LongExtension.kt     |  95 ++++++++---
 .../framework/extensions/ViewExtension.kt     | 157 +++++++++++-------
 10 files changed, 190 insertions(+), 112 deletions(-)

diff --git a/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt b/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
index 2da3eb3..a8e22ec 100644
--- a/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
+++ b/app/src/main/java/com/scrolless/app/features/home/HomeFragment.kt
@@ -37,7 +37,6 @@ class HomeFragment : BaseFragment<FragmentHomeBinding>() {
     lateinit var usageTracker: UsageTracker
 
     override fun onViewReady(bundle: Bundle?) {
-
         observeFlow(appProvider.blockConfigFlow) { config ->
             updateUIForBlockOption(config.blockOption)
             updateInfoText(usageTracker.dailyUsageInMemory, config.timeLimit)
@@ -137,7 +136,6 @@ class HomeFragment : BaseFragment<FragmentHomeBinding>() {
      *  and updates it when the checkbox is toggled.
      */
     private fun setTimerOverlayCheckBoxListener() {
-
         binding.checkBoxTimerOverlay.isChecked = appProvider.timerOverlayEnabled
 
         binding.checkBoxTimerOverlay.setOnCheckedChangeListener { _, isChecked ->
diff --git a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
index d177adf..7bb7db4 100644
--- a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
+++ b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManager.kt
@@ -1,24 +1,10 @@
+/*
+ * Copyright (C) 2025, Scrolless
+ * All rights reserved.
+ */
 package com.scrolless.app.overlay
 
 import android.content.Context
-import android.graphics.PixelFormat
-import android.view.Gravity
-import android.view.LayoutInflater
-import android.view.MotionEvent
-import android.view.View
-import android.view.WindowManager
-import android.widget.TextView
-import androidx.appcompat.view.ContextThemeWrapper
-import com.scrolless.app.R
-import com.scrolless.app.provider.AppProvider
-import com.scrolless.app.provider.UsageTracker
-import com.scrolless.framework.extensions.getReadableTime
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 
 interface TimerOverlayManager {
     fun attachServiceContext(context: Context)
diff --git a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
index 39c2929..5451736 100644
--- a/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
+++ b/app/src/main/java/com/scrolless/app/overlay/TimerOverlayManagerImpl.kt
@@ -1,3 +1,7 @@
+/*
+ * Copyright (C) 2025, Scrolless
+ * All rights reserved.
+ */
 package com.scrolless.app.overlay
 
 import android.content.Context
@@ -20,8 +24,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 
 /**
  * Implementation of TimerOverlayManager that displays a timer overlay on top of the brain rot content.
@@ -60,7 +64,6 @@ class TimerOverlayManagerImpl @Inject constructor(
      * Displays the timer overlay on screen, if it's not already visible.
      */
     override fun show() {
-
         // If already showing, do nothing
         if (overlayView != null) return
 
@@ -125,7 +128,6 @@ class TimerOverlayManagerImpl @Inject constructor(
      * @param startTimeMillis The starting point for the timer
      */
     private fun startTimer(startTimeMillis: Long) {
-
         // Cancel any existing timer before starting a new one
         stopTimer()
 
@@ -146,7 +148,6 @@ class TimerOverlayManagerImpl @Inject constructor(
         timerUpdateJob = null
     }
 
-
     /**
      * Enables dragging of the overlay view, updating and persisting position to [appProvider].
      */
@@ -189,4 +190,4 @@ class TimerOverlayManagerImpl @Inject constructor(
             },
         )
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt b/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
index 9d73124..f2cea1b 100644
--- a/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
+++ b/app/src/main/java/com/scrolless/app/services/BlockControllerImpl.kt
@@ -31,7 +31,6 @@ class BlockControllerImpl(
      * @param blockConfig Configuration for blocking options.
      */
     override fun init(blockConfig: BlockConfig) {
-
         handler = createHandlerForConfig(blockConfig)
         usageTracker.load() // Make sure we have the latest data
         usageTracker.checkDailyReset() // In case day changed
diff --git a/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt b/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
index e170818..ceecfed 100644
--- a/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
+++ b/app/src/main/java/com/scrolless/app/services/ScrollessBlockAccessibilityService.kt
@@ -13,7 +13,6 @@ import android.view.accessibility.AccessibilityEvent
 import android.view.accessibility.AccessibilityNodeInfo
 import com.scrolless.app.features.home.BlockOption
 import com.scrolless.app.overlay.TimerOverlayManager
-import com.scrolless.app.overlay.TimerOverlayManagerImpl
 import com.scrolless.app.provider.AppProvider
 import com.scrolless.app.provider.UsageTracker
 import dagger.hilt.android.AndroidEntryPoint
@@ -74,7 +73,6 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     override fun onServiceConnected() {
-
         super.onServiceConnected()
         configureServiceInfo()
 
@@ -119,9 +117,7 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     private fun configureServiceInfo() {
-
         val info = AccessibilityServiceInfo().apply {
-
             eventTypes = AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
             feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC
             notificationTimeout = 100
@@ -140,7 +136,6 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
 
     private fun onBlockedContentEntered() {
         if (!currentOnVideos) {
-
             // If timer overlay is enabled, show it
             if (appProvider.timerOverlayEnabled) {
                 timerOverlayManager.show()
@@ -160,9 +155,7 @@ class ScrollessBlockAccessibilityService : AccessibilityService() {
     }
 
     private fun onBlockedContentExited() {
-
         if (currentOnVideos) {
-            
             val sessionTime = System.currentTimeMillis() - timeStartOnBrainRot
 
             // Add to usage in memory
diff --git a/app/src/main/res/layout/overlay_timer.xml b/app/src/main/res/layout/overlay_timer.xml
index fcea91c..573e7ef 100644
--- a/app/src/main/res/layout/overlay_timer.xml
+++ b/app/src/main/res/layout/overlay_timer.xml
@@ -1,4 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2025, Scrolless
+     All rights reserved.
+-->
 <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="wrap_content"
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
index 4215185..2212ed7 100644
--- a/app/src/main/res/values/colors.xml
+++ b/app/src/main/res/values/colors.xml
@@ -151,4 +151,5 @@
     <color name="dark_background">#121212</color>
     <color name="dark_grey">#41424C</color>
     <color name="accent_color">#655967</color>
+    <color name="semi_transparent_black">#66000000</color>
 </resources>
\ No newline at end of file
diff --git a/buildLogic/convention/src/main/kotlin/com/scrolless/app/KotlinAndroid.kt b/buildLogic/convention/src/main/kotlin/com/scrolless/app/KotlinAndroid.kt
index 5db55d7..50b56b6 100644
--- a/buildLogic/convention/src/main/kotlin/com/scrolless/app/KotlinAndroid.kt
+++ b/buildLogic/convention/src/main/kotlin/com/scrolless/app/KotlinAndroid.kt
@@ -20,7 +20,7 @@ import com.android.build.api.dsl.CommonExtension
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.assign // Make sure to never remove this import
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.provideDelegate
diff --git a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
index ce67b33..7b6533e 100644
--- a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
+++ b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
@@ -1,21 +1,41 @@
-/*
- * Copyright (C) 2024, Scrolless
- * All rights reserved.
- */
 package com.scrolless.framework.extensions
 
-import java.time.Duration
 import java.util.Locale
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
+// Define named constants for use in your functions.
+private const val SECONDS_PER_MINUTE = 60
+private const val MINUTES_PER_HOUR = 60
+private const val HOURS_PER_DAY = 24
+
+private const val SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR // 3600
+private const val SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY        // 86400
+
+private const val MILLISECONDS_PER_SECOND = 1000
+private const val MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE // 60000
+private const val MILLISECONDS_PER_HOUR = MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR     // 3600000
+
+/**
+ * Formats a duration, given in seconds, into a human-readable string.
+ *
+ * The function converts a duration (expressed as seconds) into a formatted string that shows
+ * days, hours, minutes, and seconds. Components with a zero value are omitted.
+ *
+ * For example:
+ * - For an input of 3661, the output will be "1 hours 1 minutes 1 seconds".
+ * - For an input of 86400, the output will be "1 days".
+ *
+ * @receiver The duration in seconds.
+ * @return A formatted string representing the duration.
+ */
 fun Long.formatDurationFromSeconds(): String {
-    val seconds = this % 60
-    val minutes = (this / 60) % 60
-    val hours = (this / (60 * 60)) % 24
-    val days = this / (60 * 60 * 24)
+    val seconds = this % SECONDS_PER_MINUTE
+    val minutes = (this / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR
+    val hours = (this / SECONDS_PER_HOUR) % HOURS_PER_DAY
+    val days = this / SECONDS_PER_DAY
 
     val formattedDuration = StringBuilder()
 
@@ -38,10 +58,22 @@ fun Long.formatDurationFromSeconds(): String {
     return formattedDuration.toString().trim()
 }
 
+/**
+ * Formats a duration given in milliseconds into a compact time representation.
+ *
+ * The conversion uses hours, minutes, and seconds markers ("h", "m", "s"). Components that
+ * evaluate to zero are omitted, except when all components are zero, then "0s" is appended.
+ *
+ * For example:
+ * - An input of 3661000 will result in "1h1m1s".
+ *
+ * @receiver The duration in milliseconds.
+ * @return A compact string representation of the duration.
+ */
 fun Long.formatTime(): String {
-    val hours = this / (1000 * 60 * 60)
-    val minutes = (this % (1000 * 60 * 60)) / (1000 * 60)
-    val seconds = (this % (1000 * 60)) / 1000
+    val hours = this / MILLISECONDS_PER_HOUR
+    val minutes = (this % MILLISECONDS_PER_HOUR) / MILLISECONDS_PER_MINUTE
+    val seconds = (this % MILLISECONDS_PER_MINUTE) / MILLISECONDS_PER_SECOND
 
     return buildString {
         if (hours > 0) append("${hours}h")
@@ -50,7 +82,19 @@ fun Long.formatTime(): String {
     }
 }
 
-
+/**
+ * Converts a duration given in milliseconds into a readable time string.
+ *
+ * If the duration contains one or more hours, the output format is "hh:mm:ss", otherwise it is
+ * "mm:ss".
+ *
+ * For example:
+ * - An input of 3661000 will yield "01:01:01".
+ * - An input of 61000 will yield "01:01".
+ *
+ * @receiver The duration in milliseconds.
+ * @return A time string formatted to "hh:mm:ss" or "mm:ss" based on the duration.
+ */
 fun Long.getReadableTime(): String {
     val duration = this.milliseconds
     val hours = duration.inWholeHours
@@ -58,18 +102,27 @@ fun Long.getReadableTime(): String {
     val seconds = (duration - hours.hours - minutes.minutes).inWholeSeconds
 
     return if (hours > 0) {
-        String.format("%02d:%02d:%02d", hours, minutes, seconds)
+        String.format(Locale.US, "%02d:%02d:%02d", hours, minutes, seconds)
     } else {
-        String.format("%02d:%02d", minutes, seconds)
+        String.format(Locale.US, "%02d:%02d", minutes, seconds)
     }
 }
 
-
+/**
+ * Formats a duration, given in seconds as an integer, into a human-readable string.
+ *
+ * This function performs the same conversion as [Long.formatDurationFromSeconds] but accepts
+ * the duration as an [Int]. It converts the given seconds into days, hours, minutes, and seconds,
+ * omitting components with a zero value.
+ *
+ * @receiver The duration in seconds.
+ * @return A formatted string representing the duration.
+ */
 fun Int.formatDurationFromSeconds(): String {
-    val seconds = this % 60
-    val minutes = (this / 60) % 60
-    val hours = (this / (60 * 60)) % 24
-    val days = this / (60 * 60 * 24)
+    val seconds = this % SECONDS_PER_MINUTE
+    val minutes = (this / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR
+    val hours = (this / SECONDS_PER_HOUR) % HOURS_PER_DAY
+    val days = this / SECONDS_PER_DAY
 
     val formattedDuration = StringBuilder()
 
@@ -90,4 +143,4 @@ fun Int.formatDurationFromSeconds(): String {
     }
 
     return formattedDuration.toString().trim()
-}
+}
\ No newline at end of file
diff --git a/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt b/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
index 919c560..2c9a1a6 100644
--- a/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
+++ b/libraries/framework/src/main/java/com/scrolless/framework/extensions/ViewExtension.kt
@@ -28,6 +28,23 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
+// Animation durations and scale factors
+private const val FADE_DURATION_MS = 150L
+private const val SCALE_DOWN_DURATION_MS = 100L
+private const val PAUSE1_DURATION_MS = 100L
+private const val SCALE_UP_DURATION_MS = 200L
+private const val PAUSE2_DURATION_MS = 400L
+private const val FADE_OUT_DURATION_MS = 200L
+
+private const val INITIAL_SCALE = 1f
+private const val SCALE_DOWN_FACTOR = 0.9f
+private const val SCALE_UP_FACTOR = 1.1f
+private const val FINAL_SCALE = 0f
+
+// Default debounce time for safe click listener
+private const val DEFAULT_DEBOUNCE_TIME_MS = 600L
+
+// Extension functions on View for visibility handling
 fun View.beInvisible() {
     visibility = View.INVISIBLE
 }
@@ -40,14 +57,14 @@ fun View.beGone() {
     visibility = View.GONE
 }
 
+// Execute callback after the global layout
 fun View.onGlobalLayout(callback: () -> Unit) {
     viewTreeObserver?.addOnGlobalLayoutListener(
-        object : ViewTreeObserver.OnGlobalLayoutListener {
+        object :
+            ViewTreeObserver.OnGlobalLayoutListener {
             override fun onGlobalLayout() {
-                if (viewTreeObserver != null) {
-                    viewTreeObserver.removeOnGlobalLayoutListener(this)
-                    callback()
-                }
+                viewTreeObserver?.removeOnGlobalLayoutListener(this)
+                callback()
             }
         },
     )
@@ -64,112 +81,129 @@ fun View.performHapticFeedback() = performHapticFeedback(
     HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING,
 )
 
+// Fade in the view using the defined duration
 fun View.fadeIn() {
     animate()
         .alpha(1f)
-        .setDuration(150L)
+        .setDuration(FADE_DURATION_MS)
         .withStartAction { beVisible() }
         .start()
 }
 
+// Fade out the view using the defined duration
 fun View.fadeOut() {
     animate()
         .alpha(0f)
-        .setDuration(150L)
+        .setDuration(FADE_DURATION_MS)
         .withEndAction { beGone() }
         .start()
 }
 
-
 /**
  * Extension function for View that runs a hide animation sequence:
- * 1. Scale down from 1.0 to 0.9 over 100 ms.
- * 2. Pause for 100 ms.
- * 3. Scale up from 0.9 to 1.1 over 200 ms.
- * 4. Pause for 400 ms.
- * 5. Fade out and shrink (scale to 0 and alpha to 0) over 200 ms.
+ * 1. Scale down from INITIAL_SCALE to SCALE_DOWN_FACTOR over SCALE_DOWN_DURATION_MS.
+ * 2. Pause for PAUSE1_DURATION_MS.
+ * 3. Scale up from SCALE_DOWN_FACTOR to SCALE_UP_FACTOR over SCALE_UP_DURATION_MS.
+ * 4. Pause for PAUSE2_DURATION_MS.
+ * 5. Fade out and shrink (scale to FINAL_SCALE and alpha to 0) over FADE_OUT_DURATION_MS.
  *
  * @param onAnimationEnd Called when the entire animation sequence finishes.
  */
 fun View.fadeOutWithBounceAnimation(onAnimationEnd: () -> Unit) {
+    val view = this
 
-    val view = this;
-
-    // Inline helper: create a dummy animator that effectively pauses.
-    fun pause(duration: Long) = ObjectAnimator.ofFloat(this, "alpha", this.alpha, this.alpha).apply {
-        this.duration = duration
-    }
+    // Helper: create a dummy animator that effectively pauses.
+    fun pause(duration: Long) =
+        ObjectAnimator.ofFloat(this, "alpha", this.alpha, this.alpha).apply {
+            this.duration = duration
+        }
 
-    // 1. Scale down from 1.0 to 0.9 in 100 ms.
+    // 1. Scale down
     val scaleDown = AnimatorSet().apply {
         playTogether(
-            ObjectAnimator.ofFloat(view, "scaleX", 1f, 0.9f).apply { duration = 100 },
-            ObjectAnimator.ofFloat(view, "scaleY", 1f, 0.9f).apply { duration = 100 }
+            ObjectAnimator.ofFloat(view, "scaleX", INITIAL_SCALE, SCALE_DOWN_FACTOR)
+                .apply { duration = SCALE_DOWN_DURATION_MS },
+            ObjectAnimator.ofFloat(view, "scaleY", INITIAL_SCALE, SCALE_DOWN_FACTOR)
+                .apply { duration = SCALE_DOWN_DURATION_MS },
         )
     }
 
-    // 2. Pause for 100 ms.
-    val pause1 = pause(100)
+    // 2. Pause for PAUSE1_DURATION_MS.
+    val pause1 = pause(PAUSE1_DURATION_MS)
 
-    // 3. Scale up from 0.9 to 1.1 in 200 ms.
+    // 3. Scale up
     val scaleUp = AnimatorSet().apply {
         playTogether(
-            ObjectAnimator.ofFloat(view, "scaleX", 0.9f, 1.1f).apply { duration = 200 },
-            ObjectAnimator.ofFloat(view, "scaleY", 0.9f, 1.1f).apply { duration = 200 }
+            ObjectAnimator.ofFloat(view, "scaleX", SCALE_DOWN_FACTOR, SCALE_UP_FACTOR)
+                .apply { duration = SCALE_UP_DURATION_MS },
+            ObjectAnimator.ofFloat(view, "scaleY", SCALE_DOWN_FACTOR, SCALE_UP_FACTOR)
+                .apply { duration = SCALE_UP_DURATION_MS },
         )
     }
 
-    // 4. Pause for 400 ms.
-    val pause2 = pause(400)
+    // 4. Pause for PAUSE2_DURATION_MS.
+    val pause2 = pause(PAUSE2_DURATION_MS)
 
-    // 5. Fade out and shrink (scale to 0 and alpha to 0) in 200 ms.
+    // 5. Fade out and shrink.
     val fadeOut = AnimatorSet().apply {
         playTogether(
-            ObjectAnimator.ofFloat(view, "scaleX", 1.1f, 0f).apply { duration = 200 },
-            ObjectAnimator.ofFloat(view, "scaleY", 1.1f, 0f).apply { duration = 200 },
-            ObjectAnimator.ofFloat(view, "alpha", 1f, 0f).apply { duration = 200 }
+            ObjectAnimator.ofFloat(view, "scaleX", SCALE_UP_FACTOR, FINAL_SCALE)
+                .apply { duration = FADE_OUT_DURATION_MS },
+            ObjectAnimator.ofFloat(view, "scaleY", SCALE_UP_FACTOR, FINAL_SCALE)
+                .apply { duration = FADE_OUT_DURATION_MS },
+            ObjectAnimator.ofFloat(view, "alpha", 1f, 0f)
+                .apply { duration = FADE_OUT_DURATION_MS },
         )
     }
 
-    // Chain the animations sequentially.
+    // Chain and start the animation sequence.
     AnimatorSet().apply {
         playSequentially(scaleDown, pause1, scaleUp, pause2, fadeOut)
-        addListener(object : AnimatorListenerAdapter() {
-            override fun onAnimationEnd(animation: Animator) {
-                onAnimationEnd()
-            }
-        })
+        addListener(
+            object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    onAnimationEnd()
+                }
+            },
+        )
         start()
     }
 }
 
-val Context.inflater: LayoutInflater get() = LayoutInflater.from(this)
+// Extension property on Context to obtain a LayoutInflater.
+val Context.inflater: LayoutInflater
+    get() = LayoutInflater.from(this)
 
+// Extension function to inflate a layout from a ViewGroup.
 fun ViewGroup.inflate(layoutRes: Int): View =
     LayoutInflater.from(context).inflate(layoutRes, this, false)
 
+// Extension to handle focus change.
 fun View.onFocusChanged(func: (Boolean) -> Unit) {
-    this.onFocusChangeListener = View.OnFocusChangeListener { _, hasFocus -> func.invoke(hasFocus) }
+    onFocusChangeListener = View.OnFocusChangeListener { _, hasFocus ->
+        func(hasFocus)
+    }
 }
 
-fun View.setSafeOnClickListener(debounceTime: Long = 600L, action: () -> Unit) {
-    this.setOnClickListener(
+// Safe click listener with a debounce to avoid rapid multiple clicks.
+fun View.setSafeOnClickListener(
+    debounceTime: Long = DEFAULT_DEBOUNCE_TIME_MS,
+    action: () -> Unit
+) {
+    setOnClickListener(
         object : View.OnClickListener {
             private var lastClickTime: Long = 0
 
             override fun onClick(v: View) {
-                if (SystemClock.elapsedRealtime() - lastClickTime < debounceTime) {
-                    return
-                } else {
-                    action()
-                }
-
+                if (SystemClock.elapsedRealtime() - lastClickTime < debounceTime) return
+                action()
                 lastClickTime = SystemClock.elapsedRealtime()
             }
         },
     )
 }
 
+// Extension to delay a block execution, tied to the view's lifecycle.
 fun View.delayOnLifecycle(
     durationInMillis: Long,
     dispatcher: CoroutineDispatcher = Dispatchers.Main,
@@ -181,14 +215,15 @@ fun View.delayOnLifecycle(
     }
 }
 
+// Extension function to update the margins of a view.
 fun View.updateMargins(
     start: Int? = null,
     top: Int? = null,
     end: Int? = null,
     bottom: Int? = null
 ) {
-    if (this.layoutParams is ViewGroup.MarginLayoutParams) {
-        val params = this.layoutParams as ViewGroup.MarginLayoutParams
+    if (layoutParams is ViewGroup.MarginLayoutParams) {
+        val params = layoutParams as ViewGroup.MarginLayoutParams
         params.setMargins(
             start ?: params.leftMargin,
             top ?: params.topMargin,
@@ -198,6 +233,7 @@ fun View.updateMargins(
     }
 }
 
+// Extension to add window insets to the view's padding.
 fun View.addInsetsByPadding(
     top: Boolean = false,
     bottom: Boolean = false,
@@ -210,7 +246,8 @@ fun View.addInsetsByPadding(
             insets.getInsets(WindowInsetsCompat.Type.displayCutout()),
         )
         if (top) {
-            val lastTopPadding = view.getTag(R.id.view_add_insets_padding_top_tag) as? Int ?: 0
+            val lastTopPadding =
+                view.getTag(R.id.view_add_insets_padding_top_tag) as? Int ?: 0
             val newTopPadding = inset.top
             view.setTag(R.id.view_add_insets_padding_top_tag, newTopPadding)
             view.updatePadding(top = view.paddingTop - lastTopPadding + newTopPadding)
@@ -220,20 +257,26 @@ fun View.addInsetsByPadding(
                 view.getTag(R.id.view_add_insets_padding_bottom_tag) as? Int ?: 0
             val newBottomPadding = inset.bottom
             view.setTag(R.id.view_add_insets_padding_bottom_tag, newBottomPadding)
-            view.updatePadding(bottom = view.paddingBottom - lastBottomPadding + newBottomPadding)
+            view.updatePadding(
+                bottom = view.paddingBottom - lastBottomPadding + newBottomPadding,
+            )
         }
         if (left) {
-            val lastLeftPadding = view.getTag(R.id.view_add_insets_padding_left_tag) as? Int ?: 0
+            val lastLeftPadding =
+                view.getTag(R.id.view_add_insets_padding_left_tag) as? Int ?: 0
             val newLeftPadding = inset.left
             view.setTag(R.id.view_add_insets_padding_left_tag, newLeftPadding)
             view.updatePadding(left = view.paddingLeft - lastLeftPadding + newLeftPadding)
         }
         if (right) {
-            val lastRightPadding = view.getTag(R.id.view_add_insets_padding_right_tag) as? Int ?: 0
+            val lastRightPadding =
+                view.getTag(R.id.view_add_insets_padding_right_tag) as? Int ?: 0
             val newRightPadding = inset.right
             view.setTag(R.id.view_add_insets_padding_right_tag, newRightPadding)
-            view.updatePadding(right = view.paddingRight - lastRightPadding + newRightPadding)
+            view.updatePadding(
+                right = view.paddingRight - lastRightPadding + newRightPadding,
+            )
         }
-        return@setOnApplyWindowInsetsListener insets
+        insets
     }
 }

From 0488ab25c862920975dc85e357ea13db9918767d Mon Sep 17 00:00:00 2001
From: Duarte Barbosa <duartebarbosapt@gmail.com>
Date: Wed, 5 Feb 2025 20:03:07 +0000
Subject: [PATCH 3/3] Fix spotless errors

---
 .../scrolless/framework/extensions/LongExtension.kt    | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
index 7b6533e..99c50cc 100644
--- a/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
+++ b/libraries/framework/src/main/java/com/scrolless/framework/extensions/LongExtension.kt
@@ -1,3 +1,7 @@
+/*
+ * Copyright (C) 2025, Scrolless
+ * All rights reserved.
+ */
 package com.scrolless.framework.extensions
 
 import java.util.Locale
@@ -12,11 +16,11 @@ private const val MINUTES_PER_HOUR = 60
 private const val HOURS_PER_DAY = 24
 
 private const val SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR // 3600
-private const val SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY        // 86400
+private const val SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY // 86400
 
 private const val MILLISECONDS_PER_SECOND = 1000
 private const val MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE // 60000
-private const val MILLISECONDS_PER_HOUR = MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR     // 3600000
+private const val MILLISECONDS_PER_HOUR = MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR // 3600000
 
 /**
  * Formats a duration, given in seconds, into a human-readable string.
@@ -143,4 +147,4 @@ fun Int.formatDurationFromSeconds(): String {
     }
 
     return formattedDuration.toString().trim()
-}
\ No newline at end of file
+}