@capacitor/background-runner 1.0.1-dev-20230807T230144.0 → 1.0.1

package/README.md

@@ -10,13 +10,14 @@ 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. 
+On iOS you must enable the Background Modes capability.
 
 ![Enable Background Mode Capability in Xcode](https://github.com/ionic-team/capacitor-background-runner/raw/main/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.  
+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.
 
@@ -26,7 +27,7 @@ After enabling the Background Modes capability, add the following to your app's
 
 ```swift
 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
-    
+
     // ....
     BackgroundRunnerPlugin.registerBackgroundTask()
     BackgroundRunnerPlugin.handleApplicationDidFinishLaunching(launchOptions: launchOptions)
@@ -37,6 +38,7 @@ func application(_ application: UIApplication, didFinishLaunchingWithOptions lau
 ```
 
 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) {
         // ....
@@ -52,6 +54,7 @@ func application(_ application: UIApplication, didReceiveRemoteNotification user
 ```
 
 ### Geolocation
+
 Apple requires privacy descriptions to be specified in `Info.plist` for location information:
 
 - `NSLocationAlwaysUsageDescription` (`Privacy - Location Always Usage Description`)
@@ -62,6 +65,7 @@ Read about [Configuring `Info.plist`](https://capacitorjs.com/docs/ios/configura
 ## Android
 
 ### Geolocation
+
 This API requires the following permissions be added to your `AndroidManifest.xml`:
 
 ```xml
@@ -74,7 +78,8 @@ This API requires the following permissions be added to your `AndroidManifest.xm
 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.
+
+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.
 
@@ -89,62 +94,71 @@ Note that even if the permission is present, users can still disable exact notif
 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).
+
+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 `resolve()` or `reject()` are 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('myCustomEvent', (resolve, reject, args) => {
+  console.log('do something to update the system here');
+  resolve();
 });
 
-addEventListener("myCustomEventWithReturnData", (details) => {
-  console.log("accepted this data: " + JSON.stringify(details.user));
+addEventListener('myCustomEventWithReturnData', (resolve, reject, args) => {
+  try {
+    console.log('accepted this data: ' + JSON.stringify(args.user));
 
-  const updatedUser = details.user;
-  updatedUser.firstName = updatedUser.firstName + " HELLO";
-  updatedUser.lastName = updatedUser.lastName + " WORLD";
+    const updatedUser = args.user;
+    updatedUser.firstName = updatedUser.firstName + ' HELLO';
+    updatedUser.lastName = updatedUser.lastName + ' WORLD';
 
-  details.completed(updatedUser);
+    resolve(updatedUser);
+  } catch (err) {
+    reject(err);
+  }
 });
 
-addEventListener("remoteNotification", (details) => {
-  console.log("received silent push notification");
+addEventListener('remoteNotification', (resolve, reject, args) => {
+  try {
+    console.log('received silent push notification');
 
-  CapacitorNotifications.schedule([
-    {
+    CapacitorNotifications.schedule([
+      {
         id: 100,
-        title: "Enterprise Background Runner",
-        body: "Received silent push notification",
-    },
-  ]);
-
-  details.completed();
+        title: 'Enterprise Background Runner',
+        body: 'Received silent push notification',
+      },
+    ]);
+
+    resolve();
+  } catch (err) {
+    reject();
+  }
 });
-
 ```
-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.
+
+Calling `resolve()` \ `reject()` 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:
+
+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,
-        },
+  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.
@@ -152,48 +166,47 @@ Background Runner does not execute your Javascript code in a browser or web view
 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
+  - only `info`, `log`, `warn`, `error` , and `debug` are available
 - [TextDecoder](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder)
-    - only `decode` is available
+  - only `decode` is available
 - [TextEncoder](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder)
-    - only `encode` is available
+  - only `encode` is available
 - [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
-    - Event Listener options and `useCapture` not supported
+  - 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
+  - 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 Capacitor APIs](#capacitor-api) custom APIs that expose relevant mobile device functionality
 
-
-
 ## 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.
+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 thread separate 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 which your runner code is loaded and executed, and once `resolve()` or `reject()` is called, the context is destroyed.
 
 ## Android Battery Optimizations
-Some Android vendors offer built-in battery optimization settings that go beyond what stock Android provides.  Some of these optimizations must be disabled by your end users in order for your background tasks to work properly.
+
+Some Android vendors offer built-in battery optimization settings that go beyond what stock Android provides. Some of these optimizations must be disabled by your end users in order for your background tasks to work properly.
 
 Visit [Don't kill my app!](https://dontkillmyapp.com) for more information on the affected manufacturers and steps required by your users to adjust the settings.
 
 ## 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.
+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.
+- 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.
+- 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
 
@@ -304,8 +317,8 @@ Dispatches an event to the configured runner.
 
 </docgen-api>
 
-
 ## Capacitor API
+
 <capacitor-api-docs>
 
 <!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
@@ -404,4 +417,4 @@ Get access to device location information.
 | **`speed`**            | <code>number \| null</code> | The speed the user is traveling (if available)                                                                        | 1.0.0 |
 | **`heading`**          | <code>number \| null</code> | The heading the user is facing (if available)                                                                         | 1.0.0 |
 
-</capacitor-api-docs>
+</capacitor-api-docs>

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

@@ -50,6 +50,7 @@ class BackgroundRunner(context: android.content.Context) {
 
         runner = Runner()
         context = initContext(config, androidContext)
+        context?.start()
     }
 
     fun scheduleBackgroundTask(androidContext: android.content.Context) {
@@ -84,7 +85,7 @@ class BackgroundRunner(context: android.content.Context) {
         }
     }
 
-    suspend fun execute(androidContext: android.content.Context, config: RunnerConfig, args: JSONObject = JSONObject()): JSONObject? {
+    suspend fun execute(androidContext: android.content.Context, config: RunnerConfig, dataArgs: JSONObject = JSONObject()): JSONObject? {
         if (!started) {
             start(androidContext)
         }
@@ -93,17 +94,37 @@ class BackgroundRunner(context: android.content.Context) {
 
         val future = MutableStateFlow<Result<JSONObject?>?>(null)
 
-        class CompletionCallback : JSFunction(jsName = "completed") {
+        class ResolveCallback : JSFunction(jsName = "resolve") {
             override fun run() {
                 super.run()
                 future.value = Result.success(this.args)
             }
         }
 
-        val callback = CompletionCallback()
-        context!!.registerFunction("_backgroundCallback", callback)
+        class RejectCallback : JSFunction(jsName = "reject") {
+            override fun run() {
+                super.run()
+                val rejectionTitle = this.args?.optString("name", "Error") ?: "Error"
+                val rejectionMessage = this.args?.optString("message") ?: ""
+                val error = Exception("$rejectionTitle: $rejectionMessage")
+
+                future.value = Result.failure(error)
+            }
+        }
 
-        args.put("completed", "__cbr::_backgroundCallback")
+        val resolve = ResolveCallback()
+        val reject = RejectCallback()
+        context!!.registerFunction("_resolveCallback", resolve)
+        context!!.registerFunction("_rejectCallback", reject)
+
+        val args = JSONObject()
+
+        val callbacks = JSONObject();
+        callbacks.put("resolve", "__cbr::_resolveCallback")
+        callbacks.put("reject", "__cbr::_rejectCallback")
+
+        args.put("callbacks", callbacks)
+        args.put("dataArgs", dataArgs)
 
         context!!.dispatchEvent(config.event, args)
 
@@ -158,7 +179,6 @@ class BackgroundRunner(context: android.content.Context) {
 
         newContext.setCapacitorAPI(api)
 
-
         newContext.execute(srcFile, false)
 
         return newContext

package/ios/Plugin/BackgroundRunner.swift

@@ -145,17 +145,12 @@ public class BackgroundRunner {
                 throw BackgroundRunnerPluginError.runnerError(reason: "no loaded context for config")
             }
 
-            var inputArgsWithCallback = inputArgs
-
-            if inputArgsWithCallback == nil {
-                inputArgsWithCallback = [:]
-            }
-
             let waitGroup = DispatchGroup()
 
             var result: [String: Any]?
+            var rejectionErr: JSError?
 
-            let completedFunc: @convention(block)(JavaScriptCore.JSValue) -> Void = { returnObj in
+            let resolveFunc: @convention(block)(JavaScriptCore.JSValue) -> Void = { returnObj in
                 if !returnObj.isUndefined && !returnObj.isNull {
                     var dict: [String: Any] = [:]
 
@@ -170,14 +165,57 @@ public class BackgroundRunner {
                 return
             }
 
-            inputArgsWithCallback?["__ebr::completed"] = completedFunc
+            let rejectFunc: @convention(block)(JavaScriptCore.JSValue) -> Void = { rejectObj in
+                var rejectionTitle = "Error"
+                var rejectionMessage = ""
+
+                if !rejectObj.isUndefined && !rejectObj.isNull {
+                    if let errStr = rejectObj.toString() {
+                        let split = errStr.split(separator: ":", maxSplits: 1)
+                        if split.count == 0 {
+                            rejectionMessage = String(split.first ?? "")
+                        } else {
+                            rejectionTitle = String(split.first ?? "Error")
+                            rejectionMessage = String(split.last ?? "")
+                        }
+                    }
+
+                    if rejectObj.isObject, let errDict = rejectObj.toDictionary() {
+                        if let errTitle = errDict["name"] as? String {
+                            rejectionTitle = errTitle
+                        }
+
+                        if let errMsg = errDict["message"] as? String {
+                            rejectionMessage = errMsg
+                        }
+                    }
+                }
+
+                rejectionErr = JSError(message: "\(rejectionTitle): \(rejectionMessage)")
+
+                waitGroup.leave()
+                return
+            }
+
+            var args: [String: Any] = [:]
+
+            var callbacks: [String: Any] = [:]
+            callbacks["__cbr::resolve"] = resolveFunc
+            callbacks["__cbr::reject"] = rejectFunc
+
+            args["callbacks"] = callbacks
+            args["dataArgs"] = inputArgs
 
             waitGroup.enter()
 
-            try context.dispatchEvent(event: event, details: inputArgsWithCallback)
+            try context.dispatchEvent(event: event, details: args)
 
             waitGroup.wait()
 
+            if let rejection = rejectionErr {
+                throw EngineError.jsException(details: rejection.message)
+            }
+
             return result
         } catch {
             print("error executing task: \(error)")

package/ios/Plugin/CapacitorAPI/KV.swift

@@ -3,7 +3,7 @@ import JavaScriptCore
 
 @objc protocol CapacitorKVStoreExports: JSExport {
     static func set(_ key: String, _ value: String)
-    static func get(_ key: String) -> String?
+    static func get(_ key: String) -> JSValue
     static func remove(_ key: String)
 }
 
@@ -12,8 +12,13 @@ class CapacitorKVStore: NSObject, CapacitorKVStoreExports {
         UserDefaults.standard.set(value, forKey: key)
     }
 
-    static func get(_ key: String) -> String? {
-        return UserDefaults.standard.string(forKey: key)
+    static func get(_ key: String) -> JSValue {
+        var valueWrapper: [String: String] = [:]
+
+        let value = UserDefaults.standard.string(forKey: key)
+        valueWrapper["value"] = value
+
+        return JSValue(object: valueWrapper, in: JSContext.current())
     }
 
     static func remove(_ key: String) {

package/ios/Plugin/RunnerEngine/Context.swift

@@ -6,7 +6,9 @@ public class Context {
     let ctx: JSContext
 
     private var timers = [Int: Timer]()
-    private var eventListeners = [String: [JSValue]]()
+    private var eventListeners = [String: JSValue]()
+    private var thread: Thread!
+    private var runLoop: RunLoop?
 
     // swiftlint:disable:next identifier_name
     public init(vm: JSVirtualMachine, ctxName: String) throws {
@@ -19,6 +21,20 @@ public class Context {
         name = ctxName
         ctx = newCtx
 
+        thread = Thread { [weak self] in
+            self?.runLoop = RunLoop.current
+
+            while self != nil && !self!.thread.isCancelled && self!.runLoop != nil {
+                self?.runLoop?.run(mode: .default, before: .distantFuture)
+            }
+
+            Thread.exit()
+        }
+
+        thread.name = "[\(name)] context thread"
+        thread.qualityOfService = .userInitiated
+        thread.start()
+
         try setupWebAPI()
     }
 
@@ -39,41 +55,51 @@ public class Context {
     }
 
     public func dispatchEvent(event: String, details: [String: Any]? = nil) throws {
-        if let callbacks = eventListeners[event] {
-            try callbacks.forEach { jsFunc in
-                var thrownException: JSValue?
+        if let eventHandler = eventListeners[event] {
+            var dataArgs = details?["dataArgs"] as? [String: Any]
+            if dataArgs == nil {
+                dataArgs = details
+            }
 
-                self.ctx.exceptionHandler = { _, exception in
-                    thrownException = exception
+            var callbackFunctions: [String: JSValue] = [:]
+
+            if let callbacks = details?["callbacks"] as? [String: Any] {
+                callbacks.keys.forEach { key in
+                    if key.hasPrefix("__cbr::") {
+                        let funcName = key.replacingOccurrences(of: "__cbr::", with: "")
+                        callbackFunctions[funcName] = JSValue.init(object: callbacks[key], in: self.ctx)
+                    }
                 }
+            }
 
-                if let detailsObj = details {
-                    var callbackFunctions: [String: Any] = [:]
+            var thrownException: JSValue?
 
-                    detailsObj.keys.forEach { key in
-                        if key.hasPrefix("__ebr::") {
-                            let funcName = key.replacingOccurrences(of: "__ebr::", with: "")
-                            callbackFunctions[funcName] = detailsObj[key]
-                        }
-                    }
+            self.ctx.exceptionHandler = { _, exception in
+                thrownException = exception
+            }
 
-                    guard let jsDetailsObj = JSValue(object: detailsObj, in: self.ctx) else {
-                        throw EngineError.jsValueError
-                    }
+            var callArgs: [Any] = []
 
-                    callbackFunctions.forEach { (funcName: String, jsFunc: Any) in
-                        jsDetailsObj.setValue(jsFunc, forProperty: funcName)
-                    }
+            if let resolveFunc = callbackFunctions["resolve"],
+               let rejectFunc = callbackFunctions["reject"] {
+                callArgs.append(resolveFunc)
+                callArgs.append(rejectFunc)
+            }
 
-                    jsFunc.call(withArguments: [jsDetailsObj])
-                } else {
-                    jsFunc.call(withArguments: [])
+            if let dataArgs = dataArgs {
+                guard let jsDataArgs = JSValue(object: dataArgs, in: self.ctx) else {
+                    throw EngineError.jsValueError
                 }
 
-                if let exception = thrownException {
-                    throw EngineError.jsException(details: String(describing: exception))
-                }
+                callArgs.append(jsDataArgs)
             }
+
+            eventHandler.call(withArguments: callArgs)
+
+            if let exception = thrownException {
+                throw EngineError.jsException(details: String(describing: exception))
+            }
+
         }
     }
     private func setupWebAPI() throws {
@@ -93,6 +119,7 @@ public class Context {
         let fetchFunc: @convention(block) (JSValue, JSValue) -> JSValue = { resource, options in
             return fetch(resource: resource, options: options)
         }
+
         let newTextEncoderConst: @convention(block) () -> JSTextEncoder = JSTextEncoder.init
         let newTextDecoderConst: @convention(block) (String?, [AnyHashable: Any]?) -> JSTextDecoder = JSTextDecoder.init
 
@@ -110,15 +137,11 @@ public class Context {
     }
 
     private func addEventListener(eventName: String, callback: JSValue) {
-        if eventListeners[eventName] == nil {
-            eventListeners[eventName] = [callback]
-        } else {
-            eventListeners[eventName]?.append(callback)
-        }
+        eventListeners[eventName] = callback
     }
 
     private func initTimer(callback: JSValue, timeout: Int, isInterval: Bool) -> Int {
-        let timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(timeout / 1000), repeats: isInterval) { t in
+        let timer = Timer(timeInterval: TimeInterval(timeout / 1000), repeats: isInterval) { t in
             callback.call(withArguments: [])
             if !isInterval {
                 let timerId = Int(Int32.init(truncatingIfNeeded: t.hashValue))
@@ -127,11 +150,16 @@ public class Context {
         }
 
         let timerId = Int(Int32.init(truncatingIfNeeded: timer.hashValue))
-
-        RunLoop.current.add(timer, forMode: .common)
-
         timers[timerId] = timer
 
+        if let runLoop = self.runLoop {
+            runLoop.add(timer, forMode: .default)
+            runLoop.add(timer, forMode: .common)
+        } else {
+            RunLoop.current.add(timer, forMode: .default)
+            RunLoop.current.add(timer, forMode: .common)
+        }
+
         return timerId
     }
 

package/ios/Plugin/RunnerEngine/JSResponse.swift

@@ -15,7 +15,7 @@ import JavaScriptCore
     dynamic var status: Int
     // swiftlint:disable:next identifier_name
     dynamic var ok: Bool {
-        return status > 200 && status <= 299
+        return status >= 200 && status <= 299
     }
 
     private let data: Data?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/background-runner",
-  "version": "1.0.1-dev-20230807T230144.0",
+  "version": "1.0.1",
   "description": "Capacitor Background Runner",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -80,5 +80,5 @@
       "src": "android"
     }
   },
-  "gitHead": "0c7dde163121b218b5599b4aa072527daa37a771"
+  "gitHead": "737db866d360fc2717724ddfa470ba0aad729ab6"
 }