diff --git a/app/src/main/java/eu/depau/etchdroid/services/job/JobIntentHandler.kt b/app/src/main/java/eu/depau/etchdroid/services/job/JobIntentHandler.kt new file mode 100644 index 0000000..ae66d12 --- /dev/null +++ b/app/src/main/java/eu/depau/etchdroid/services/job/JobIntentHandler.kt @@ -0,0 +1,77 @@ +package eu.depau.etchdroid.services.job + +import eu.depau.etchdroid.db.EtchDroidDatabase +import eu.depau.etchdroid.db.entity.Job +import eu.depau.etchdroid.notification.impl.JobServiceNotificationHandler +import eu.depau.etchdroid.services.job.dto.JobServiceIntentDTO +import eu.depau.etchdroid.utils.job.IJobAction +import eu.depau.etchdroid.utils.job.IJobProcedure +import eu.depau.etchdroid.utils.job.impl.AbstractJobProgressSender +import eu.depau.etchdroid.utils.ktexts.runForeground +import eu.depau.etchdroid.utils.worker.IAsyncWorker + +class JobIntentHandler( + val context: JobService, + private val jobDTO: JobServiceIntentDTO +) : AbstractJobProgressSender() { + + private val jobId = jobDTO.jobId + private val broadcastForwarder = ProgressBroadcastForwarder(jobId, context) + private val svcNotificationHandler = JobServiceNotificationHandler(context) + private val notification = svcNotificationHandler.build() + private lateinit var job: Job + + init { + assert(jobId >= 0) { "Invalid jobId (jobId < 0)" } + } + + fun handle() = context.runForeground(jobId.toInt(), notification, true) { + val db = EtchDroidDatabase.getDatabase(context) + job = db.jobRepository().getById(jobId) + assert(!job.completed) { "Job $jobId already completed" } + + job.attachAndRun { procedure -> + procedure.forEachAction { index, action, worker -> + while (worker.runStep()) { + } + } + } + } + + + private inline fun Job.attachAndRun(body: (procedure: IJobProcedure) -> T): T { + attachJobProgressListener(broadcastForwarder) + try { + notifyJobProcedureStart(this.checkpointActionIndex ?: 0) + val result = body(this.jobProcedure) + notifyJobProcedureDone() + return result + } catch (t: Throwable) { + notifyJobProcedureError(t) + throw t + } finally { + detachJobProgressListener(broadcastForwarder) + } + } + + private inline fun IJobProcedure.forEachAction( + body: (index: Int, action: IJobAction, worker: IAsyncWorker) -> Unit + ) { + val startIndex = job.checkpointActionIndex ?: 0 + + (startIndex until size).forEach { index -> + + val action = this[index] + val worker = action.getWorker() + worker.attachWorkerProgressListener(broadcastForwarder) + + try { + broadcastForwarder.onActionStart(index) + body(index, action, worker) + broadcastForwarder.onActionDone() + } finally { + worker.detachWorkerProgressListener(broadcastForwarder) + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/services/job/JobService.kt b/app/src/main/java/eu/depau/etchdroid/services/job/JobService.kt index e7babe2..98cc76d 100644 --- a/app/src/main/java/eu/depau/etchdroid/services/job/JobService.kt +++ b/app/src/main/java/eu/depau/etchdroid/services/job/JobService.kt @@ -2,58 +2,15 @@ package eu.depau.etchdroid.services.job import android.app.IntentService import android.content.Intent -import eu.depau.etchdroid.db.EtchDroidDatabase -import eu.depau.etchdroid.notification.impl.JobServiceNotificationHandler import eu.depau.etchdroid.services.job.dto.JobServiceIntentDTO +/** + * Job service. Creates an instance of and runs another class to prevent Android + * from reusing data in another thread + */ open class JobService(name: String) : IntentService(name) { - constructor() : this("TestJobService") - - private fun startProcedure(jobId: Long) { - - } - - private fun startAction(jobId: Long, actionIndex: Int) { - - } - override fun onHandleIntent(intent: Intent?) { - intent!! // Assert intent != null - val jobDTO = intent.getParcelableExtra(JobServiceIntentDTO.EXTRA) - val jobId = jobDTO.jobId - - assert(jobId >= 0) { "Invalid jobId (jobId < 0)" } - - val svcNotificationHandler = JobServiceNotificationHandler(this) - val notification = svcNotificationHandler.build() - startForeground(jobId.toInt(), notification) - - // TODO: Implement notification broadcast receiver and bind it here - // TODO: add and notify BroadcastProgressForwarder - - try { - val db = EtchDroidDatabase.getDatabase(this) - val job = db.jobRepository().getById(jobId) - assert(!job.completed) { "Job $jobId already completed" } - - val procedure = job.jobProcedure - // TODO: notify BroadcastProgressForwarder - startProcedure(jobId) - - for (i in 0 until procedure.size) { - val action = procedure[i] - startAction(jobId, i) - // TODO: notify BroadcastProgressForwarder - - val worker = action.getWorker() - while (worker.runStep()) { - } - - // TODO: notify BroadcastProgressForwarder - } - - } finally { - stopForeground(true) - } + val jobDTO = intent!!.getParcelableExtra(JobServiceIntentDTO.EXTRA) + JobIntentHandler(this, jobDTO).handle() } } \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/services/job/ProgressBroadcastForwarder.kt b/app/src/main/java/eu/depau/etchdroid/services/job/ProgressBroadcastForwarder.kt index 9f69658..0e08ceb 100644 --- a/app/src/main/java/eu/depau/etchdroid/services/job/ProgressBroadcastForwarder.kt +++ b/app/src/main/java/eu/depau/etchdroid/services/job/ProgressBroadcastForwarder.kt @@ -1,7 +1,6 @@ package eu.depau.etchdroid.services.job import android.content.Context -import android.util.Log import eu.depau.etchdroid.db.EtchDroidDatabase import eu.depau.etchdroid.utils.job.IJobProgressListener import eu.depau.etchdroid.utils.worker.IWorkerProgressListener @@ -10,14 +9,14 @@ import eu.depau.etchdroid.utils.worker.dto.ProgressUpdateDTO // TODO: implement class stubs /** - * This class is subscribed to IAsyncWorker+IProgressSender events by the worker service. + * This class is subscribed to IAsyncWorker+IWorkerProgressSender events by the worker service. * It is aware of the current JobProcedure (in fact, it retrieves it by ID from the database). * * It tracks */ -class ProgressBroadcastForwarder(private val context: Context) : IJobProgressListener, IWorkerProgressListener { - - var jobId: Long = -1 +class ProgressBroadcastForwarder( + private val jobId: Long, private val context: Context +) : IJobProgressListener, IWorkerProgressListener { private val db = EtchDroidDatabase.getDatabase(context) private val jobEntity = db.jobRepository().getById(jobId) @@ -44,6 +43,9 @@ class ProgressBroadcastForwarder(private val context: Context) : IJobProgressLis .subList(0, currentActionIdx!!) .map { it.progressWeight } .sum() + + println("-> onProcedureStart job $jobId, startAt $startActionIndex, " + + "currentAction $currentActionIdx, prevProgress: $prevActionsProgressWeight") } @@ -54,19 +56,22 @@ class ProgressBroadcastForwarder(private val context: Context) : IJobProgressLis override fun onProcedureDone() { assertProcedureStarted() // TODO: stub - Log.d(TAG, "onProcedureDone job $jobId ACTION $currentActionIdx") + println("-> onProcedureDone job $jobId action $currentActionIdx") } + /** * Called by the worker service to notify the forwarder that the currently referenced procedure * has failed with the provided exception. */ - override fun onProcedureError(error: Exception) { + override fun onProcedureError(error: Throwable) { assertProcedureStarted() // TODO: stub - Log.d(TAG, "onProcedureError job $jobId ACTION $currentActionIdx", error) + println("-> onProcedureError job $jobId action $currentActionIdx") + error.printStackTrace() } + /** * Called by the current worker to update the progress listener on its status relative to * the current JobAction that describes its task. @@ -76,13 +81,14 @@ class ProgressBroadcastForwarder(private val context: Context) : IJobProgressLis override fun onWorkerProgress(dto: ProgressUpdateDTO) { assertProcedureStarted() // TODO: stub - Log.d(TAG, "onWorkerProgress job $jobId ACTION $currentActionIdx dto $dto") + println(" -> onWorkerProgress job $jobId action $currentActionIdx dto $dto") } + /** - * Called by the worker service to update the forwarder on the current ACTION index. + * Called by the worker service to update the forwarder on the current action index. * - * @param actionIndex the current ACTION index within the JobProcedure + * @param actionIndex the current action index within the JobProcedure */ override fun onActionStart(actionIndex: Int) { assertProcedureStarted() @@ -90,11 +96,12 @@ class ProgressBroadcastForwarder(private val context: Context) : IJobProgressLis prevActionsProgressWeight = prevActionsProgressWeight!!.plus(jobEntity.jobProcedure[actionIndex].progressWeight) // TODO: stub - Log.d(TAG, "onActionStart job $jobId ACTION $currentActionIdx") + println(" -> onActionStart job $jobId action $currentActionIdx") } + /** - * Called by the worker service to notify the forwarder that the current ACTION has finished + * Called by the worker service to notify the forwarder that the current action has finished * running. Whether it has finished successfully or not is unspecified. * * If it failed, a call to onProcedureError will follow with an Exception reference. @@ -102,10 +109,6 @@ class ProgressBroadcastForwarder(private val context: Context) : IJobProgressLis override fun onActionDone() { assertProcedureStarted() // TODO: stub - Log.d(TAG, "onActionDone job $jobId ACTION $currentActionIdx") - } - - companion object { - const val TAG = ".w.ProgBcastFwd" + println(" -> onActionDone job $jobId action $currentActionIdx") } } \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressListener.kt b/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressListener.kt index 690bcf5..d474502 100644 --- a/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressListener.kt +++ b/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressListener.kt @@ -31,12 +31,12 @@ interface IJobProgressListener { /** * Called by the worker service to notify the forwarder that the currently referenced procedure * has finished successfully. - */ + */ fun onProcedureDone() /** * Called by the worker service to notify the forwarder that the currently referenced procedure * has failed with the provided exception. */ - fun onProcedureError(error: java.lang.Exception) + fun onProcedureError(error: Throwable) } \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressSender.kt new file mode 100644 index 0000000..0b2172b --- /dev/null +++ b/app/src/main/java/eu/depau/etchdroid/utils/job/IJobProgressSender.kt @@ -0,0 +1,6 @@ +package eu.depau.etchdroid.utils.job + +interface IJobProgressSender { + fun attachJobProgressListener(listener: IJobProgressListener): Boolean + fun detachJobProgressListener(listener: IJobProgressListener): Boolean +} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/job/impl/AbstractJobProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/utils/job/impl/AbstractJobProgressSender.kt new file mode 100644 index 0000000..54dbedb --- /dev/null +++ b/app/src/main/java/eu/depau/etchdroid/utils/job/impl/AbstractJobProgressSender.kt @@ -0,0 +1,29 @@ +package eu.depau.etchdroid.utils.job.impl + +import eu.depau.etchdroid.utils.job.IJobProgressListener +import eu.depau.etchdroid.utils.job.IJobProgressSender + +abstract class AbstractJobProgressSender : IJobProgressSender { + private val listeners = ArrayList() + + override fun attachJobProgressListener(listener: IJobProgressListener): Boolean = + listeners.add(listener) + + override fun detachJobProgressListener(listener: IJobProgressListener): Boolean = + listeners.remove(listener) + + protected fun notifyJobActionStart(actionIndex: Int) = + listeners.forEach { it.onActionStart(actionIndex) } + + protected fun notifyJobActionDone() = + listeners.forEach { it.onActionDone() } + + protected fun notifyJobProcedureStart(startActionIndex: Int = 0) = + listeners.forEach { it.onProcedureStart(startActionIndex) } + + protected fun notifyJobProcedureDone() = + listeners.forEach { it.onProcedureDone() } + + protected fun notifyJobProcedureError(error: Throwable) = + listeners.forEach { it.onProcedureError(error) } +} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/ktexts/ServiceForeground.kt b/app/src/main/java/eu/depau/etchdroid/utils/ktexts/ServiceForeground.kt new file mode 100644 index 0000000..159534a --- /dev/null +++ b/app/src/main/java/eu/depau/etchdroid/utils/ktexts/ServiceForeground.kt @@ -0,0 +1,13 @@ +package eu.depau.etchdroid.utils.ktexts + +import android.app.Notification +import android.app.Service + +fun Service.runForeground(id: Int, notification: Notification, removeNotification: Boolean, body: () -> T): T { + this.startForeground(id, notification) + try { + return body() + } finally { + stopForeground(removeNotification) + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/IAsyncWorker.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/IAsyncWorker.kt index 6d49c4f..47c78a0 100644 --- a/app/src/main/java/eu/depau/etchdroid/utils/worker/IAsyncWorker.kt +++ b/app/src/main/java/eu/depau/etchdroid/utils/worker/IAsyncWorker.kt @@ -1,6 +1,6 @@ package eu.depau.etchdroid.utils.worker -interface IAsyncWorker: IProgressSender { +interface IAsyncWorker: IWorkerProgressSender { /** * Make the worker run do one step. Returns whether there are more steps to do * diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/IProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/IProgressSender.kt deleted file mode 100644 index cd7dbb9..0000000 --- a/app/src/main/java/eu/depau/etchdroid/utils/worker/IProgressSender.kt +++ /dev/null @@ -1,6 +0,0 @@ -package eu.depau.etchdroid.utils.worker - -interface IProgressSender { - fun attachProgressListener(listener: IWorkerProgressListener): Boolean - fun detachProgressListener(listener: IWorkerProgressListener): Boolean -} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/IWorkerProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/IWorkerProgressSender.kt new file mode 100644 index 0000000..857e523 --- /dev/null +++ b/app/src/main/java/eu/depau/etchdroid/utils/worker/IWorkerProgressSender.kt @@ -0,0 +1,6 @@ +package eu.depau.etchdroid.utils.worker + +interface IWorkerProgressSender { + fun attachWorkerProgressListener(listener: IWorkerProgressListener): Boolean + fun detachWorkerProgressListener(listener: IWorkerProgressListener): Boolean +} \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAsyncWorker.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAsyncWorker.kt index a0423fc..735b5d8 100644 --- a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAsyncWorker.kt +++ b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAsyncWorker.kt @@ -2,4 +2,4 @@ package eu.depau.etchdroid.utils.worker.impl import eu.depau.etchdroid.utils.worker.IAsyncWorker -abstract class AbstractAsyncWorker : IAsyncWorker, AbstractProgressSender() \ No newline at end of file +abstract class AbstractAsyncWorker : IAsyncWorker, AbstractWorkerProgressSender() \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAutoProgressAsyncWorker.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAutoProgressAsyncWorker.kt index a69865a..3a478af 100644 --- a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAutoProgressAsyncWorker.kt +++ b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractAutoProgressAsyncWorker.kt @@ -32,7 +32,7 @@ abstract class AbstractAutoProgressAsyncWorker( rateUnit = rateUnit ) - notifyProgress(dto) + notifyWorkerProgress(dto) doneSinceLastUpdate = 0 lastUpdateTime = currentTime diff --git a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractWorkerProgressSender.kt similarity index 50% rename from app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractProgressSender.kt rename to app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractWorkerProgressSender.kt index f012aea..c1b1055 100644 --- a/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractProgressSender.kt +++ b/app/src/main/java/eu/depau/etchdroid/utils/worker/impl/AbstractWorkerProgressSender.kt @@ -1,19 +1,19 @@ package eu.depau.etchdroid.utils.worker.impl -import eu.depau.etchdroid.utils.worker.IProgressSender import eu.depau.etchdroid.utils.worker.IWorkerProgressListener +import eu.depau.etchdroid.utils.worker.IWorkerProgressSender import eu.depau.etchdroid.utils.worker.dto.ProgressUpdateDTO -abstract class AbstractProgressSender : IProgressSender { +abstract class AbstractWorkerProgressSender : IWorkerProgressSender { private val listeners = ArrayList() - override fun attachProgressListener(listener: IWorkerProgressListener) = + override fun attachWorkerProgressListener(listener: IWorkerProgressListener) = listeners.add(listener) - override fun detachProgressListener(listener: IWorkerProgressListener) = + override fun detachWorkerProgressListener(listener: IWorkerProgressListener) = listeners.remove(listener) - protected fun notifyProgress(dto: ProgressUpdateDTO) = + protected fun notifyWorkerProgress(dto: ProgressUpdateDTO) = listeners.forEach { it.onWorkerProgress(dto) } } \ No newline at end of file diff --git a/app/src/main/java/eu/depau/etchdroid/workers/IMergedAsyncWorkerProgressSender.kt b/app/src/main/java/eu/depau/etchdroid/workers/IMergedAsyncWorkerProgressSender.kt index e908709..f20fb6a 100644 --- a/app/src/main/java/eu/depau/etchdroid/workers/IMergedAsyncWorkerProgressSender.kt +++ b/app/src/main/java/eu/depau/etchdroid/workers/IMergedAsyncWorkerProgressSender.kt @@ -1,7 +1,7 @@ package eu.depau.etchdroid.workers import eu.depau.etchdroid.utils.worker.IAsyncWorker -import eu.depau.etchdroid.utils.worker.IProgressSender +import eu.depau.etchdroid.utils.worker.IWorkerProgressSender -internal interface IMergedAsyncWorkerProgressSender: IAsyncWorker, IProgressSender \ No newline at end of file +internal interface IMergedAsyncWorkerProgressSender: IAsyncWorker, IWorkerProgressSender \ No newline at end of file diff --git a/app/src/test/java/eu/depau/etchdroid/services/JobServiceTest.kt b/app/src/test/java/eu/depau/etchdroid/services/JobIntentHandlerTest.kt similarity index 73% rename from app/src/test/java/eu/depau/etchdroid/services/JobServiceTest.kt rename to app/src/test/java/eu/depau/etchdroid/services/JobIntentHandlerTest.kt index 49a5a6e..d17a015 100644 --- a/app/src/test/java/eu/depau/etchdroid/services/JobServiceTest.kt +++ b/app/src/test/java/eu/depau/etchdroid/services/JobIntentHandlerTest.kt @@ -7,6 +7,7 @@ import eu.depau.etchdroid.AppBuildConfig import eu.depau.etchdroid.db.EtchDroidDatabase import eu.depau.etchdroid.db.entity.Job import eu.depau.etchdroid.db.repository.JobRepository +import eu.depau.etchdroid.services.job.JobIntentHandler import eu.depau.etchdroid.services.job.JobService import eu.depau.etchdroid.services.job.dto.JobServiceIntentDTO import eu.depau.etchdroid.testutils.job.MockJobAction @@ -22,9 +23,8 @@ import java.util.* import kotlin.math.abs @RunWith(MockitoJUnitRunner::class) -internal class JobServiceTest { - private var service: JobService? = null - private var mockContext: Context? = null +internal class JobIntentHandlerTest { + private var mockService: JobService? = null private var jobRepo: JobRepository? = null private var random = Random() @@ -33,7 +33,21 @@ internal class JobServiceTest { // Used by JobServiceNotificationHandler to avoid building real notifications when testing AppBuildConfig.TEST_BUILD = true - mockContext = mock(Context::class.java) + // Mock eu.depau.etchdroid.services.job.JobService + mockService = mock(JobService::class.java) + Mockito + .doReturn(mock(NotificationManager::class.java)) + .`when`(mockService!!).getSystemService(Context.NOTIFICATION_SERVICE) + Mockito + .doReturn("penis") + .`when`(mockService!!).getString(anyInt()) + Mockito + .doNothing() + .`when`(mockService!!).startForeground(anyInt(), any()) + Mockito + .doNothing() + .`when`(mockService!!).stopForeground(anyBoolean()) + jobRepo = mock(JobRepository::class.java) // Inject mock JobRepository into database mock instance @@ -47,30 +61,14 @@ internal class JobServiceTest { .getDeclaredMethod("access\$setINSTANCE\$cp", EtchDroidDatabase::class.java) .apply { isAccessible = true } .invoke(null, db) - - // Create a clean JobService and mock its Android framework methods - service = spy(JobService::class.java) - Mockito - .doReturn(mock(NotificationManager::class.java)) - .`when`(service!!).getSystemService(Context.NOTIFICATION_SERVICE) - Mockito - .doReturn("penis") - .`when`(service!!).getString(anyInt()) - Mockito - .doNothing() - .`when`(service!!).startForeground(anyInt(), any()) - Mockito - .doNothing() - .`when`(service!!).stopForeground(anyBoolean()) - } @Test fun testBasicFlow() { // Create mock job val jobProcedure = JobProcedure(-1).apply { - add(MockJobAction(1, 1.0)) - add(MockJobAction(2, 1.0)) + add(MockJobAction(1, 1.0, 0, 10)) + add(MockJobAction(2, 1.0, 0, 10)) } val job = Job( jobId = abs(random.nextInt().toLong()), @@ -83,27 +81,25 @@ internal class JobServiceTest { .`when`(jobRepo!!.getById(jobId)) .thenReturn(job) - // Create mock Intent to pass to the service + // Create mock Intent to pass to the intentHandler val serviceIntent = mock(Intent::class.java) as Intent Mockito .doReturn(JobServiceIntentDTO(jobId)) .`when`(serviceIntent).getParcelableExtra(JobServiceIntentDTO.EXTRA) - // Pass it to onHandleIntent (with reflection cause it's protected) - service!!::class.java - .getDeclaredMethod("onHandleIntent", Intent::class.java) - .apply { isAccessible = true } - .invoke(service, serviceIntent) + // Pass it to the intent handler + val intentHandler = JobIntentHandler(mockService!!, JobServiceIntentDTO(jobId)) + intentHandler.handle() // Check whether everything was called, in order val mockWorkers = jobProcedure .map { it.getWorker() as MockJobWorker } .toTypedArray() - val inOrder = Mockito.inOrder(*mockWorkers, service) + val inOrder = Mockito.inOrder(mockService, *mockWorkers) inOrder - .verify(service!!, times(1)) + .verify(mockService!!, times(1)) .startForeground(anyInt(), any()) for (mockWorker in mockWorkers) { @@ -113,7 +109,7 @@ internal class JobServiceTest { } inOrder - .verify(service!!, times(1)) + .verify(mockService!!, times(1)) .stopForeground(anyBoolean()) } } \ No newline at end of file diff --git a/app/src/test/java/eu/depau/etchdroid/testutils/job/MockJobAction.kt b/app/src/test/java/eu/depau/etchdroid/testutils/job/MockJobAction.kt index 7b4a1a5..b7b6e30 100644 --- a/app/src/test/java/eu/depau/etchdroid/testutils/job/MockJobAction.kt +++ b/app/src/test/java/eu/depau/etchdroid/testutils/job/MockJobAction.kt @@ -11,16 +11,20 @@ import org.mockito.Mockito class MockJobAction( override val nameResId: Int, - override val progressWeight: Double + override val progressWeight: Double, + private val startAt: Int, + private val steps: Int ) : IJobAction, KotletParcelable { constructor(parcel: Parcel) : this( parcel.readInt(), - parcel.readDouble() + parcel.readDouble(), + parcel.readInt(), + parcel.readInt() ) private val lazyWorker by lazy { - Mockito.spy(MockJobWorker()) + Mockito.spy(MockJobWorker(startAt, steps)) } override fun getWorker(): IAsyncWorker { @@ -42,6 +46,8 @@ class MockJobAction( parcel.apply { writeInt(nameResId) writeDouble(progressWeight) + writeInt(startAt) + writeInt(steps) } } diff --git a/app/src/test/java/eu/depau/etchdroid/testutils/worker/MockJobWorker.kt b/app/src/test/java/eu/depau/etchdroid/testutils/worker/MockJobWorker.kt index 24969e6..3080b4a 100644 --- a/app/src/test/java/eu/depau/etchdroid/testutils/worker/MockJobWorker.kt +++ b/app/src/test/java/eu/depau/etchdroid/testutils/worker/MockJobWorker.kt @@ -3,9 +3,8 @@ package eu.depau.etchdroid.testutils.worker import eu.depau.etchdroid.utils.worker.enums.RateUnit import eu.depau.etchdroid.utils.worker.impl.AbstractAutoProgressAsyncWorker -open class MockJobWorker : AbstractAutoProgressAsyncWorker(10, RateUnit.FURLONGS_PER_FORTNIGHT) { - var counter = 0 - val steps = 10 +open class MockJobWorker(startAt: Int, val steps: Int) : AbstractAutoProgressAsyncWorker(10, RateUnit.FURLONGS_PER_FORTNIGHT) { + var counter = startAt private val sleepTime = (UPDATE_INTERVAL * 2.2 / steps).toLong() /** @@ -15,7 +14,7 @@ open class MockJobWorker : AbstractAutoProgressAsyncWorker(10, RateUnit.FURLONGS */ override fun runStep(): Boolean { counter++ - println("Worker counts $counter/$steps") + println(" -> Worker counts $counter/$steps") Thread.sleep(sleepTime) return counter < steps }