@capgo/capacitor-background-task 8.1.0

package/dist/plugin.js

@@ -0,0 +1,231 @@
+var capacitorBackgroundTask = (function (exports, core) {
+    'use strict';
+
+    /**
+     * Return value for a background task callback.
+     */
+    exports.BackgroundTaskResult = void 0;
+    (function (BackgroundTaskResult) {
+        /**
+         * The task finished successfully.
+         */
+        BackgroundTaskResult[BackgroundTaskResult["Success"] = 1] = "Success";
+        /**
+         * The task failed.
+         */
+        BackgroundTaskResult[BackgroundTaskResult["Failed"] = 2] = "Failed";
+    })(exports.BackgroundTaskResult || (exports.BackgroundTaskResult = {}));
+    /**
+     * Availability status for background task scheduling.
+     */
+    exports.BackgroundTaskStatus = void 0;
+    (function (BackgroundTaskStatus) {
+        /**
+         * Background task scheduling is unavailable or restricted.
+         */
+        BackgroundTaskStatus[BackgroundTaskStatus["Restricted"] = 1] = "Restricted";
+        /**
+         * Background task scheduling is available.
+         */
+        BackgroundTaskStatus[BackgroundTaskStatus["Available"] = 2] = "Available";
+    })(exports.BackgroundTaskStatus || (exports.BackgroundTaskStatus = {}));
+
+    const DEFAULT_TASK_NAME = 'CapgoBackgroundTask';
+    const NativeBackgroundTask = core.registerPlugin('BackgroundTask', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.BackgroundTaskWeb()),
+    });
+    const callbacks = new Map();
+    const processedTaskIds = new Set();
+    let listenerReady;
+    let currentReactNativeTask;
+    const ensureListener = () => {
+        if (!listenerReady) {
+            listenerReady = NativeBackgroundTask.addListener('backgroundTask', (event) => {
+                void runTask(event);
+            }).then(() => undefined);
+        }
+        return listenerReady;
+    };
+    const drainPendingTaskRuns = async () => {
+        const { tasks } = await NativeBackgroundTask.getPendingTaskRuns();
+        await Promise.all(tasks.map((task) => runTask(task)));
+    };
+    const runTask = async (event) => {
+        if (processedTaskIds.has(event.taskId)) {
+            return;
+        }
+        const callback = callbacks.get(event.taskName);
+        if (!callback) {
+            return;
+        }
+        processedTaskIds.add(event.taskId);
+        try {
+            currentReactNativeTask = {
+                taskId: event.taskId,
+                taskName: event.taskName,
+                result: exports.BackgroundTaskResult.Success,
+            };
+            const result = await callback(event);
+            await NativeBackgroundTask.finish({
+                taskId: event.taskId,
+                taskName: event.taskName,
+                result: result !== null && result !== void 0 ? result : exports.BackgroundTaskResult.Success,
+            });
+        }
+        catch (_a) {
+            await NativeBackgroundTask.finish({
+                taskId: event.taskId,
+                taskName: event.taskName,
+                result: exports.BackgroundTaskResult.Failed,
+            });
+        }
+        finally {
+            currentReactNativeTask = undefined;
+        }
+    };
+    const assertTaskName = (taskName) => {
+        if (!taskName || typeof taskName !== 'string') {
+            throw new Error('taskName is required');
+        }
+    };
+    const normalizeReactNativeOptions = (options) => {
+        var _a;
+        const period = (_a = options === null || options === void 0 ? void 0 : options.period) !== null && _a !== void 0 ? _a : 900;
+        return {
+            minimumInterval: Math.max(15, Math.ceil(period / 60)),
+        };
+    };
+    const BackgroundTask = {
+        defineTask(taskName, callback) {
+            assertTaskName(taskName);
+            callbacks.set(taskName, callback);
+            void ensureListener().then(drainPendingTaskRuns);
+        },
+        async registerTaskAsync(taskName, options) {
+            assertTaskName(taskName);
+            if (!callbacks.has(taskName)) {
+                throw new Error(`Task "${taskName}" must be defined before it is registered.`);
+            }
+            await NativeBackgroundTask.registerTask({ taskName, options });
+            await ensureListener();
+            await drainPendingTaskRuns();
+        },
+        async unregisterTaskAsync(taskName) {
+            assertTaskName(taskName);
+            await NativeBackgroundTask.unregisterTask({ taskName });
+        },
+        async isTaskRegisteredAsync(taskName) {
+            assertTaskName(taskName);
+            const { value } = await NativeBackgroundTask.isTaskRegistered({ taskName });
+            return value;
+        },
+        async getRegisteredTasksAsync() {
+            const { tasks } = await NativeBackgroundTask.getRegisteredTasks();
+            return tasks;
+        },
+        async getPendingTaskRunsAsync() {
+            const { tasks } = await NativeBackgroundTask.getPendingTaskRuns();
+            return tasks;
+        },
+        async getStatusAsync() {
+            const { status } = await NativeBackgroundTask.getStatus();
+            return status;
+        },
+        async triggerTaskWorkerForTestingAsync() {
+            await ensureListener();
+            const { value } = await NativeBackgroundTask.triggerTaskWorkerForTesting();
+            await drainPendingTaskRuns();
+            return value;
+        },
+        addExpirationListener(listener) {
+            return NativeBackgroundTask.addListener('expiration', listener);
+        },
+        define(callback) {
+            this.defineTask(DEFAULT_TASK_NAME, callback);
+        },
+        schedule(options) {
+            return this.registerTaskAsync(DEFAULT_TASK_NAME, normalizeReactNativeOptions(options));
+        },
+        cancel() {
+            return this.unregisterTaskAsync(DEFAULT_TASK_NAME);
+        },
+        async statusAsync() {
+            const status = await this.getStatusAsync();
+            if (status === exports.BackgroundTaskStatus.Available) {
+                return { available: true };
+            }
+            return {
+                available: false,
+                unavailableReason: 'restricted',
+            };
+        },
+        async finish(result = exports.BackgroundTaskResult.Success) {
+            if (!currentReactNativeTask) {
+                return;
+            }
+            await NativeBackgroundTask.finish(Object.assign(Object.assign({}, currentReactNativeTask), { result }));
+        },
+    };
+
+    class BackgroundTaskWeb extends core.WebPlugin {
+        constructor() {
+            super(...arguments);
+            this.registeredTasks = new Map();
+        }
+        async registerTask(options) {
+            this.registeredTasks.set(options.taskName, options);
+        }
+        async unregisterTask(options) {
+            this.registeredTasks.delete(options.taskName);
+        }
+        async isTaskRegistered(options) {
+            return {
+                value: this.registeredTasks.has(options.taskName),
+            };
+        }
+        async getRegisteredTasks() {
+            return {
+                tasks: [...this.registeredTasks.keys()],
+            };
+        }
+        async getPendingTaskRuns() {
+            return {
+                tasks: [],
+            };
+        }
+        async getStatus() {
+            return {
+                status: exports.BackgroundTaskStatus.Restricted,
+            };
+        }
+        async triggerTaskWorkerForTesting() {
+            const timestamp = Date.now();
+            for (const taskName of this.registeredTasks.keys()) {
+                void this.notifyListeners('backgroundTask', {
+                    taskName,
+                    taskId: `${taskName}:${timestamp}`,
+                    timestamp,
+                    test: true,
+                });
+            }
+            return {
+                value: this.registeredTasks.size > 0,
+            };
+        }
+        async finish() {
+            return;
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        BackgroundTaskWeb: BackgroundTaskWeb
+    });
+
+    exports.BackgroundTask = BackgroundTask;
+    exports.NativeBackgroundTask = NativeBackgroundTask;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/definitions.js","esm/index.js","esm/web.js"],"sourcesContent":["/**\n * Return value for a background task callback.\n */\nexport var BackgroundTaskResult;\n(function (BackgroundTaskResult) {\n    /**\n     * The task finished successfully.\n     */\n    BackgroundTaskResult[BackgroundTaskResult[\"Success\"] = 1] = \"Success\";\n    /**\n     * The task failed.\n     */\n    BackgroundTaskResult[BackgroundTaskResult[\"Failed\"] = 2] = \"Failed\";\n})(BackgroundTaskResult || (BackgroundTaskResult = {}));\n/**\n * Availability status for background task scheduling.\n */\nexport var BackgroundTaskStatus;\n(function (BackgroundTaskStatus) {\n    /**\n     * Background task scheduling is unavailable or restricted.\n     */\n    BackgroundTaskStatus[BackgroundTaskStatus[\"Restricted\"] = 1] = \"Restricted\";\n    /**\n     * Background task scheduling is available.\n     */\n    BackgroundTaskStatus[BackgroundTaskStatus[\"Available\"] = 2] = \"Available\";\n})(BackgroundTaskStatus || (BackgroundTaskStatus = {}));\n//# sourceMappingURL=definitions.js.map","import { registerPlugin } from '@capacitor/core';\nimport { BackgroundTaskResult, BackgroundTaskStatus } from './definitions';\nconst DEFAULT_TASK_NAME = 'CapgoBackgroundTask';\nconst NativeBackgroundTask = registerPlugin('BackgroundTask', {\n    web: () => import('./web').then((m) => new m.BackgroundTaskWeb()),\n});\nconst callbacks = new Map();\nconst processedTaskIds = new Set();\nlet listenerReady;\nlet currentReactNativeTask;\nconst ensureListener = () => {\n    if (!listenerReady) {\n        listenerReady = NativeBackgroundTask.addListener('backgroundTask', (event) => {\n            void runTask(event);\n        }).then(() => undefined);\n    }\n    return listenerReady;\n};\nconst drainPendingTaskRuns = async () => {\n    const { tasks } = await NativeBackgroundTask.getPendingTaskRuns();\n    await Promise.all(tasks.map((task) => runTask(task)));\n};\nconst runTask = async (event) => {\n    if (processedTaskIds.has(event.taskId)) {\n        return;\n    }\n    const callback = callbacks.get(event.taskName);\n    if (!callback) {\n        return;\n    }\n    processedTaskIds.add(event.taskId);\n    try {\n        currentReactNativeTask = {\n            taskId: event.taskId,\n            taskName: event.taskName,\n            result: BackgroundTaskResult.Success,\n        };\n        const result = await callback(event);\n        await NativeBackgroundTask.finish({\n            taskId: event.taskId,\n            taskName: event.taskName,\n            result: result !== null && result !== void 0 ? result : BackgroundTaskResult.Success,\n        });\n    }\n    catch (_a) {\n        await NativeBackgroundTask.finish({\n            taskId: event.taskId,\n            taskName: event.taskName,\n            result: BackgroundTaskResult.Failed,\n        });\n    }\n    finally {\n        currentReactNativeTask = undefined;\n    }\n};\nconst assertTaskName = (taskName) => {\n    if (!taskName || typeof taskName !== 'string') {\n        throw new Error('taskName is required');\n    }\n};\nconst normalizeReactNativeOptions = (options) => {\n    var _a;\n    const period = (_a = options === null || options === void 0 ? void 0 : options.period) !== null && _a !== void 0 ? _a : 900;\n    return {\n        minimumInterval: Math.max(15, Math.ceil(period / 60)),\n    };\n};\nconst BackgroundTask = {\n    defineTask(taskName, callback) {\n        assertTaskName(taskName);\n        callbacks.set(taskName, callback);\n        void ensureListener().then(drainPendingTaskRuns);\n    },\n    async registerTaskAsync(taskName, options) {\n        assertTaskName(taskName);\n        if (!callbacks.has(taskName)) {\n            throw new Error(`Task \"${taskName}\" must be defined before it is registered.`);\n        }\n        await NativeBackgroundTask.registerTask({ taskName, options });\n        await ensureListener();\n        await drainPendingTaskRuns();\n    },\n    async unregisterTaskAsync(taskName) {\n        assertTaskName(taskName);\n        await NativeBackgroundTask.unregisterTask({ taskName });\n    },\n    async isTaskRegisteredAsync(taskName) {\n        assertTaskName(taskName);\n        const { value } = await NativeBackgroundTask.isTaskRegistered({ taskName });\n        return value;\n    },\n    async getRegisteredTasksAsync() {\n        const { tasks } = await NativeBackgroundTask.getRegisteredTasks();\n        return tasks;\n    },\n    async getPendingTaskRunsAsync() {\n        const { tasks } = await NativeBackgroundTask.getPendingTaskRuns();\n        return tasks;\n    },\n    async getStatusAsync() {\n        const { status } = await NativeBackgroundTask.getStatus();\n        return status;\n    },\n    async triggerTaskWorkerForTestingAsync() {\n        await ensureListener();\n        const { value } = await NativeBackgroundTask.triggerTaskWorkerForTesting();\n        await drainPendingTaskRuns();\n        return value;\n    },\n    addExpirationListener(listener) {\n        return NativeBackgroundTask.addListener('expiration', listener);\n    },\n    define(callback) {\n        this.defineTask(DEFAULT_TASK_NAME, callback);\n    },\n    schedule(options) {\n        return this.registerTaskAsync(DEFAULT_TASK_NAME, normalizeReactNativeOptions(options));\n    },\n    cancel() {\n        return this.unregisterTaskAsync(DEFAULT_TASK_NAME);\n    },\n    async statusAsync() {\n        const status = await this.getStatusAsync();\n        if (status === BackgroundTaskStatus.Available) {\n            return { available: true };\n        }\n        return {\n            available: false,\n            unavailableReason: 'restricted',\n        };\n    },\n    async finish(result = BackgroundTaskResult.Success) {\n        if (!currentReactNativeTask) {\n            return;\n        }\n        await NativeBackgroundTask.finish(Object.assign(Object.assign({}, currentReactNativeTask), { result }));\n    },\n};\nexport * from './definitions';\nexport { BackgroundTask, NativeBackgroundTask };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nimport { BackgroundTaskStatus } from './definitions';\nexport class BackgroundTaskWeb extends WebPlugin {\n    constructor() {\n        super(...arguments);\n        this.registeredTasks = new Map();\n    }\n    async registerTask(options) {\n        this.registeredTasks.set(options.taskName, options);\n    }\n    async unregisterTask(options) {\n        this.registeredTasks.delete(options.taskName);\n    }\n    async isTaskRegistered(options) {\n        return {\n            value: this.registeredTasks.has(options.taskName),\n        };\n    }\n    async getRegisteredTasks() {\n        return {\n            tasks: [...this.registeredTasks.keys()],\n        };\n    }\n    async getPendingTaskRuns() {\n        return {\n            tasks: [],\n        };\n    }\n    async getStatus() {\n        return {\n            status: BackgroundTaskStatus.Restricted,\n        };\n    }\n    async triggerTaskWorkerForTesting() {\n        const timestamp = Date.now();\n        for (const taskName of this.registeredTasks.keys()) {\n            void this.notifyListeners('backgroundTask', {\n                taskName,\n                taskId: `${taskName}:${timestamp}`,\n                timestamp,\n                test: true,\n            });\n        }\n        return {\n            value: this.registeredTasks.size > 0,\n        };\n    }\n    async finish() {\n        return;\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["BackgroundTaskResult","BackgroundTaskStatus","registerPlugin","WebPlugin"],"mappings":"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"}

package/ios/Sources/BackgroundTaskPlugin/BackgroundTask.swift

@@ -0,0 +1,269 @@
+import BackgroundTasks
+import Foundation
+import UIKit
+
+@objc public class BackgroundTask: NSObject {
+    static let defaultIdentifier = "app.capgo.backgroundtask.processing"
+    static let statusRestricted = 1
+    static let statusAvailable = 2
+    static let resultSuccess = 1
+    static let resultFailed = 2
+    static let defaultMinimumIntervalMinutes = 12 * 60
+    static let minimumIntervalMinutes = 15
+
+    private let taskIdentifier: String
+    private let defaults = UserDefaults.standard
+    private weak var plugin: BackgroundTaskPlugin?
+    private var schedulerRegistered = false
+    private var runningTaskIds = Set<String>()
+    private var activeTask: BGTask?
+    private var activeTaskSucceeded = true
+
+    private let taskNamesKey = "CapgoBackgroundTask.taskNames"
+    private let taskPrefix = "CapgoBackgroundTask.task."
+    private let pendingRunsKey = "CapgoBackgroundTask.pendingRuns"
+    private let lastRunPrefix = "CapgoBackgroundTask.lastRun."
+    private let lastResultPrefix = "CapgoBackgroundTask.lastResult."
+
+    init(taskIdentifier: String = BackgroundTask.defaultIdentifier) {
+        self.taskIdentifier = taskIdentifier
+        super.init()
+    }
+
+    func configure(plugin: BackgroundTaskPlugin) {
+        self.plugin = plugin
+        registerScheduler()
+        dispatchPendingRuns()
+    }
+
+    func registerTask(taskName: String, minimumInterval: Int, requiresNetwork: Bool) throws {
+        let normalizedInterval = normalizeInterval(minimumInterval)
+        var taskNames = getTaskNames()
+        taskNames.insert(taskName)
+        defaults.set(Array(taskNames), forKey: taskNamesKey)
+        defaults.set(
+            [
+                "taskName": taskName,
+                "minimumInterval": normalizedInterval,
+                "requiresNetwork": requiresNetwork
+            ],
+            forKey: taskPrefix + taskName
+        )
+        try scheduleNextProcessingTask()
+    }
+
+    func unregisterTask(taskName: String) {
+        var taskNames = getTaskNames()
+        taskNames.remove(taskName)
+        defaults.set(Array(taskNames), forKey: taskNamesKey)
+        defaults.removeObject(forKey: taskPrefix + taskName)
+
+        if taskNames.isEmpty {
+            BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: taskIdentifier)
+        } else {
+            try? scheduleNextProcessingTask()
+        }
+    }
+
+    func isTaskRegistered(taskName: String) -> Bool {
+        getTaskNames().contains(taskName)
+    }
+
+    func getRegisteredTasks() -> [String] {
+        Array(getTaskNames()).sorted()
+    }
+
+    func getPendingRuns() -> [[String: Any]] {
+        defaults.array(forKey: pendingRunsKey) as? [[String: Any]] ?? []
+    }
+
+    func getStatus() -> Int {
+        UIApplication.shared.backgroundRefreshStatus == .available ? BackgroundTask.statusAvailable : BackgroundTask.statusRestricted
+    }
+
+    func triggerTaskWorkerForTesting() -> Bool {
+        let taskNames = getTaskNames()
+        for taskName in taskNames {
+            recordAndDispatchRun(taskName: taskName, isTest: true)
+        }
+        return !taskNames.isEmpty
+    }
+
+    func finish(taskId: String, taskName: String?, result: Int) {
+        removePendingRun(taskId: taskId)
+
+        if let taskName = taskName, !taskName.isEmpty {
+            defaults.set(result, forKey: lastResultPrefix + taskName)
+        }
+
+        if runningTaskIds.contains(taskId) {
+            activeTaskSucceeded = activeTaskSucceeded && result == BackgroundTask.resultSuccess
+            runningTaskIds.remove(taskId)
+        }
+
+        completeActiveTaskIfNeeded()
+    }
+
+    private func registerScheduler() {
+        guard !schedulerRegistered else {
+            return
+        }
+
+        schedulerRegistered = BGTaskScheduler.shared.register(forTaskWithIdentifier: taskIdentifier, using: nil) { [weak self] task in
+            self?.handleProcessingTask(task)
+        }
+
+        if schedulerRegistered {
+            try? scheduleNextProcessingTask()
+        }
+    }
+
+    private func handleProcessingTask(_ task: BGTask) {
+        activeTask = task
+        activeTaskSucceeded = true
+        runningTaskIds.removeAll()
+        try? scheduleNextProcessingTask()
+
+        task.expirationHandler = { [weak self] in
+            self?.handleExpiration()
+        }
+
+        let dueTaskNames = dueTasks()
+        guard !dueTaskNames.isEmpty else {
+            task.setTaskCompleted(success: true)
+            activeTask = nil
+            return
+        }
+
+        for taskName in dueTaskNames {
+            let taskId = recordAndDispatchRun(taskName: taskName, isTest: false)
+            runningTaskIds.insert(taskId)
+            defaults.set(Date().timeIntervalSince1970, forKey: lastRunPrefix + taskName)
+        }
+    }
+
+    private func handleExpiration() {
+        for run in getPendingRuns() where runningTaskIds.contains(run["taskId"] as? String ?? "") {
+            plugin?.notifyListeners("expiration", data: run, retainUntilConsumed: true)
+        }
+
+        runningTaskIds.removeAll()
+        activeTaskSucceeded = false
+        completeActiveTaskIfNeeded()
+    }
+
+    private func completeActiveTaskIfNeeded() {
+        guard runningTaskIds.isEmpty, let task = activeTask else {
+            return
+        }
+
+        task.setTaskCompleted(success: activeTaskSucceeded)
+        activeTask = nil
+        try? scheduleNextProcessingTask()
+    }
+
+    private func scheduleNextProcessingTask() throws {
+        guard schedulerRegistered, !getTaskNames().isEmpty else {
+            return
+        }
+
+        let request = BGProcessingTaskRequest(identifier: taskIdentifier)
+        request.requiresNetworkConnectivity = anyTaskRequiresNetwork()
+        request.requiresExternalPower = false
+        request.earliestBeginDate = nextEarliestBeginDate()
+
+        BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: taskIdentifier)
+        try BGTaskScheduler.shared.submit(request)
+    }
+
+    private func dueTasks() -> [String] {
+        let now = Date().timeIntervalSince1970
+        return getTaskNames().filter { taskName in
+            let interval = TimeInterval(taskConfig(taskName: taskName).minimumInterval * 60)
+            let lastRun = defaults.double(forKey: lastRunPrefix + taskName)
+            return lastRun == 0 || now - lastRun >= interval
+        }
+    }
+
+    private func nextEarliestBeginDate() -> Date {
+        let now = Date()
+        var earliestDate = now.addingTimeInterval(TimeInterval(BackgroundTask.defaultMinimumIntervalMinutes * 60))
+
+        for taskName in getTaskNames() {
+            let config = taskConfig(taskName: taskName)
+            let interval = TimeInterval(config.minimumInterval * 60)
+            let lastRun = defaults.double(forKey: lastRunPrefix + taskName)
+            let nextDate = lastRun == 0 ? now.addingTimeInterval(interval) : Date(timeIntervalSince1970: lastRun + interval)
+            if nextDate < earliestDate {
+                earliestDate = nextDate
+            }
+        }
+
+        return earliestDate
+    }
+
+    private func anyTaskRequiresNetwork() -> Bool {
+        getTaskNames().contains { taskConfig(taskName: $0).requiresNetwork }
+    }
+
+    @discardableResult
+    private func recordAndDispatchRun(taskName: String, isTest: Bool) -> String {
+        let taskId = UUID().uuidString
+        let run: [String: Any] = [
+            "taskName": taskName,
+            "taskId": taskId,
+            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
+            "test": isTest
+        ]
+
+        addPendingRun(run)
+        plugin?.notifyListeners("backgroundTask", data: run, retainUntilConsumed: true)
+        return taskId
+    }
+
+    private func dispatchPendingRuns() {
+        for run in getPendingRuns() {
+            plugin?.notifyListeners("backgroundTask", data: run, retainUntilConsumed: true)
+        }
+    }
+
+    private func addPendingRun(_ run: [String: Any]) {
+        var runs = getPendingRuns()
+        runs.append(run)
+        defaults.set(runs, forKey: pendingRunsKey)
+    }
+
+    private func removePendingRun(taskId: String) {
+        let runs = getPendingRuns().filter { run in
+            run["taskId"] as? String != taskId
+        }
+        defaults.set(runs, forKey: pendingRunsKey)
+    }
+
+    private func getTaskNames() -> Set<String> {
+        Set(defaults.stringArray(forKey: taskNamesKey) ?? [])
+    }
+
+    private func taskConfig(taskName: String) -> TaskConfig {
+        guard let rawConfig = defaults.dictionary(forKey: taskPrefix + taskName) else {
+            return TaskConfig(minimumInterval: BackgroundTask.defaultMinimumIntervalMinutes, requiresNetwork: true)
+        }
+
+        return TaskConfig(
+            minimumInterval: normalizeInterval(rawConfig["minimumInterval"] as? Int ?? BackgroundTask.defaultMinimumIntervalMinutes),
+            requiresNetwork: rawConfig["requiresNetwork"] as? Bool ?? true
+        )
+    }
+
+    private func normalizeInterval(_ minimumInterval: Int) -> Int {
+        if minimumInterval <= 0 {
+            return BackgroundTask.defaultMinimumIntervalMinutes
+        }
+        return max(BackgroundTask.minimumIntervalMinutes, minimumInterval)
+    }
+}
+
+private struct TaskConfig {
+    let minimumInterval: Int
+    let requiresNetwork: Bool
+}

package/ios/Sources/BackgroundTaskPlugin/BackgroundTaskPlugin.swift

@@ -0,0 +1,101 @@
+import Foundation
+import Capacitor
+
+@objc(BackgroundTaskPlugin)
+public class BackgroundTaskPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "BackgroundTaskPlugin"
+    public let jsName = "BackgroundTask"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "registerTask", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "unregisterTask", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isTaskRegistered", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getRegisteredTasks", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPendingTaskRuns", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "triggerTaskWorkerForTesting", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "finish", returnType: CAPPluginReturnPromise)
+    ]
+
+    private lazy var implementation = BackgroundTask()
+
+    override public func load() {
+        implementation.configure(plugin: self)
+    }
+
+    @objc func registerTask(_ call: CAPPluginCall) {
+        guard let taskName = call.getString("taskName"), !taskName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            call.reject("taskName is required")
+            return
+        }
+
+        let options = call.getObject("options") ?? [:]
+        let minimumInterval = options["minimumInterval"] as? Int ?? BackgroundTask.defaultMinimumIntervalMinutes
+        let requiresNetwork = options["requiresNetwork"] as? Bool ?? true
+
+        do {
+            try implementation.registerTask(taskName: taskName, minimumInterval: minimumInterval, requiresNetwork: requiresNetwork)
+            call.resolve()
+        } catch {
+            call.reject("Unable to register background task", nil, error)
+        }
+    }
+
+    @objc func unregisterTask(_ call: CAPPluginCall) {
+        guard let taskName = call.getString("taskName"), !taskName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            call.reject("taskName is required")
+            return
+        }
+
+        implementation.unregisterTask(taskName: taskName)
+        call.resolve()
+    }
+
+    @objc func isTaskRegistered(_ call: CAPPluginCall) {
+        guard let taskName = call.getString("taskName"), !taskName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            call.reject("taskName is required")
+            return
+        }
+
+        call.resolve([
+            "value": implementation.isTaskRegistered(taskName: taskName)
+        ])
+    }
+
+    @objc func getRegisteredTasks(_ call: CAPPluginCall) {
+        call.resolve([
+            "tasks": implementation.getRegisteredTasks()
+        ])
+    }
+
+    @objc func getPendingTaskRuns(_ call: CAPPluginCall) {
+        call.resolve([
+            "tasks": implementation.getPendingRuns()
+        ])
+    }
+
+    @objc func getStatus(_ call: CAPPluginCall) {
+        call.resolve([
+            "status": implementation.getStatus()
+        ])
+    }
+
+    @objc func triggerTaskWorkerForTesting(_ call: CAPPluginCall) {
+        call.resolve([
+            "value": implementation.triggerTaskWorkerForTesting()
+        ])
+    }
+
+    @objc func finish(_ call: CAPPluginCall) {
+        guard let taskId = call.getString("taskId"), !taskId.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            call.reject("taskId is required")
+            return
+        }
+
+        implementation.finish(
+            taskId: taskId,
+            taskName: call.getString("taskName"),
+            result: call.getInt("result") ?? BackgroundTask.resultSuccess
+        )
+        call.resolve()
+    }
+}

package/ios/Tests/BackgroundTaskPluginTests/BackgroundTaskTests.swift

@@ -0,0 +1,18 @@
+import XCTest
+@testable import BackgroundTaskPlugin
+
+class BackgroundTaskTests: XCTestCase {
+    func testRegisterAndUnregisterTask() throws {
+        let implementation = BackgroundTask()
+        let taskName = "unit-test-background-task"
+
+        implementation.unregisterTask(taskName: taskName)
+        XCTAssertFalse(implementation.isTaskRegistered(taskName: taskName))
+
+        try implementation.registerTask(taskName: taskName, minimumInterval: 1, requiresNetwork: false)
+        XCTAssertTrue(implementation.isTaskRegistered(taskName: taskName))
+
+        implementation.unregisterTask(taskName: taskName)
+        XCTAssertFalse(implementation.isTaskRegistered(taskName: taskName))
+    }
+}