Feat: Network Rule

src/androidMain/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.liftric.job.queue">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

src/androidMain/kotlin/com/liftric/job/queue/JobQueue.kt

@@ -8,9 +8,13 @@ actual class JobQueue(
     context: Context,
     serializers: SerializersModule = SerializersModule {},
     configuration: Queue.Configuration = Queue.DefaultConfiguration,
-    store: JsonStorage = SettingsStorage(SharedPreferencesSettings.Factory(context).create("com.liftric.persisted.queue"))
+    networkListener: NetworkListener,
+    store: JsonStorage = SettingsStorage(
+        SharedPreferencesSettings.Factory(context).create("com.liftric.persisted.queue")
+    )
 ) : AbstractJobQueue(
-    serializers,
-    configuration,
-    store
+    serializers = serializers,
+    networkListener = networkListener,
+    configuration = configuration,
+    store = store
 )

src/androidMain/kotlin/com/liftric/job/queue/NetworkListener.kt

@@ -0,0 +1,37 @@
+package com.liftric.job.queue
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+
+actual class NetworkListener(
+    networkManager: NetworkManager,
+    scope: CoroutineScope = CoroutineScope(context = Dispatchers.Default)
+) : AbstractNetworkListener(
+    networkManager = networkManager,
+    scope = scope
+) {
+    private val _currentNetworkState = MutableStateFlow(NetworkState.NONE)
+    override val currentNetworkState: StateFlow<NetworkState>
+        get() = _currentNetworkState.asStateFlow()
+
+    private var job: kotlinx.coroutines.Job? = null
+
+    override fun observeNetworkState() {
+        job = scope.launch {
+            networkManager
+                .network
+                .collectLatest { currentNetworkState ->
+                    _currentNetworkState.emit(currentNetworkState ?: NetworkState.NONE)
+                }
+        }
+    }
+
+    override fun stopMonitoring() {
+        job?.cancel()
+    }
+}

src/androidMain/kotlin/com/liftric/job/queue/NetworkManager.kt

@@ -0,0 +1,54 @@
+package com.liftric.job.queue
+
+import android.annotation.SuppressLint
+import android.annotation.TargetApi
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.Build
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+@SuppressLint("MissingPermission")
+actual class NetworkManager(context: Context) {
+    private var connectivityManager: ConnectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+    private val connectionPublisher = MutableStateFlow(getCurrentNetworkConnection())
+    val network: Flow<NetworkState?> = connectionPublisher
+
+    private fun getCurrentNetworkConnection(): NetworkState? =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            postAndroidMNetworkConnection(connectivityManager)
+        } else {
+            preAndroidMNetworkConnection(connectivityManager)
+        }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    private fun postAndroidMNetworkConnection(connectivityManager: ConnectivityManager): NetworkState? {
+        val network = connectivityManager.activeNetwork
+        val capabilities = connectivityManager.getNetworkCapabilities(network)
+        return getNetworkConnection(capabilities)
+    }
+
+    @Suppress("DEPRECATION")
+    private fun preAndroidMNetworkConnection(connectivityManager: ConnectivityManager): NetworkState? =
+        when (connectivityManager.activeNetworkInfo?.type) {
+            null -> null
+            ConnectivityManager.TYPE_WIFI -> NetworkState.WIFI
+            else -> NetworkState.MOBILE
+        }
+
+    private fun getNetworkConnection(capabilities: NetworkCapabilities?): NetworkState? =
+        when {
+            capabilities == null -> null
+            Build.VERSION.SDK_INT < Build.VERSION_CODES.M
+                    && !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) -> null
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
+                    !(capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                            && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) -> null
+            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> NetworkState.WIFI
+            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> NetworkState.MOBILE
+            else -> null
+        }
+}

src/androidTest/kotlin/com/liftric/job/queue/JobQueueTests.kt

@@ -7,12 +7,18 @@ import kotlinx.serialization.modules.polymorphic
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
-actual class JobQueueTests: AbstractJobQueueTests(JobQueue(
-    context = InstrumentationRegistry.getInstrumentation().targetContext,
-    serializers = SerializersModule {
-        polymorphic(Task::class) {
-            subclass(TestTask::class, TestTask.serializer())
-        }
-    },
-    store = MapStorage()
-))
+actual class JobQueueTests : AbstractJobQueueTests(
+    JobQueue(
+        context = InstrumentationRegistry.getInstrumentation().targetContext,
+        serializers = SerializersModule {
+            polymorphic(Task::class) {
+                subclass(TestTask::class, TestTask.serializer())
+            }
+        },
+        store = MapStorage(),
+        networkListener = NetworkListener(
+            networkManager = NetworkManager(InstrumentationRegistry.getInstrumentation().context)
+        )
+    )
+)
+

src/commonMain/kotlin/com/liftric/job/queue/Job.kt

@@ -2,7 +2,6 @@ package com.liftric.job.queue
 
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.withTimeout
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlinx.serialization.Serializable
@@ -19,47 +18,61 @@ data class Job(
     override val info: JobInfo,
     override val task: Task,
     override val startTime: Instant
-): JobContext {
-    @Transient internal var delegate: JobDelegate? = null
+) : JobContext {
+    @Transient
+    internal var delegate: JobDelegate? = null
 
-    constructor(task: Task, info: JobInfo) : this (UUIDFactory.create(), info, task, Clock.System.now())
+    constructor(task: Task, info: JobInfo) : this(
+        id = UUIDFactory.create(),
+        info = info,
+        task = task,
+        startTime = Clock.System.now()
+    )
 
     private var canRepeat: Boolean = true
 
     suspend fun run(): JobEvent {
-        return withTimeout(info.timeout) {
-            val event = try {
-                info.rules.forEach { it.willRun(this@Job) }
-
-                task.body()
-
-                JobEvent.DidSucceed(this@Job)
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: Throwable) {
-                canRepeat = task.onRepeat(e)
-                JobEvent.DidFail(this@Job, e)
+        val event = try {
+            info.rules.forEach {
+                it.willRun(jobContext = this@Job)
             }
+            task.body()
+            JobEvent.DidSucceed(job = this@Job)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Throwable) {
+            canRepeat = task.onRepeat(e)
+            JobEvent.DidFail(job = this@Job, error = e)
+        }
 
-            try {
-                info.rules.forEach { it.willRemove(this@Job, event) }
-
-                event
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: Throwable) {
-                JobEvent.DidFailOnRemove(this@Job, e)
+        try {
+            info.rules.forEach { rule ->
+                rule.willRemove(jobContext = this@Job, result = event)
             }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Throwable) {
+            JobEvent.DidFailOnRemove(job = this@Job, error = e)
         }
+        return event
     }
 
     override suspend fun cancel() {
-        delegate?.onEvent?.emit(JobEvent.DidCancel(this@Job))
+        delegate?.onEvent?.emit(JobEvent.DidCancel(job = this@Job))
     }
 
     override suspend fun repeat(id: UUID, info: JobInfo, task: Task, startTime: Instant) {
         if (canRepeat) {
-            delegate?.onEvent?.emit(JobEvent.ShouldRepeat(Job(id, info, task, startTime)))
+            delegate?.onEvent?.emit(
+                JobEvent.ShouldRepeat(
+                    Job(
+                        id = id,
+                        info = info,
+                        task = task,
+                        startTime = startTime
+                    )
+                )
+            )
         }
     }
 }

src/commonMain/kotlin/com/liftric/job/queue/JobContext.kt

@@ -2,9 +2,14 @@ package com.liftric.job.queue
 
 import kotlinx.datetime.Instant
 
-interface JobContext: JobData {
+interface JobContext : JobData {
     suspend fun cancel()
-    suspend fun repeat(id: UUID = this.id, info: JobInfo = this.info, task: Task = this.task, startTime: Instant = this.startTime)
+    suspend fun repeat(
+        id: UUID = this.id,
+        info: JobInfo = this.info,
+        task: Task = this.task,
+        startTime: Instant = this.startTime,
+    )
 }
 
 interface JobData {

src/commonMain/kotlin/com/liftric/job/queue/JobEvent.kt

@@ -10,4 +10,7 @@ sealed class JobEvent {
     data class ShouldRepeat(val job: Job): JobEvent()
     data class DidCancel(val job: JobContext): JobEvent()
     data class DidFailOnRemove(val job: JobContext, val error: Throwable): JobEvent()
+    data class NetworkRuleSatisfied(val job: JobContext): JobEvent()
+    data class NetworkRuleTimeout(val job: JobContext): JobEvent()
+    data class JobTimeout(val job: JobContext): JobEvent()
 }

src/commonMain/kotlin/com/liftric/job/queue/JobInfo.kt

@@ -6,7 +6,9 @@ import kotlinx.serialization.Serializable
 @Serializable
 data class JobInfo(
     var tag: String? = null,
-    var timeout: Duration = Duration.INFINITE,
+    var jobTimeout: Duration = Duration.INFINITE,
+    var networkRuleTimeout: Duration = Duration.INFINITE,
     var rules: MutableList<JobRule> = mutableListOf(),
-    var shouldPersist: Boolean = false
+    var shouldPersist: Boolean = false,
+    var minRequiredNetworkState: NetworkState = NetworkState.NONE
 )