fix service termination on some chinese OEM devices

some chinese OEM devices have aggressive battery optimizations which
would kill the service when the overlay option is enabled and the
application is swiped away from the recent apps list or after some time
has passed, the fix is a litte bit crude for now. the app saves the last
remaining timeout to the device's storage every one second and then when
the service is killed, it retreives the last saved remaining timeout and
then restarts the service.

This may put a strain on the device's storage but can be avoided if the
overlay is disabled while running on these devices

Change-Id: I7dc0b984499d0e23d1fd5e80b642d7b5c93d9634
Signed-off-by: AbdAlMoniem AlHifnawy <hifnawy_moniem@hotmail.com>

Author: abdalmoniem

.github/workflows/publish_release.yml

@@ -9,6 +9,7 @@ on:
         required: true
         type: choice
         options:
+          - v1.8.0
           - v1.7.5
           - v1.7.2
           - v1.7.1

app/build.gradle.kts

@@ -15,8 +15,8 @@ android {
         applicationId = "com.hifnawy.caffeinate"
         minSdk = 24
         targetSdk = 35
-        versionCode = 29
-        versionName = "1.7.5"
+        versionCode = 30
+        versionName = "1.8.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/AndroidManifest.xml

@@ -31,7 +31,7 @@
                 <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
-                <!-- <category android:name="android.intent.category.DEFAULT" /> -->
+                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
 

app/src/main/java/com/hifnawy/caffeinate/services/KeepAwakeService.kt

@@ -287,10 +287,13 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
             this@KeepAwakeService.isDimmingEnabled = isDimmingEnabled
             this@KeepAwakeService.isWhileLockedEnabled = isWhileLockedEnabled
         }
-
+        val restartDuration = when (val lastTimeout = intent.getLongExtra(Intent.EXTRA_INTENT, -1L)) {
+            -1L  -> null
+            else -> lastTimeout.seconds
+        }
         when (keepAwakeServiceAction) {
             ACTION_START                  -> prepareService()
-            ACTION_RESTART                -> restart(caffeinateApplication)
+            ACTION_RESTART                -> restart(caffeinateApplication, restartDuration)
             ACTION_STOP                   -> stopCaffeine()
             ACTION_CHANGE_TIMEOUT         -> startNextTimeout(caffeinateApplication, debounce = false)
             ACTION_CHANGE_DIMMING_ENABLED -> sharedPreferences.isDimmingEnabled = !sharedPreferences.isDimmingEnabled
@@ -305,6 +308,28 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
      * This method is triggered when the user swipes away the app from the recent apps list.
      * It is responsible for cleaning up resources and stopping the caffeine session.
      *
+     *
+     * > TODO: Fix service stopping when overlay is shown and the app is swiped away
+     *         from the recent apps list on some chinese devices.
+     *
+     * > On some chinese devices, the service is stopped when the user swipes away the app
+     *   from the recent apps list. but the service is not stopped gracefully, so we need
+     *   to stop the service manually. This also seems to only happen when the overlay is
+     *   shown; but if it is not, the service is not stopped for some reason.
+     *
+     * > For now there is no way around this limitation except checking the device model
+     *   and gracefully stopping the service only if the overlay is shown. We use the
+     *   isOverlayEnabled flag from the shared preferences to check if the overlay was
+     *   shown or not before the service got killed, since the isOverlayEnabled flag will
+     *   be reset after the service instance is killed.
+     *
+     * > For now we can restart the service manually when the user swipes away the app
+     *   from the recent apps list passing the last remaining timeout to the service.
+     *   This is a crude solution, and may put a strain on the device's storage since
+     *   it will store the last remaining timeout in the shared preferences every time
+     *   the service status is updated. which is every one second.
+     *
+     *
      * @param rootIntent [Intent?] The root Intent that was used to launch the task.
      * This may be `null` if the task was removed via the task manager.
      *
@@ -313,8 +338,13 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
     override fun onTaskRemoved(rootIntent: Intent?) {
         super.onTaskRemoved(rootIntent)
 
-        Log.d("${this::class.simpleName} service removed from task manager!")
-        if (sharedPreferences.isOverlayEnabled) stopCaffeine()
+        Log.d("${this::class.simpleName} service removed from task manager! restarting...")
+
+        Intent(this, KeepAwakeService::class.java).apply {
+            action = ACTION_RESTART.name
+            putExtra(Intent.EXTRA_INTENT, sharedPreferences.lastRemainingTimeout)
+            startService(this)
+        }
     }
 
     /**
@@ -383,6 +413,12 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
 
             is ServiceStatus.Stopped -> stopForeground(STOP_FOREGROUND_REMOVE)
         }
+        /* TODO: Remove or find a way to infer the service status without using shared preferences
+         *       because this will put a strain on the device's storage since it will store
+         *       the last remaining timeout in the shared preferences every time the service
+         *       status is updated. which is every one second.
+         */
+        sharedPreferences.isServiceRunning = status is ServiceStatus.Running
     }
 
     /**
@@ -912,8 +948,10 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
          * ```
          *
          * @param caffeinateApplication [CaffeinateApplication] The application context.
+         * @param startTimeout [Duration] The timeout duration to use when starting the service. If `null`, the service will use the previously set timeout.
          */
-        fun restart(caffeinateApplication: CaffeinateApplication) = toggleState(caffeinateApplication, STATE_START)
+        fun restart(caffeinateApplication: CaffeinateApplication, startTimeout: Duration? = null) =
+                toggleState(caffeinateApplication, STATE_START, startTimeout)
 
         /**
          * Toggles the state of the KeepAwakeService.
@@ -930,7 +968,7 @@ class KeepAwakeService : Service(), SharedPrefsObserver, ServiceStatusObserver {
         fun toggleState(
                 caffeinateApplication: CaffeinateApplication,
                 newKeepAwakeServiceState: KeepAwakeServiceState,
-                startTimeout: Duration? = null,
+                startTimeout: Duration? = null
         ): Unit = caffeinateApplication.run {
             Log.d("newState: $newKeepAwakeServiceState")
             val start = when (newKeepAwakeServiceState) {

app/src/main/java/com/hifnawy/caffeinate/utils/SharedPrefsManager.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import androidx.appcompat.app.AppCompatDelegate
 import com.hifnawy.caffeinate.CaffeinateApplication
 import com.hifnawy.caffeinate.services.Observer
+import com.hifnawy.caffeinate.services.ServiceStatus
 import com.hifnawy.caffeinate.ui.CheckBoxItem
 import com.hifnawy.caffeinate.utils.DurationExtensionFunctions.toFormattedTime
 import com.hifnawy.caffeinate.utils.DurationExtensionFunctions.toLocalizedFormattedTime
@@ -14,6 +15,8 @@ import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.ENABLE_DI
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.ENABLE_MATERIAL_YOU
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.ENABLE_OVERLAY
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.ENABLE_WHILE_LOCKED
+import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.IS_SERVICE_RUNNING
+import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.LAST_REMAINING_TIMEOUT
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.THEME
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.SharedPrefsKeys.TIMEOUT_CHECK_BOXES
 import com.hifnawy.caffeinate.utils.SharedPrefsManager.Theme.DARK
@@ -90,6 +93,26 @@ class SharedPrefsManager(private val caffeinateApplication: CaffeinateApplicatio
          * A [List] of [CheckBoxItem] values indicating the timeouts that should be displayed in the RecyclerView.
          */
         TIMEOUT_CHECK_BOXES,
+
+        /**
+         * A [Boolean] value indicating whether the service is running.
+         *
+         * > TODO: Remove or find a way to infer the service status without using shared preferences
+         *         because this will put a strain on the device's storage since it will store
+         *         the last remaining timeout in the shared preferences every time the service
+         *         status is updated. which is every one second.
+         */
+        IS_SERVICE_RUNNING,
+
+        /**
+         * A [Long] value indicating the last remaining timeout value stored in shared preferences.
+         *
+         * > TODO: Remove or find a way to infer the service status without using shared preferences
+         *         because this will put a strain on the device's storage since it will store
+         *         the last remaining timeout in the shared preferences every time the service
+         *         status is updated. which is every one second.
+         */
+        LAST_REMAINING_TIMEOUT
     }
 
     /**
@@ -261,6 +284,51 @@ class SharedPrefsManager(private val caffeinateApplication: CaffeinateApplicatio
             checkBoxItem.copy(text = checkBoxItem.duration.toLocalizedFormattedTime(caffeinateApplication.localizedApplicationContext))
         }).apply()
 
+    /**
+     * Retrieves or sets whether the service is running.
+     *
+     * This property allows the application to determine if the service is currently running. The value is stored in
+     * shared preferences and persists across sessions.
+     *
+     * > TODO: Remove or find a way to infer the service status without using shared preferences
+     *         because this will put a strain on the device's storage since it will store
+     *         the last remaining timeout in the shared preferences every time the service
+     *         status is updated. which is every one second.
+     *
+     * @return [Boolean] `true` if the service is running, `false` otherwise.
+     */
+    var isServiceRunning: Boolean
+        get() = sharedPreferences.getBoolean(IS_SERVICE_RUNNING.name, false)
+        set(value) {
+            sharedPreferences.edit().putBoolean(IS_SERVICE_RUNNING.name, value).apply()
+            val timeout = when (value) {
+                true  -> (caffeinateApplication.lastStatusUpdate as ServiceStatus.Running).remaining.inWholeSeconds
+                false -> -1L
+            }
+
+            sharedPreferences.edit().putLong(LAST_REMAINING_TIMEOUT.name, timeout).apply()
+        }
+
+    /**
+     * Retrieves the last remaining timeout value stored in shared preferences.
+     *
+     * This property returns the last remaining timeout value stored in shared preferences, which is the value of the
+     * remaining timeout at the time the service was last stopped. The value is stored in shared preferences and persists
+     * across sessions.
+     *
+     * If the service is not running or the last remaining timeout has not been stored, this property returns `-1`.
+     *
+     * > TODO: Remove or find a way to infer the service status without using shared preferences
+     *         because this will put a strain on the device's storage since it will store
+     *         the last remaining timeout in the shared preferences every time the service
+     *         status is updated. which is every one second.
+     *
+     * @return [Long] The last remaining timeout value stored in shared preferences, or `-1` if the service is not running
+     *         or the last remaining timeout has not been stored.
+     */
+    val lastRemainingTimeout: Long
+        get() = sharedPreferences.getLong(LAST_REMAINING_TIMEOUT.name, -1)
+
     /**
      * Notifies all registered observers of a change in the shared preferences.
      *

app/src/main/res/xml/widget_info.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
-    android:description="@string/app_name"
     android:configure="com.hifnawy.caffeinate.ui.WidgetConfigurationActivity"
+    android:description="@string/app_name"
     android:initialKeyguardLayout="@layout/widget"
     android:initialLayout="@layout/widget"
     android:previewImage="@drawable/widget_preview"
@@ -12,4 +12,5 @@
     android:targetCellHeight="1"
     android:updatePeriodMillis="86400000"
     android:widgetCategory="home_screen"
+    android:widgetFeatures="reconfigurable"
     tools:ignore="UnusedAttribute" />

fastlane/metadata/android/en-US/changelogs/30.txt

@@ -0,0 +1,31 @@
+
+* added show overlay option
+* fix allow while locked not working as expected
+* added configureable widget
+* bug fixes and code improvements
+* fix service termination on some chinese OEM devices
+
+- added an option to show or hide an overlay with the remaining timeout
+  on the top right/left of the screen
+  the overlay option may be required on some devices in order for the app to
+  continue working in the background
+  if the overlay option is enabled and the app is closed from the recents
+  menu, the timeout will be cancelled (seems that this is a restriciton
+  from android, if there is an overlay enabled and the app is closed,
+  everything gets terminated)
+
+- fixed issue where the allow while locked toggle worked opposite to the intended behavior
+
+- the widget's background can now be configured to be on or off
+
+- some chinese OEM devices have aggressive battery optimizations which
+  would kill the service when the overlay option is enabled and the
+  application is swiped away from the recent apps list or after some time
+  has passed, the fix is a litte bit crude for now. the app saves the last
+  remaining timeout to the device's storage every one second and then when
+  the service is killed, it retreives the last saved remaining timeout and
+  then restarts the service.
+  
+  This may put a strain on the device's storage but can be avoided if the
+  overlay is disabled while running on these devices
+

git_hooks/get_changelog.sh

@@ -17,17 +17,21 @@ if [ -z "$latestTag" ] || [ -z "$previousTag" ]; then
   exit 1
 fi
 
-echo "Generating Changelog..."
-while IFS= read -r body && IFS= read -r subject; do
-  subject_trimmed=$(echo "$subject" | sed -e 's/Change-Id:\s*.*//' | sed -e 's/Signed-off-by:\s*.*//' | sed 's/__END__//' | sed -e 's/^[^a-zA-Z0-9]*//')
-  body_trimmed=$(echo "$body" | sed -e 's/Change-Id:\s*.*//' | sed -e 's/Signed-off-by:\s*.*//' | sed 's/__END__//' | sed -e 's/^[^a-zA-Z0-9]*//')
+echo "Generating Changelog between $previousTag and $latestTag..."
+while read commit_hash
+do
+  subject=$(git log --format=%s -n 1 $commit_hash | sed -e 's/Change-Id:\s*.*//' | sed -e 's/Signed-off-by:\s*.*//' | sed -e 's/^[^a-zA-Z0-9]*//')
+  body=$(git log --format=%b -n 1 $commit_hash | sed -e 's/Change-Id:\s*.*//' | sed -e 's/Signed-off-by:\s*.*//' | sed -e 's/^[^a-zA-Z0-9]*//')
 
-  [[ -n "$subject_trimmed" ]] && echo "* $subject_trimmed"
-  [[ -n "$body_trimmed" ]] && echo "- $body_trimmed"
-
-  subjects+=("$subject_trimmed")
-  bodies+=("$body_trimmed")
-done < <(git log "$previousTag".."$latestTag" --pretty=format:"%s%n%b%n__END__")
+  echo "Commit: $commit_hash"
+  echo "* $subject"
+  subjects+=("$subject")
+  if [[ -n "$body" ]]; then
+    echo "- $body"
+    bodies+=("$body")
+  fi
+  echo "------------------------------"
+done < <(git log "$previousTag".."$latestTag" --pretty=format:"%H")
 
 changeLogs=${#subjects[@]}
 
@@ -36,12 +40,21 @@ if [ $changeLogs -gt 0 ]; then
 
   echo "" > "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
 
-  for subject in "${subjects[@]}"; do
-    [[ -n "$subject" ]] && echo "* $subject" >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+  for index in $(seq ${#subjects[@]} -1 1); do
+    subject=${subjects[$index-1]}
+    if [[ -n "$subject" ]]; then
+      echo "* $subject" | sed '2,$s/^/  /' >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+    fi
   done
 
-  for body in "${bodies[@]}"; do
-    [[ -n "$body" ]] && echo "- $body" >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+  echo >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+
+  for index in $(seq ${#bodies[@]} -1 1); do
+    body=${bodies[$index-1]}
+    if [[ -n "$body" ]]; then
+      echo "- $body" | sed '2,$s/^/  /' >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+      echo >> "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/$versionCode.txt"
+    fi
   done
 
   currentCommitHash=$(git rev-parse HEAD)
@@ -53,12 +66,15 @@ if [ $changeLogs -gt 0 ]; then
     echo
 
     git add "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/"
-    git commit -sm "updated $changeLogs change logs(s)"
+    git commit -sm "updated $changeLogs change log(s)"
   else
     echo "commit '$currentCommitHash' is not on the remote branch, amending..."
     echo
 
     git add "$gitTopLevel/fastlane/metadata/android/en-US/changeLogs/"
     git commit --amend --no-edit
   fi
+else
+  echo "No / $changeLogs change log(s) found between $previousTag and $latestTag"
 fi
+