Migrate internal interfaces to pigeon

example/ios/Podfile.lock

@@ -41,7 +41,7 @@ SPEC CHECKSUMS:
   path_provider_foundation: 608fcb11be570ce83519b076ab6a1fffe2474f05
   permission_handler_apple: 4ed2196e43d0651e8ff7ca3483a069d469701f2d
   shared_preferences_foundation: 9e1978ff2562383bd5676f64ec4e9aa8fa06a6f7
-  workmanager_apple: f540d652595dfe5c8b8200c4c85ba622d6fb5c5b
+  workmanager_apple: f073c5f57af569af5c2dab83ae031bd4396c8a95
 
 PODFILE CHECKSUM: 4225ca2ac155c3e63d4d416fa6b1b890e2563502
 

melos.yaml

@@ -15,3 +15,7 @@ scripts:
   generate:dart:
     run: melos exec -c 1 --depends-on="build_runner" --no-flutter -- "dart run build_runner build --delete-conflicting-outputs"
     description: Build all generated files for Dart packages in this project.
+
+  generate:pigeon:
+    run: cd workmanager_platform_interface && dart run pigeon --input pigeons/workmanager_api.dart
+    description: Generate Pigeon type-safe platform channel code for workmanager_platform_interface.

workmanager_android/android/src/main/kotlin/dev/fluttercommunity/workmanager/SharedPreferenceHelper.kt

@@ -1,25 +1,45 @@
 package dev.fluttercommunity.workmanager
 
 import android.content.Context
+import android.content.SharedPreferences
+import androidx.core.content.edit
 
-object SharedPreferenceHelper {
-    private const val SHARED_PREFS_FILE_NAME = "flutter_workmanager_plugin"
-    private const val CALLBACK_DISPATCHER_HANDLE_KEY = "dev.fluttercommunity.workmanager.CALLBACK_DISPATCHER_HANDLE_KEY"
-
-    private fun Context.prefs() = getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE)
+class SharedPreferenceHelper(
+    private val context: Context,
+    private val dispatcherHandleListener: DispatcherHandleListener
+) {
+    // Interface to listen for changes in the dispatcher handle.
+    // This allows the plugin to react when the dispatcher handle is updated.
+    interface DispatcherHandleListener {
+        // Called when the dispatcher handle changes.
+        fun onDispatcherHandleChanged(handle: Long)
+    }
 
-    fun saveCallbackDispatcherHandleKey(
-        ctx: Context,
-        callbackHandle: Long,
-    ) {
-        ctx
-            .prefs()
-            .edit()
-            .putLong(CALLBACK_DISPATCHER_HANDLE_KEY, callbackHandle)
-            .apply()
+    companion object {
+        private const val SHARED_PREFS_FILE_NAME = "flutter_workmanager_plugin"
+        private const val CALLBACK_DISPATCHER_HANDLE_KEY =
+            "dev.fluttercommunity.workmanager.CALLBACK_DISPATCHER_HANDLE_KEY"
     }
 
-    fun getCallbackHandle(ctx: Context): Long = ctx.prefs().getLong(CALLBACK_DISPATCHER_HANDLE_KEY, -1L)
+    private val preferences: SharedPreferences
+        get() = context.getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE)
+
+    private val preferenceListener: (sharedPreferences: SharedPreferences, key: String?) -> Unit =
+        { preferences, key ->
+            if (key == CALLBACK_DISPATCHER_HANDLE_KEY) {
+                dispatcherHandleListener.onDispatcherHandleChanged(
+                    preferences.getLong(CALLBACK_DISPATCHER_HANDLE_KEY, -1L)
+                )
+            }
+        }
 
-    fun hasCallbackHandle(ctx: Context) = ctx.prefs().contains(CALLBACK_DISPATCHER_HANDLE_KEY)
+    init {
+        preferences.registerOnSharedPreferenceChangeListener(preferenceListener)
+    }
+
+    fun saveCallbackDispatcherHandleKey(callbackHandle: Long) {
+        preferences.edit {
+            putLong(CALLBACK_DISPATCHER_HANDLE_KEY, callbackHandle)
+        }
+    }
 }

workmanager_android/android/src/main/kotlin/dev/fluttercommunity/workmanager/WorkManagerUtils.kt

@@ -0,0 +1,258 @@
+package dev.fluttercommunity.workmanager
+
+import android.content.Context
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.Data
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequest
+import androidx.work.OutOfQuotaPolicy
+import androidx.work.PeriodicWorkRequest
+import androidx.work.WorkManager
+import dev.fluttercommunity.workmanager.BackgroundWorker.Companion.DART_TASK_KEY
+import dev.fluttercommunity.workmanager.BackgroundWorker.Companion.IS_IN_DEBUG_MODE_KEY
+import java.util.concurrent.TimeUnit
+
+// Constants
+const val DEFAULT_INITIAL_DELAY_SECONDS = 0L
+const val DEFAULT_FLEX_INTERVAL_SECONDS =
+    PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS / 1000
+
+// Default values
+val defaultOneOffExistingWorkPolicy = ExistingWorkPolicy.KEEP
+val defaultPeriodExistingWorkPolicy = ExistingPeriodicWorkPolicy.KEEP
+val defaultConstraints: Constraints = Constraints.NONE
+val defaultOutOfQuotaPolicy: OutOfQuotaPolicy? = null
+
+
+// Extension functions to convert Pigeon types to Android WorkManager types
+private fun dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.toAndroidWorkPolicy(): ExistingWorkPolicy {
+    return when (this) {
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.APPEND -> ExistingWorkPolicy.APPEND_OR_REPLACE
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.KEEP -> ExistingWorkPolicy.KEEP
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.REPLACE -> ExistingWorkPolicy.REPLACE
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.UPDATE -> ExistingWorkPolicy.APPEND_OR_REPLACE
+    }
+}
+
+private fun dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.toAndroidPeriodicWorkPolicy(): ExistingPeriodicWorkPolicy {
+    return when (this) {
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.APPEND -> ExistingPeriodicWorkPolicy.REPLACE
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.KEEP -> ExistingPeriodicWorkPolicy.KEEP
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.REPLACE -> ExistingPeriodicWorkPolicy.REPLACE
+        dev.fluttercommunity.workmanager.pigeon.ExistingWorkPolicy.UPDATE -> ExistingPeriodicWorkPolicy.UPDATE
+    }
+}
+
+private fun dev.fluttercommunity.workmanager.pigeon.OutOfQuotaPolicy.toAndroidOutOfQuotaPolicy(): OutOfQuotaPolicy {
+    return when (this) {
+        dev.fluttercommunity.workmanager.pigeon.OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST -> OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST
+        dev.fluttercommunity.workmanager.pigeon.OutOfQuotaPolicy.DROP_WORK_REQUEST -> OutOfQuotaPolicy.DROP_WORK_REQUEST
+    }
+}
+
+private fun dev.fluttercommunity.workmanager.pigeon.Constraints.toAndroidConstraints(): Constraints {
+    val builder = Constraints.Builder()
+
+    networkType?.let { builder.setRequiredNetworkType(it.toAndroidNetworkType()) }
+    requiresBatteryNotLow?.let { builder.setRequiresBatteryNotLow(it) }
+    requiresCharging?.let { builder.setRequiresCharging(it) }
+    requiresDeviceIdle?.let {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            builder.setRequiresDeviceIdle(it)
+        }
+    }
+    requiresStorageNotLow?.let { builder.setRequiresStorageNotLow(it) }
+
+    return builder.build()
+}
+
+private fun dev.fluttercommunity.workmanager.pigeon.NetworkType.toAndroidNetworkType(): NetworkType {
+    return when (this) {
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.CONNECTED -> NetworkType.CONNECTED
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.METERED -> NetworkType.METERED
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.NOT_REQUIRED -> NetworkType.NOT_REQUIRED
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.NOT_ROAMING -> NetworkType.NOT_ROAMING
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.UNMETERED -> NetworkType.UNMETERED
+        dev.fluttercommunity.workmanager.pigeon.NetworkType.TEMPORARILY_UNMETERED -> {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                NetworkType.TEMPORARILY_UNMETERED
+            } else {
+                NetworkType.UNMETERED
+            }
+        }
+    }
+}
+
+
+private fun dev.fluttercommunity.workmanager.pigeon.BackoffPolicy.toAndroidBackoffPolicy(): BackoffPolicy {
+    return when (this) {
+        dev.fluttercommunity.workmanager.pigeon.BackoffPolicy.EXPONENTIAL -> BackoffPolicy.EXPONENTIAL
+        dev.fluttercommunity.workmanager.pigeon.BackoffPolicy.LINEAR -> BackoffPolicy.LINEAR
+    }
+}
+
+// Helper function to filter out null keys from Map<String?, Any?>
+private fun Map<String?, Any?>.filterNotNullKeys(): Map<String, Any> {
+    return this.mapNotNull { (key, value) ->
+        if (key != null && value != null) key to value else null
+    }.toMap()
+}
+
+class WorkManagerWrapper(val context: Context) {
+    private val workManager = WorkManager.getInstance(context)
+
+    fun enqueueOneOffTask(
+        request: dev.fluttercommunity.workmanager.pigeon.OneOffTaskRequest,
+        isInDebugMode: Boolean = false,
+    ) {
+        try {
+            val oneOffTaskRequest =
+                OneTimeWorkRequest
+                    .Builder(BackgroundWorker::class.java)
+                    .setInputData(
+                        buildTaskInputData(
+                            request.taskName,
+                            isInDebugMode,
+                            request.inputData?.filterNotNullKeys()
+                        )
+                    )
+                    .setInitialDelay(
+                        request.initialDelaySeconds ?: DEFAULT_INITIAL_DELAY_SECONDS,
+                        TimeUnit.SECONDS
+                    )
+                    .setConstraints(
+                        request.constraints?.toAndroidConstraints() ?: defaultConstraints
+                    )
+                    .apply {
+                        request.backoffPolicy?.let { backoffConfig ->
+                            if (backoffConfig.backoffPolicy != null && backoffConfig.backoffDelayMillis != null) {
+                                setBackoffCriteria(
+                                    backoffConfig.backoffPolicy.toAndroidBackoffPolicy(),
+                                    backoffConfig.backoffDelayMillis.toLong(),
+                                    TimeUnit.MILLISECONDS,
+                                )
+                            }
+                        }
+                    }.apply {
+                        request.tag?.let(::addTag)
+                        request.outOfQuotaPolicy?.toAndroidOutOfQuotaPolicy()?.let(::setExpedited)
+                    }.build()
+            workManager.enqueueUniqueWork(
+                request.uniqueName,
+                request.existingWorkPolicy?.toAndroidWorkPolicy()
+                    ?: defaultOneOffExistingWorkPolicy,
+                oneOffTaskRequest
+            )
+        } catch (e: Exception) {
+            throw e
+        }
+    }
+
+    fun enqueuePeriodicTask(
+        request: dev.fluttercommunity.workmanager.pigeon.PeriodicTaskRequest,
+        isInDebugMode: Boolean = false,
+    ) {
+        val periodicTaskRequest =
+            PeriodicWorkRequest
+                .Builder(
+                    BackgroundWorker::class.java,
+                    request.frequencySeconds,
+                    TimeUnit.SECONDS,
+                    request.flexIntervalSeconds ?: DEFAULT_FLEX_INTERVAL_SECONDS,
+                    TimeUnit.SECONDS,
+                ).setInputData(
+                    buildTaskInputData(
+                        request.taskName,
+                        isInDebugMode,
+                        request.inputData?.filterNotNullKeys()
+                    )
+                )
+                .setInitialDelay(
+                    request.initialDelaySeconds ?: DEFAULT_INITIAL_DELAY_SECONDS,
+                    TimeUnit.SECONDS
+                )
+                .setConstraints(request.constraints?.toAndroidConstraints() ?: defaultConstraints)
+                .apply {
+                    request.backoffPolicy?.let { backoffConfig ->
+                        if (backoffConfig.backoffPolicy != null && backoffConfig.backoffDelayMillis != null) {
+                            setBackoffCriteria(
+                                backoffConfig.backoffPolicy.toAndroidBackoffPolicy(),
+                                backoffConfig.backoffDelayMillis.toLong(),
+                                TimeUnit.MILLISECONDS,
+                            )
+                        }
+                    }
+                }.apply {
+                    request.tag?.let(::addTag)
+                    // Note: outOfQuotaPolicy is not supported for periodic tasks
+                }.build()
+        workManager.enqueueUniquePeriodicWork(
+            request.uniqueName,
+            request.existingWorkPolicy?.toAndroidPeriodicWorkPolicy()
+                ?: defaultPeriodExistingWorkPolicy,
+            periodicTaskRequest
+        )
+    }
+
+    private fun buildTaskInputData(
+        dartTask: String,
+        isInDebugMode: Boolean,
+        payload: Map<String, Any>?,
+    ): Data {
+        val builder =
+            Data
+                .Builder()
+                .putString(DART_TASK_KEY, dartTask)
+                .putBoolean(IS_IN_DEBUG_MODE_KEY, isInDebugMode)
+
+        // Add payload data if provided
+        payload?.forEach { (key, value) ->
+            when (value) {
+                is String -> builder.putString("payload_$key", value)
+                is Boolean -> builder.putBoolean("payload_$key", value)
+                is Int -> builder.putInt("payload_$key", value)
+                is Long -> builder.putLong("payload_$key", value)
+                is Float -> builder.putFloat("payload_$key", value)
+                is Double -> builder.putDouble("payload_$key", value)
+                is Array<*> ->
+                    builder.putStringArray(
+                        "payload_$key",
+                        value.filterIsInstance<String>().toTypedArray(),
+                    )
+
+                is List<*> ->
+                    builder.putStringArray(
+                        "payload_$key",
+                        value.filterIsInstance<String>().toTypedArray(),
+                    )
+
+                is ByteArray -> builder.putByteArray("payload_$key", value)
+
+                else -> {
+                    throw IllegalArgumentException(
+                        "Unsupported payload type for key '$key': ${value::class.java.simpleName}. " +
+                                "Consider converting it to a supported type.",
+                    )
+                }
+            }
+        }
+
+        return builder.build()
+    }
+
+    fun getWorkInfoByUniqueName(uniqueWorkName: String) =
+        workManager.getWorkInfosForUniqueWork(uniqueWorkName)
+
+    fun cancelByUniqueName(uniqueWorkName: String) =
+        workManager.cancelUniqueWork(uniqueWorkName)
+
+    fun cancelByTag(tag: String) =
+        workManager.cancelAllWorkByTag(tag)
+
+    fun cancelAll() = workManager.cancelAllWork()
+}