Cleanup and add stub ProgressBroadcastForwarder

This commit is contained in:
Davide Depau committed 2019-08-11 22:24:24 +02:00
1 parent 9e76d5ff22
commit fdb88db3ae
17 files changed
+209 -123

No files matched your search

@@ -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 <T> 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)
}
}
}
}
@@ -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>(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>(JobServiceIntentDTO.EXTRA)
JobIntentHandler(this, jobDTO).handle()
}
}
@@ -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")
}
}
@@ -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)
}
@@ -0,0 +1,6 @@
package eu.depau.etchdroid.utils.job
interface IJobProgressSender {
fun attachJobProgressListener(listener: IJobProgressListener): Boolean
fun detachJobProgressListener(listener: IJobProgressListener): Boolean
}
@@ -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<IJobProgressListener>()
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) }
}
@@ -0,0 +1,13 @@
package eu.depau.etchdroid.utils.ktexts
import android.app.Notification
import android.app.Service
fun <T> Service.runForeground(id: Int, notification: Notification, removeNotification: Boolean, body: () -> T): T {
this.startForeground(id, notification)
try {
return body()
} finally {
stopForeground(removeNotification)
}
}
@@ -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
*
@@ -1,6 +0,0 @@
package eu.depau.etchdroid.utils.worker
interface IProgressSender {
fun attachProgressListener(listener: IWorkerProgressListener): Boolean
fun detachProgressListener(listener: IWorkerProgressListener): Boolean
}
@@ -0,0 +1,6 @@
package eu.depau.etchdroid.utils.worker
interface IWorkerProgressSender {
fun attachWorkerProgressListener(listener: IWorkerProgressListener): Boolean
fun detachWorkerProgressListener(listener: IWorkerProgressListener): Boolean
}
@@ -2,4 +2,4 @@ package eu.depau.etchdroid.utils.worker.impl
import eu.depau.etchdroid.utils.worker.IAsyncWorker
abstract class AbstractAsyncWorker : IAsyncWorker, AbstractProgressSender()
abstract class AbstractAsyncWorker : IAsyncWorker, AbstractWorkerProgressSender()
@@ -32,7 +32,7 @@ abstract class AbstractAutoProgressAsyncWorker(
rateUnit = rateUnit
)
notifyProgress(dto)
notifyWorkerProgress(dto)
doneSinceLastUpdate = 0
lastUpdateTime = currentTime
@@ -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<IWorkerProgressListener>()
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) }
}
@@ -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
internal interface IMergedAsyncWorkerProgressSender: IAsyncWorker, IWorkerProgressSender
@@ -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>(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())
}
}
@@ -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)
}
}
@@ -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
}