@iternio/react-native-auto-play 0.6.1 → 0.7.0

package/nitrogen/generated/shared/c++/AssetImage.hpp

@@ -31,9 +31,9 @@
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 
+#include <string>
 #include "NitroColor.hpp"
 #include <optional>
-#include <string>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -42,16 +42,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
    */
   struct AssetImage final {
   public:
-    std::optional<NitroColor> color     SWIFT_PRIVATE;
-    bool packager_asset     SWIFT_PRIVATE;
-    double height     SWIFT_PRIVATE;
+    std::string uri     SWIFT_PRIVATE;
     double width     SWIFT_PRIVATE;
+    double height     SWIFT_PRIVATE;
     double scale     SWIFT_PRIVATE;
-    std::string uri     SWIFT_PRIVATE;
+    std::optional<NitroColor> color     SWIFT_PRIVATE;
+    bool packager_asset     SWIFT_PRIVATE;
 
   public:
     AssetImage() = default;
-    explicit AssetImage(std::optional<NitroColor> color, bool packager_asset, double height, double width, double scale, std::string uri): color(color), packager_asset(packager_asset), height(height), width(width), scale(scale), uri(uri) {}
+    explicit AssetImage(std::string uri, double width, double height, double scale, std::optional<NitroColor> color, bool packager_asset): uri(uri), width(width), height(height), scale(scale), color(color), packager_asset(packager_asset) {}
 
   public:
     friend bool operator==(const AssetImage& lhs, const AssetImage& rhs) = default;
@@ -67,22 +67,22 @@ namespace margelo::nitro {
     static inline margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage(
-        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color"))),
-        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "packager_asset"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri"))),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "scale"))),
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri")))
+        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "packager_asset")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "color"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::toJSI(runtime, arg.color));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "packager_asset"), JSIConverter<bool>::toJSI(runtime, arg.packager_asset));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "uri"), JSIConverter<std::string>::toJSI(runtime, arg.uri));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, arg.width));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "scale"), JSIConverter<double>::toJSI(runtime, arg.scale));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "uri"), JSIConverter<std::string>::toJSI(runtime, arg.uri));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "color"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::toJSI(runtime, arg.color));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "packager_asset"), JSIConverter<bool>::toJSI(runtime, arg.packager_asset));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -93,12 +93,12 @@ namespace margelo::nitro {
       if (!nitro::isPlainObject(runtime, obj)) {
         return false;
       }
-      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))) return false;
-      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "packager_asset")))) return false;
-      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "scale")))) return false;
-      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "packager_asset")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/HybridAutoPlayTimingSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridAutoPlayTimingSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAutoPlayTimingSpec.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  void HybridAutoPlayTimingSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("createTimer", &HybridAutoPlayTimingSpec::createTimer);
+      prototype.registerHybridMethod("deleteTimer", &HybridAutoPlayTimingSpec::deleteTimer);
+    });
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/shared/c++/HybridAutoPlayTimingSpec.hpp

@@ -0,0 +1,63 @@
+///
+/// HybridAutoPlayTimingSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <functional>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AutoPlayTiming`
+   * Inherit this class to create instances of `HybridAutoPlayTimingSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAutoPlayTiming: public HybridAutoPlayTimingSpec {
+   * public:
+   *   HybridAutoPlayTiming(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAutoPlayTimingSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAutoPlayTimingSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAutoPlayTimingSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual double createTimer(const std::function<void()>& callback, double durationMs, bool repeats) = 0;
+      virtual void deleteTimer(double id) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AutoPlayTiming";
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",
@@ -14,6 +14,8 @@
     "lib",
     "lib-cjs",
     "jest.js",
+    "installTimers.ts",
+    "installTimers.web.ts",
     "nitrogen",
     "android/build.gradle",
     "android/gradle.properties",
@@ -65,13 +67,13 @@
     "@types/jest": "^29.5.12",
     "@types/react": "~19.2.0",
     "dpdm": "^4.0.1",
-    "nitrogen": "^0.35.9",
-    "typescript": "^5.8.3"
+    "nitrogen": "^0.37.1",
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "*"
+    "react-native-nitro-modules": ">=0.37.1"
   },
   "dependencies": {
     "react-native-uuid": "^2.0.3"

package/src/components/SafeAreaView.tsx

@@ -10,7 +10,7 @@ export const SafeAreaView = (props: ViewProps) => {
       style={[
         style,
         {
-          ...StyleSheet.absoluteFillObject,
+          ...StyleSheet.absoluteFill,
           paddingTop: safeAreaInsets.top,
           paddingBottom: safeAreaInsets.bottom,
           paddingRight: safeAreaInsets.right,

package/src/hybrid/HybridAutoPlayTiming.ts

@@ -0,0 +1,5 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { AutoPlayTiming } from '../specs/AutoPlayTiming.nitro';
+
+export const HybridAutoPlayTiming =
+  NitroModules.createHybridObject<AutoPlayTiming>('AutoPlayTiming');

package/src/hybrid/HybridVoice.ts

@@ -30,8 +30,8 @@ const startVoiceInput: StartVoiceInput = async (options?: VoiceInputOptions) =>
   const listeningImageRepeats =
     listeningImage?.type === 'asset' ? listeningImage.repeats : undefined;
 
-  const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound).uri : undefined;
-  const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound).uri : undefined;
+  const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound)?.uri : undefined;
+  const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound)?.uri : undefined;
 
   return await _native.startVoiceInput(
     silenceThresholdMs,

package/src/index.ts

@@ -1,14 +1,11 @@
 import { Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
-import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
 import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 
-AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
-
 export { HybridAndroidAutoTelemetry, HybridAndroidWindowInformation, HybridAutoPlay, HybridVoice };
 
 export const HybridAndroidAutomotive =

package/src/installTimers.ts

@@ -0,0 +1,9 @@
+// Side-effect-only entry point, re-exported at the package root as `installTimers` (see
+// ../installTimers.ts) for `import '@iternio/react-native-auto-play/installTimers';` as the
+// app's first import. installAutoPlayTimers() itself isn't part of the public API -- funneling
+// installation through this one module is what actually guarantees "runs before anything else
+// captures the original globals" (see the README) instead of just documenting it as a rule
+// callers have to get right.
+import { installAutoPlayTimers } from './utils/AutoPlayTimers';
+
+installAutoPlayTimers();

package/src/installTimers.web.ts

@@ -0,0 +1,2 @@
+// Web/Jest stub -- nothing to install there. See installTimers.ts.
+export {};

package/src/specs/AutoPlayTiming.nitro.ts

@@ -0,0 +1,25 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+/**
+ * Backs setTimeout/setInterval with a scheduler that never pauses -- unlike RN's own JS
+ * timers, which RN throttles or pauses whenever the app backgrounds, regardless of whether
+ * the process is actually still running.
+ *
+ * iOS: CarPlay keeps this app's process alive and driving the external screen even when the
+ * phone's own screen is off, but RN's own RCTTiming still pauses in that state regardless.
+ *
+ * Android: JavaTimerManager only keeps ticking while the host is resumed *or* a headless JS
+ * task is running -- previously satisfied by registering a permanent no-op headless task
+ * (see AutoPlayHeadlessJsTask), which this replaces.
+ *
+ * All due-time bookkeeping lives here natively (mirroring RCTTiming's/JavaTimerManager's own
+ * architecture) so JS only crosses the bridge when a timer actually fires, not on every tick.
+ */
+export interface AutoPlayTiming extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  /**
+   * Schedules `callback` to run after `durationMs`, repeating every `durationMs` if `repeats`
+   * is true. Returns an id to pass to `deleteTimer`.
+   */
+  createTimer(callback: () => void, durationMs: number, repeats: boolean): number;
+  deleteTimer(id: number): void;
+}

package/src/types/Telemetry.ts

@@ -1,4 +1,4 @@
-import type { Permission } from 'react-native/types';
+import type { Permission } from 'react-native';
 
 export type AndroidAutoPermissions =
   | Permission

package/src/utils/AutoPlayTimers.ts

@@ -0,0 +1,60 @@
+import { HybridAutoPlayTiming } from '../hybrid/HybridAutoPlayTiming';
+
+type TimerCallback = (...args: unknown[]) => void;
+
+let installed = false;
+
+/**
+ * Replaces the global `setTimeout`/`setInterval`/`clearTimeout`/`clearInterval` and
+ * `requestAnimationFrame`/`cancelAnimationFrame` with implementations backed by the native
+ * `AutoPlayTiming` module, so they keep running while the app is actively driving a car
+ * surface even though the phone itself is backgrounded or its screen is locked. React
+ * Native's own timers throttle or pause in that state regardless of whether the process is
+ * actually still alive, which would otherwise stall ETA updates and telemetry polling.
+ *
+ * `requestIdleCallback`/`cancelIdleCallback` are deliberately not covered: bridgeless RN
+ * backs those with a separate native module unrelated to `setTimeout`/`requestAnimationFrame`
+ * (and its own callback delivery path is an unimplemented stub on iOS), so there is nothing
+ * for this library to intercept there.
+ *
+ * All due-time bookkeeping happens natively -- this is a thin pass-through, so JS only
+ * crosses the bridge when a timer actually fires, not on some fixed interval.
+ *
+ * Call this **once**, as early as possible in your app -- ideally the first line of your
+ * entry file, before any other import -- so nothing else has already captured a reference to
+ * the original globals. Safe to call more than once; only the first call has any effect.
+ */
+export function installAutoPlayTimers(): void {
+  if (installed || HybridAutoPlayTiming == null) {
+    return;
+  }
+  installed = true;
+
+  const timing = HybridAutoPlayTiming;
+
+  const schedule =
+    (repeats: boolean) =>
+    (callback: TimerCallback, delay?: number, ...args: unknown[]): number =>
+      timing.createTimer(() => callback(...args), delay ?? 0, repeats);
+
+  const clear = (id: unknown): void => {
+    if (typeof id === 'number') {
+      timing.deleteTimer(id);
+    }
+  };
+
+  globalThis.setTimeout = schedule(false) as unknown as typeof setTimeout;
+  globalThis.setInterval = schedule(true) as unknown as typeof setInterval;
+  globalThis.clearTimeout = clear as unknown as typeof clearTimeout;
+  globalThis.clearInterval = clear as unknown as typeof clearInterval;
+
+  // Mirrors bridgeless RN's own implementation: requestAnimationFrame is setTimeout(0) with
+  // a performance.now() timestamp handed to the callback, and cancelAnimationFrame deletes
+  // the same underlying timer clearTimeout would.
+  const now = () =>
+    (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+  globalThis.requestAnimationFrame = ((callback: (timestamp: number) => void): number =>
+    timing.createTimer(() => callback(now()), 0, false)) as unknown as typeof requestAnimationFrame;
+  globalThis.cancelAnimationFrame = clear as unknown as typeof cancelAnimationFrame;
+}

package/src/utils/NitroImage.ts

@@ -1,4 +1,4 @@
-import { Image, type ImageResolvedAssetSource } from 'react-native';
+import { Image } from 'react-native';
 import type { AutoImage } from '../types/Image';
 import { type NitroColor, NitroColorUtil } from './NitroColor';
 
@@ -64,7 +64,11 @@ function resolveGlyph(image: Extract<AutoImage, { type: 'glyph' }>): number {
   throw new Error('Glyph image must provide either `name` or `codepoint`.');
 }
 
-interface AssetImage extends ImageResolvedAssetSource {
+interface AssetImage {
+  uri: string;
+  width: number;
+  height: number;
+  scale: number;
   color?: NitroColor;
   packager_asset: boolean;
 }
@@ -119,7 +123,13 @@ function convert(image?: AutoImage): NitroImage | undefined {
   // so the input allows all optional parameters which are returned as is even though
   // the return type claims to not have any optional parameters...
   // we specify some default values to not crash because of proper typing required by nitro-modules
-  const { height = 0, scale = 0, uri, width = 0, ...rest } = Image.resolveAssetSource(image.image);
+  const {
+    height = 0,
+    scale = 0,
+    uri = '',
+    width = 0,
+    ...rest
+  } = Image.resolveAssetSource(image.image) ?? {};
 
   const assetImage: AssetImage = {
     height,

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HeadlessTaskService.kt

@@ -1,36 +0,0 @@
-package com.margelo.nitro.swe.iternio.reactnativeautoplay
-
-import android.content.Intent
-import android.os.Binder
-import android.os.IBinder
-import com.facebook.react.HeadlessJsTaskService
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.jstasks.HeadlessJsTaskConfig
-
-class HeadlessTaskService : HeadlessJsTaskService() {
-    // we use a bound service so it will never be killed when Android Auto is active
-    inner class LocalBinder : Binder() {
-        fun getService() = this@HeadlessTaskService
-    }
-
-    private val mBinder = LocalBinder()
-
-    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig {
-        val data = intent?.extras?.let {
-            Arguments.fromBundle(it)
-        } ?: Arguments.createMap()
-
-        return HeadlessJsTaskConfig(
-            taskKey = "AndroidAutoHeadlessJsTask", data = data, isAllowedInForeground = true
-        )
-    }
-
-    override fun onBind(intent: Intent): IBinder? {
-        // Start the headless task when bound
-        UiThreadUtil.runOnUiThread {
-            startTask(getTaskConfig(intent))
-        }
-        return mBinder
-    }
-}

package/lib/AutoPlayHeadlessJsTask.d.ts

@@ -1,5 +0,0 @@
-import type { AutoPlay as NitroAutoPlay } from './specs/AutoPlay.nitro';
-declare const _default: {
-    registerHeadlessTask: (hybridAutoPlay: NitroAutoPlay) => void;
-};
-export default _default;

package/lib/AutoPlayHeadlessJsTask.js

@@ -1,14 +0,0 @@
-import { AppRegistry, Platform } from 'react-native';
-const createTaskProvider = (hybridAutoPlay) => () => () => new Promise((resolve) => {
-    const remove = hybridAutoPlay.addListener('didDisconnect', () => {
-        resolve();
-        remove();
-    });
-});
-const registerHeadlessTask = (hybridAutoPlay) => {
-    if (Platform.OS !== 'android') {
-        return;
-    }
-    AppRegistry.registerHeadlessTask('AndroidAutoHeadlessJsTask', createTaskProvider(hybridAutoPlay));
-};
-export default { registerHeadlessTask };

package/lib-cjs/AutoPlayHeadlessJsTask.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_native_1 = require("react-native");
-const createTaskProvider = (hybridAutoPlay) => () => () => new Promise((resolve) => {
-    const remove = hybridAutoPlay.addListener('didDisconnect', () => {
-        resolve();
-        remove();
-    });
-});
-const registerHeadlessTask = (hybridAutoPlay) => {
-    if (react_native_1.Platform.OS !== 'android') {
-        return;
-    }
-    react_native_1.AppRegistry.registerHeadlessTask('AndroidAutoHeadlessJsTask', createTaskProvider(hybridAutoPlay));
-};
-exports.default = { registerHeadlessTask };

package/src/AutoPlayHeadlessJsTask.ts

@@ -1,22 +0,0 @@
-import { AppRegistry, Platform, type Task, type TaskProvider } from 'react-native';
-import type { AutoPlay as NitroAutoPlay } from './specs/AutoPlay.nitro';
-
-const createTaskProvider =
-  (hybridAutoPlay: NitroAutoPlay): TaskProvider =>
-  (): Task =>
-  () =>
-    new Promise((resolve) => {
-      const remove = hybridAutoPlay.addListener('didDisconnect', () => {
-        resolve();
-        remove();
-      });
-    });
-
-const registerHeadlessTask = (hybridAutoPlay: NitroAutoPlay) => {
-  if (Platform.OS !== 'android') {
-    return;
-  }
-  AppRegistry.registerHeadlessTask('AndroidAutoHeadlessJsTask', createTaskProvider(hybridAutoPlay));
-};
-
-export default { registerHeadlessTask };