Merge pull request #49 from 05nelsonm/mn/refactor/last-action

Refactors lastServiceAction tracking

Author: 05nelsonm

topl-service/src/main/java/io/matthewnelson/topl_service/lifecycle/BackgroundManager.kt

@@ -72,6 +72,7 @@ import androidx.lifecycle.OnLifecycleEvent
 import androidx.lifecycle.ProcessLifecycleOwner
 import io.matthewnelson.topl_service.service.BaseService
 import io.matthewnelson.topl_service.service.TorService
+import io.matthewnelson.topl_service.service.components.actions.ServiceActionProcessor
 import io.matthewnelson.topl_service.service.components.binding.BaseServiceConnection
 import io.matthewnelson.topl_service.util.ServiceConsts
 
@@ -255,15 +256,20 @@ class BackgroundManager internal constructor(
     private fun applicationMovedToForeground() {
         // if the last _accepted_ ServiceAction to be issued by the Application was not to STOP
         // the service, then we want to put it back in the state it was in
-        if (!BaseService.wasLastAcceptedServiceActionStop()) {
+        if (!ServiceActionProcessor.wasLastAcceptedServiceActionStop()) {
             BaseServiceConnection.serviceBinder?.cancelExecuteBackgroundPolicyJob()
-            BaseService.startService(BaseService.getAppContext(), serviceClass, serviceConnection)
+            BaseService.startService(
+                BaseService.getAppContext(),
+                serviceClass,
+                serviceConnection,
+                includeIntentActionStart = false
+            )
         }
     }
 
     @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
     private fun applicationMovedToBackground() {
-        if (!BaseService.wasLastAcceptedServiceActionStop())
+        if (!ServiceActionProcessor.wasLastAcceptedServiceActionStop())
             BaseServiceConnection.serviceBinder?.executeBackgroundPolicyJob(policy, executionDelay)
     }
 }

topl-service/src/main/java/io/matthewnelson/topl_service/service/BaseService.kt

@@ -166,12 +166,29 @@ internal abstract class BaseService: Service() {
         /// ServiceStartup ///
         //////////////////////
 
+        /**
+         * Starts the Service. Setting [includeIntentActionStart] to `false`, will not include
+         * [ServiceActionName.START] in the Intent as an action so that [onStartCommand] knows
+         * to set the [ServiceActions.Start.updateLastAction] to false. This allows for
+         * distinguishing what is coming from the application (either by user input, or how
+         * the application has the library implemented), and what is coming from this library.
+         * It makes keeping the state of the service in sync with the application's desires.
+         *
+         * @param [context]
+         * @param [serviceClass] The Service's class wanting to be started
+         * @param [serviceConn] The [BaseServiceConnection] to bind to
+         * @param [includeIntentActionStart] Boolean for including [ServiceActionName.START] as
+         *   the Intent's Action.
+         * */
         fun startService(
             context: Context,
             serviceClass: Class<*>,
-            serviceConn: BaseServiceConnection
+            serviceConn: BaseServiceConnection,
+            includeIntentActionStart: Boolean = true
         ) {
             val intent = Intent(context.applicationContext, serviceClass)
+            if (includeIntentActionStart)
+                intent.action = ServiceActionName.START
             context.applicationContext.startService(intent)
             context.applicationContext.bindService(intent, serviceConn, Context.BIND_AUTO_CREATE)
         }
@@ -328,12 +345,17 @@ internal abstract class BaseService: Service() {
     }
 
     /**
-     * No matter what Intent comes in, it will update [BaseService.lastAcceptedServiceAction]
-     * with [ServiceActionName.START] and then start Tor.
+     * No matter what Intent comes in, it starts Tor. If the Intent comes with no Action,
+     * it will not update [ServiceActionProcessor.lastServiceAction].
+     *
+     * @see [Companion.startService]
      * */
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        updateLastAcceptedServiceAction(ServiceActionName.START)
-        processServiceAction(ServiceActions.Start())
+        if (intent?.action == ServiceActionName.START)
+            processServiceAction(ServiceActions.Start())
+        else
+            processServiceAction(ServiceActions.Start(updateLastServiceAction = false))
+
         return START_NOT_STICKY
     }
 

topl-service/src/main/java/io/matthewnelson/topl_service/service/TorService.kt

@@ -262,7 +262,7 @@ internal class TorService: BaseService() {
         super.onTaskRemoved(rootIntent)
         broadcastLogger.debug("Task has been removed")
 
-        // Shutdown Tor and stop the Service
-        processServiceAction(ServiceActions.Stop())
+        // Shutdown Tor and stop the Service.
+        processServiceAction(ServiceActions.Stop(updateLastServiceAction = false))
     }
 }

topl-service/src/main/java/io/matthewnelson/topl_service/service/components/actions/ServiceActionProcessor.kt

@@ -72,11 +72,11 @@ import io.matthewnelson.topl_service.util.ServiceConsts
 import kotlinx.coroutines.*
 
 /**
- * [ServiceConsts.ServiceActionName]'s are translated to [ServiceAction]'s,
- * submitted to a queue, and then processed. This allows for sequential execution of
- * individual [ServiceConsts.ServiceActionCommand]'s for each [ServiceAction]
- * and the ability to quickly interrupt execution for reacting to User actions (such as
- * stopping, or clearing the task).
+ * This class allows for sequential execution of individual [ServiceConsts.ServiceActionCommand]'s
+ * for each [ServiceAction] and the ability to quickly interrupt execution for reacting to User
+ * actions (such as stopping, or clearing the task). Because there are various ways to interact
+ * with a Service (via Binding, BroadcastReceiver, or startService), this class acts as the funnel
+ * to standardize things.
  *
  * @param [torService] [BaseService] for interacting with other components of the Service
  * @see [ServiceActions]
@@ -93,6 +93,16 @@ internal class ServiceActionProcessor(private val torService: BaseService): Serv
             restartTorDelayTime = restartMilliseconds
             stopServiceDelayTime = stopServiceMilliseconds
         }
+
+        //////////////////////////
+        /// Last ServiceAction ///
+        //////////////////////////
+        @Volatile
+        @ServiceActionName
+        private var lastServiceAction: String = ServiceActionName.STOP
+
+        fun wasLastAcceptedServiceActionStop(): Boolean =
+            lastServiceAction == ServiceActionName.STOP
     }
 
     private val broadcastLogger = torService.getBroadcastLogger(ServiceActionProcessor::class.java)
@@ -112,6 +122,9 @@ internal class ServiceActionProcessor(private val torService: BaseService): Serv
             }
         }
 
+        if (serviceAction.updateLastAction)
+            lastServiceAction = serviceAction.name
+
         if (addActionToQueue(serviceAction))
             launchProcessQueueJob()
     }
@@ -168,7 +181,7 @@ internal class ServiceActionProcessor(private val torService: BaseService): Serv
         processQueueJob = torService.getScopeIO().launch {
             broadcastDebugMsgWithObjectDetails("Processing Queue: ", this)
 
-            while (actionQueue.isNotEmpty()) {
+            while (actionQueue.isNotEmpty() && isActive) {
                 val serviceAction = actionQueue.elementAtOrNull(0)
                 if (serviceAction == null) {
                     return@launch

topl-service/src/main/java/io/matthewnelson/topl_service/service/components/actions/ServiceActions.kt

@@ -115,6 +115,16 @@ internal sealed class ServiceActions {
                 delayLengthQueue.removeAt(0)
             else
                 0L
+
+        /**
+         * Boolean value for providing [ServiceAction]'s the capability of being issued to
+         * the [ServiceActionProcessor] and notifying that the submitter of the [ServiceAction]
+         * wants [ServiceActionProcessor.lastServiceAction] to be updated.
+         *
+         * @see [Start]
+         * @see [Stop]
+         * */
+        open val updateLastAction: Boolean = true
     }
 
     class NewId: ServiceAction() {
@@ -143,7 +153,7 @@ internal sealed class ServiceActions {
         override val delayLengthQueue = mutableListOf(ServiceActionProcessor.restartTorDelayTime)
     }
 
-    class Start: ServiceAction() {
+    class Start(private val updateLastServiceAction: Boolean = true): ServiceAction() {
 
         @ServiceActionName
         override val name: String = ServiceActionName.START
@@ -152,9 +162,12 @@ internal sealed class ServiceActions {
             get() = arrayOf(
                 ServiceActionCommand.START_TOR
             )
+
+        override val updateLastAction: Boolean
+            get() = updateLastServiceAction
     }
 
-    class Stop: ServiceAction() {
+    class Stop(private val updateLastServiceAction: Boolean = true): ServiceAction() {
 
         @ServiceActionName
         override val name: String = ServiceActionName.STOP
@@ -167,5 +180,8 @@ internal sealed class ServiceActions {
             )
 
         override val delayLengthQueue = mutableListOf(ServiceActionProcessor.stopServiceDelayTime)
+
+        override val updateLastAction: Boolean
+            get() = updateLastServiceAction
     }
 }

topl-service/src/main/java/io/matthewnelson/topl_service/service/components/binding/TorServiceBinder.kt

@@ -83,14 +83,9 @@ internal class TorServiceBinder(private val torService: BaseService): Binder() {
     /**
      * Accepts all [ServiceActions] except [ServiceActions.Start], which gets issued via
      * [io.matthewnelson.topl_service.service.TorService.onStartCommand].
-     *
-     * To be used **only** by interactions coming from the User or Application so
-     * [BaseService.lastAcceptedServiceAction] stays in sync.
      * */
     fun submitServiceAction(serviceAction: ServiceAction) {
         if (serviceAction is ServiceActions.Start) return
-
-        BaseService.updateLastAcceptedServiceAction(serviceAction.name)
         torService.processServiceAction(serviceAction)
     }
 
@@ -127,7 +122,9 @@ internal class TorServiceBinder(private val torService: BaseService): Binder() {
                 BackgroundPolicy.RESPECT_RESOURCES -> {
                     delay(executionDelay)
                     bgMgrBroadcastLogger.debug("Executing background management policy")
-                    torService.processServiceAction(ServiceActions.Stop())
+                    torService.processServiceAction(
+                        ServiceActions.Stop(updateLastServiceAction = false)
+                    )
                 }
             }
         }

topl-service/src/main/java/io/matthewnelson/topl_service/service/components/receiver/TorServiceReceiver.kt

@@ -128,19 +128,13 @@ internal class TorServiceReceiver(private val torService: BaseService): Broadcas
 
             when (val serviceAction = intent.getStringExtra(SERVICE_INTENT_FILTER)) {
                 ServiceActionName.NEW_ID -> {
-                    BaseServiceConnection.serviceBinder?.submitServiceAction(
-                        ServiceActions.NewId()
-                    )
+                    torService.processServiceAction(ServiceActions.NewId())
                 }
                 ServiceActionName.RESTART_TOR -> {
-                    BaseServiceConnection.serviceBinder?.submitServiceAction(
-                        ServiceActions.RestartTor()
-                    )
+                    torService.processServiceAction(ServiceActions.RestartTor())
                 }
                 ServiceActionName.STOP -> {
-                    BaseServiceConnection.serviceBinder?.submitServiceAction(
-                        ServiceActions.Stop()
-                    )
+                    torService.processServiceAction(ServiceActions.Stop())
                 }
                 else -> {
                     broadcastLogger.warn(

topl-service/src/test/java/io/matthewnelson/test_helpers/service/TestTorService.kt

@@ -216,6 +216,6 @@ internal class TestTorService(
         super.onTaskRemoved(rootIntent)
 
         // Shutdown Tor and stop the Service
-        processServiceAction(ServiceActions.Stop())
+        processServiceAction(ServiceActions.Stop(updateLastServiceAction = false))
     }
 }