@capacitor/background-runner 1.0.0-rc.1

package/CapacitorBackgroundRunner.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorBackgroundRunner'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,310 @@
+# @capacitor/background-runner
+
+Background Runner provides an event-based standalone JavaScript environment for executing your Javascript code outside of the web view.
+
+## Install
+
+```bash
+npm install @capacitor/background-runner
+npx cap sync
+```
+
+Background Runner has support for various device APIs that require permission from the user prior to use.
+## iOS
+
+On iOS you must enable the Background Modes capability. 
+
+![Enable Background Mode Capability in Xcode](docs/enable_background_mode_capability.png)
+
+Once added, you must enable the `Background fetch` and `Background processing` modes at a minimum to enable the ability to register and schedule your background tasks.  
+
+If you will be making use of Geolocation or Push Notifications, enable `Location updates` or `Remote notifications` respectively.
+
+![Configure Background Modes in Xcode](docs/configure_background_modes.png)
+
+After enabling the Background Modes capability, add the following to your app's `AppDelegate.swift`:
+
+```swift
+func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+    
+    // ....
+    BackgroundRunnerPlugin.registerBackgroundTask()
+    BackgroundRunnerPlugin.handleApplicationDidFinishLaunching(launchOptions: launchOptions)
+    // ....
+
+    return true
+}
+```
+
+To allow the Background Runner to handle remote notifications, add the following:
+```swift
+func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+        // ....
+        BackgroundRunnerPlugin.dispatchEvent(event: "remoteNotification", eventArgs: userInfo) { result in
+            switch result {
+            case .success:
+                completionHandler(.newData)
+            case .failure:
+                completionHandler(.failed)
+            }
+        }
+    }
+```
+
+### Geolocation
+Apple requires privacy descriptions to be specified in `Info.plist` for location information:
+
+- `NSLocationAlwaysUsageDescription` (`Privacy - Location Always Usage Description`)
+- `NSLocationWhenInUseUsageDescription` (`Privacy - Location When In Use Usage Description`)
+
+Read about [Configuring `Info.plist`](https://capacitorjs.com/docs/ios/configuration#configuring-infoplist) in the [iOS Guide](https://capacitorjs.com/docs/ios) for more information on setting iOS permissions in Xcode
+
+## Android
+
+### Geolocation
+This API requires the following permissions be added to your `AndroidManifest.xml`:
+
+```xml
+<!-- Geolocation API -->
+<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+<uses-feature android:name="android.hardware.location.gps" />
+```
+
+The first two permissions ask for location data, both fine and coarse, and the last line is optional but necessary if your app _requires_ GPS to function. You may leave it out, though keep in mind that this may mean your app is installed on devices lacking GPS hardware.
+
+### Local Notifications
+Android 13 requires a permission check in order to send notifications.  You are required to call `checkPermissions()` and `requestPermissions()` accordingly.
+
+On Android 12 and older it won't show a prompt and will just return as granted.
+
+Starting on Android 12, scheduled notifications won't be exact unless this permission is added to your `AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+```
+
+Note that even if the permission is present, users can still disable exact notifications from the app settings.
+
+Read about [Setting Permissions](https://capacitorjs.com/docs/android/configuration#setting-permissions) in the [Android Guide](https://capacitorjs.com/docs/android) for more information on setting Android permissions.
+
+## Using Background Runner
+Background Runner is an event based JavaScript environment that emits events to a javascript runner file that you designate in your `capacitor.config.ts` file.  If the runner finds a event handler corresponding to incoming event in your runner file, it will execute the event handler, then shutdown once `details.completed()` is called (or if the OS force kills your process).
+
+#### Example Runner JS File
+
+```js
+addEventListener("myCustomEvent", (details) => {
+  console.log("do something to update the system here");
+  details.completed();
+});
+
+addEventListener("myCustomEventWithReturnData", (details) => {
+  console.log("accepted this data: " + JSON.stringify(details.user));
+
+  const updatedUser = details.user;
+  updatedUser.firstName = updatedUser.firstName + " HELLO";
+  updatedUser.lastName = updatedUser.lastName + " WORLD";
+
+  details.completed(updatedUser);
+});
+
+addEventListener("remoteNotification", (details) => {
+  console.log("received silent push notification");
+
+  CapacitorNotifications.schedule([
+    {
+        id: 100,
+        title: "Enterprise Background Runner",
+        body: "Received silent push notification",
+    },
+  ]);
+
+  details.completed();
+});
+
+```
+Calling `details.completed()` is **required** within every event handler called by the runner.  Failure to do this could result in your runner being killed by the OS if your event is called while the app is in the background.  If the app is in the foreground, async calls to `dispatchEvent` may not resolve.
+
+## Configuring Background Runner
+On load, Background Runner will automatically register a background task that will be scheduled and ran once your app is backgrounded.  The settings for this behavior is defined in your `capacitor.config.ts` file:
+
+```ts
+const config: CapacitorConfig = {
+    plugins: {
+        BackgroundRunner: {
+            label: "com.example.background.task",
+            src: "background.js",
+            event: "myCustomEvent",
+            repeat: true,
+            interval: 2,
+            autoStart: false,
+        },
+    },
+}
+```
+
+
+## JavaScript API
+
+Background Runner does not execute your Javascript code in a browser or web view, therefore the typical Web APIs you may be used to may not be available. This includes DOM APIs nor ability to interact with your application's DOM.
+
+Below is a list of the available Web APIs provided in Background Runner:
+
+- [console](https://developer.mozilla.org/en-US/docs/Web/API/console)
+    - only `info`, `log`, `warn`, `error` , and `debug` are available
+- [TextDecoder](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder)
+    - only `decode` is available
+- [TextEncoder](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder)
+    - only `encode` is available
+- [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+    - Event Listener options and `useCapture` not supported
+- [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/setTimeout)
+- [setInterval](https://developer.mozilla.org/en-US/docs/Web/API/setInterval)
+- [clearTimeout](https://developer.mozilla.org/en-US/docs/Web/API/clearTimeout)
+- [clearInterval](https://developer.mozilla.org/en-US/docs/Web/API/clearInterval)
+- [crypto](https://developer.mozilla.org/en-US/docs/Web/API/Crypto)
+- [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+    - Request object not yet supported
+    - Only `method`, `headers` and `body` supported in options object
+
+In addition to the standard Web APIs, Background Runner also supports a number of custom APIs that expose relevant mobile device functionality:
+
+- CapacitorKV - a simple string key / value store backed by UserDefaults on iOS and Shared Preferences on Android.
+    - `get(key: string): string`
+    - `set(key: string, value: string)`
+    - `remove(key: string)`
+- CapacitorNotifications - basic support for sending local notifications.
+    - `schedule()`
+- CapacitorDevice - provides information on the device, such as network connectivity and battery status.
+    - `getBatteryStatus()`
+    - `getNetworkStatus()`
+- CapacitorGeolocation - provides access to the device location information
+    - `getCurrentPosition()`
+
+## Runner Lifetimes
+
+Currently, the runners are designed for performing periodic bursts of work while your app is in the background, or for executing asynchronous work in a separate thread from your UI while your app is in the foreground.  As a result, runners are not long lived.  State is not maintained between calls to events in the runner.  Each call to `dispatchEvent()` creates a new context in with your runner code is loaded and executed, and once `completed()` is called, the context is destroyed.
+
+## Limitations of Background Tasks
+
+It’s not possible to run persistent, always running background services on mobile operating systems.  Due to the limitations imposed by iOS and Android designed to reduce battery and data consumption, background tasks are constrained with various limitations that you must keep in mind while designing and implementing your background task.
+
+### iOS
+
+- Each invocation of your task has approximately up to 30 seconds of runtime before you must call `completed()` or your task is killed.
+- While you can set an interval to define when your task runs after the app is backgrounded, or how often it should run, this is not guaranteed.  iOS will determine when and how often you task will ultimately run, determined in part by how often you app is used.
+
+### Android
+
+- Your task has a maximum of 10 minutes to perform work, but to keep your task cross platform compatible, you should limit your work to 30 seconds at most.
+- Repeating background tasks have a minimal interval of at least 15 minutes.  Similar to iOS, any interval you request may not be hit exactly - actual execution time is subject to OS battery optimizations and other heuristics.
+
+## API
+
+<docgen-index>
+
+* [`checkPermissions()`](#checkpermissions)
+* [`requestPermissions(...)`](#requestpermissions)
+* [`dispatchEvent(...)`](#dispatchevent)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### checkPermissions()
+
+```typescript
+checkPermissions() => any
+```
+
+Check permissions for the various Capacitor device APIs.
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### requestPermissions(...)
+
+```typescript
+requestPermissions(options: RequestPermissionOptions) => any
+```
+
+Request permission to display local notifications.
+
+| Param         | Type                                                                          |
+| ------------- | ----------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#requestpermissionoptions">RequestPermissionOptions</a></code> |
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### dispatchEvent(...)
+
+```typescript
+dispatchEvent(options: DispatchEventOptions) => any
+```
+
+Dispatches an event to the configured runner.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#dispatcheventoptions">DispatchEventOptions</a></code> |
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### PermissionStatus
+
+| Prop                | Type                                                        |
+| ------------------- | ----------------------------------------------------------- |
+| **`geolocation`**   | <code><a href="#permissionstate">PermissionState</a></code> |
+| **`notifications`** | <code><a href="#permissionstate">PermissionState</a></code> |
+
+
+#### RequestPermissionOptions
+
+| Prop       | Type            |
+| ---------- | --------------- |
+| **`apis`** | <code>{}</code> |
+
+
+#### DispatchEventOptions
+
+| Prop          | Type                                 | Description                                | Since |
+| ------------- | ------------------------------------ | ------------------------------------------ | ----- |
+| **`label`**   | <code>string</code>                  | The runner label to dispatch the event to  | 1.0.0 |
+| **`event`**   | <code>string</code>                  | The name of the registered event listener. | 1.0.0 |
+| **`details`** | <code>{ [key: string]: any; }</code> |                                            |       |
+
+
+### Type Aliases
+
+
+#### PermissionState
+
+<code>'prompt' | 'prompt-with-rationale' | 'granted' | 'denied'</code>
+
+
+#### API
+
+<code>'geolocation' | 'notifications'</code>
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,67 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+    workManagerVersion = project.hasProperty('workManagerVersion') ? rootProject.ext.workManagerVersion : '2.8.1'
+
+}
+
+buildscript {
+    ext {
+        kotlin_version = '1.8.20'
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 33
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    flatDir { dirs "./src/main/libs" }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation (name: "android-js-engine-release", ext: "aar")
+    implementation "androidx.work:work-runtime-ktx:$workManagerVersion"
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'androidx.core:core-ktx:1.10.1'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.ionic.backgroundrunner.plugin">
+
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <application>
+        <receiver android:name=".api.TimedNotificationPublisher" />
+    </application>
+</manifest>

package/android/src/main/java/io/ionic/backgroundrunner/plugin/BackgroundRunner.kt

@@ -0,0 +1,166 @@
+package io.ionic.backgroundrunner.plugin
+
+import android.content.res.AssetManager
+import androidx.work.Data
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequest
+import androidx.work.PeriodicWorkRequest
+import androidx.work.WorkManager
+import io.ionic.android_js_engine.Context
+import io.ionic.android_js_engine.JSFunction
+import io.ionic.android_js_engine.Runner
+import io.ionic.android_js_engine.api.CapacitorAPI
+import io.ionic.backgroundrunner.plugin.api.Device
+import io.ionic.backgroundrunner.plugin.api.Geolocation
+import io.ionic.backgroundrunner.plugin.api.KV
+import io.ionic.backgroundrunner.plugin.api.Notifications
+import kotlinx.coroutines.flow.MutableStateFlow
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.lang.Exception
+import java.util.concurrent.TimeUnit
+
+
+class BackgroundRunner(context: android.content.Context) {
+    public val config: RunnerConfig?
+    private var runner: Runner? = null
+    private var context: Context? = null
+
+    companion object {
+        @Volatile private var instance: BackgroundRunner? = null
+
+        fun getInstance(context: android.content.Context): BackgroundRunner = instance ?: synchronized(this) {
+            instance ?: BackgroundRunner(context).also { instance = it }
+        }
+    }
+
+    private val started: Boolean
+        get() {
+            return runner != null && context != null
+        }
+
+    init {
+        config = loadRunnerConfig(context.assets)
+    }
+
+    fun start(androidContext: android.content.Context) {
+        config ?: throw Exception("...no runner config to start")
+
+        runner = Runner()
+        context = initContext(config, androidContext)
+    }
+
+    fun scheduleBackgroundTask(androidContext: android.content.Context) {
+        config ?: throw Exception("...no runner config to schedule")
+
+        val interval = config.interval ?: throw Exception("cannot register background task without a configured interval")
+
+        if (!config.autoSchedule) {
+            return
+        }
+
+        val data = Data.Builder()
+            .putString("label", config.label)
+            .putString("src", config.src)
+            .putString("event", config.event)
+            .build()
+
+        if (!config.repeats) {
+            val work = OneTimeWorkRequest.Builder(RunnerWorker::class.java)
+                .setInitialDelay(interval.toLong(), TimeUnit.MINUTES)
+                .setInputData(data)
+                .addTag(config.label)
+                .build()
+            WorkManager.getInstance(androidContext).enqueueUniqueWork(config.label, ExistingWorkPolicy.REPLACE, work)
+        } else {
+            val work = PeriodicWorkRequest.Builder(RunnerWorker::class.java, interval.toLong(), TimeUnit.MINUTES)
+                .setInitialDelay(interval.toLong(), TimeUnit.MINUTES)
+                .setInputData(data)
+                .addTag(config.label)
+                .build()
+            WorkManager.getInstance(androidContext).enqueueUniquePeriodicWork(config.label, ExistingPeriodicWorkPolicy.UPDATE, work)
+        }
+    }
+
+    suspend fun execute(androidContext: android.content.Context, config: RunnerConfig, args: JSONObject = JSONObject()): JSONObject? {
+        if (!started) {
+            start(androidContext)
+        }
+
+        context ?: throw Exception("no loaded context for config")
+
+        val future = MutableStateFlow<Result<JSONObject?>?>(null)
+
+        class CompletionCallback : JSFunction(jsName = "completed") {
+            override fun run() {
+                super.run()
+                future.value = Result.success(this.args)
+            }
+        }
+
+        val callback = CompletionCallback()
+        context!!.registerFunction("_backgroundCallback", callback)
+
+        args.put("completed", "__cbr::_backgroundCallback")
+
+        context!!.dispatchEvent(config.event, args)
+
+        val finished = future.conditionalAwait {
+            it != null
+        }
+
+        runner?.destroy()
+
+        runner = null
+
+        if (finished!!.isSuccess) {
+            return finished.getOrNull()
+        } else {
+            val ex = finished.exceptionOrNull()
+            ex ?: throw Exception("unknown exception")
+            throw ex
+        }
+    }
+
+    private fun loadRunnerConfig(assetManager: AssetManager): RunnerConfig {
+        BufferedReader(InputStreamReader(assetManager.open("capacitor.config.json"))).use { reader ->
+            val buffer = StringBuilder()
+            var line: String?
+            while (reader.readLine().also { line = it } != null) {
+                buffer.append(line).append("\n")
+            }
+             val fileContents = buffer.toString();
+
+            val configObject = JSONObject(fileContents)
+            val plugins = configObject.getJSONObject("plugins") ?: throw Exception("could not read config file")
+            val runnerConfigObj = plugins.getJSONObject("BackgroundRunner") ?: throw Exception("could not read config file")
+
+            return  RunnerConfig(runnerConfigObj)
+        }
+    }
+
+    private fun initContext(config: RunnerConfig, context: android.content.Context): Context {
+        runner ?: throw Exception("runner is not initialized")
+
+        val srcFile = context.assets.open("public/${config.src}").bufferedReader().use {
+            it.readText()
+        }
+
+        val newContext  = runner!!.createContext(config.label)
+
+        val api = CapacitorAPI(config.label)
+        api.initNotificationsAPI(Notifications(context))
+        api.initDeviceAPI(Device(context))
+        api.initGeolocationAPI(Geolocation(context))
+        api.initKVAPI(KV(context, config.label))
+
+        newContext.setCapacitorAPI(api)
+
+
+        newContext.execute(srcFile, false)
+
+        return newContext
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/BackgroundRunnerPlugin.kt

@@ -0,0 +1,102 @@
+package io.ionic.backgroundrunner.plugin;
+
+import android.Manifest
+import android.util.Log
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+
+
+@CapacitorPlugin(
+    name = "BackgroundRunner",
+    permissions = [
+        Permission(
+            strings = [Manifest.permission.ACCESS_COARSE_LOCATION],
+            alias = BackgroundRunnerPlugin.GEOLOCATION
+        ),
+        Permission(
+            strings = [Manifest.permission.POST_NOTIFICATIONS],
+            alias = BackgroundRunnerPlugin.NOTIFICATIONS
+        )
+    ]
+)
+class BackgroundRunnerPlugin: Plugin() {
+    private var impl: BackgroundRunner? = null
+
+    companion object {
+        const val GEOLOCATION = "geolocation"
+        const val NOTIFICATIONS = "notifications"
+    }
+
+    override fun load() {
+        super.load()
+        impl = BackgroundRunner.getInstance(this.context)
+
+        bridge.app.setStatusChangeListener {
+            if (!it) {
+                Log.d("Background Runner", "registering runner workers")
+                impl?.scheduleBackgroundTask(this.context)
+            }
+        }
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        super.checkPermissions(call)
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        val apiToRequest = call.getArray("apis").toList<String>()
+        super.requestPermissionForAliases(apiToRequest.toTypedArray(), call, "completePermissionsCallback")
+    }
+
+    @PermissionCallback
+    fun completePermissionsCallback(call: PluginCall) {
+        super.checkPermissions(call)
+    }
+
+    @PluginMethod
+    fun dispatchEvent(call: PluginCall) {
+        try {
+            val impl = BackgroundRunner.getInstance(this.context)
+
+            val runnerEvent = call.getString("event") ?: throw Exception("event is missing or invalid")
+            val details = call.getObject("details")
+            val config = impl.config ?: throw Exception("no runner config loaded")
+            config.event = runnerEvent
+
+            GlobalScope.launch(Dispatchers.Default) {
+                try {
+                    val returnData = impl.execute(
+                        this@BackgroundRunnerPlugin.context,
+                        config,
+                        details
+                    )
+
+                    if (returnData != null) {
+                        call.resolve(JSObject.fromJSONObject(returnData))
+                    } else {
+                        call.resolve()
+                    }
+                } catch (ex: Exception) {
+                    call.reject(ex.message)
+                }
+            }
+        } catch(ex: Exception) {
+            call.reject(ex.message)
+        }
+    }
+
+    @PluginMethod
+    fun registerBackgroundTask(call: PluginCall) {
+        call.resolve()
+    }
+}