@neoskola/auto-play 0.2.18 → 0.3.1

package/ios/hybrid/HybridNowPlayingTemplate.swift

@@ -58,4 +58,94 @@ class HybridNowPlayingTemplate: HybridNowPlayingTemplateSpec {
             await template.updateElapsedTime(elapsedTime: elapsedTime, duration: duration)
         }
     }
+
+    // MARK: - Native Audio Playback
+
+    func playAudio(
+        templateId: String,
+        url: String,
+        startFrom: Double
+    ) throws -> Promise<Bool> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            return await template.playAudio(url: url, startFrom: startFrom)
+        }
+    }
+
+    func pauseAudio(templateId: String) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.pauseAudio()
+        }
+    }
+
+    func resumeAudio(templateId: String) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.resumeAudio()
+        }
+    }
+
+    func seekForward(
+        templateId: String,
+        seconds: Double
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.seekForward(seconds: seconds)
+        }
+    }
+
+    func seekBackward(
+        templateId: String,
+        seconds: Double
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.seekBackward(seconds: seconds)
+        }
+    }
+
+    func stopAudio(templateId: String) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.stopAudio()
+        }
+    }
 }

package/ios/templates/NowPlayingTemplate.swift

@@ -1,5 +1,6 @@
 import CarPlay
 import MediaPlayer
+import AVFoundation
 
 class NowPlayingTemplate: AutoPlayTemplate {
     var template: CPNowPlayingTemplate
@@ -9,6 +10,16 @@ class NowPlayingTemplate: AutoPlayTemplate {
     private var currentElapsedTime: Double = 0
     private var currentDuration: Double = 0
 
+    // Native audio player
+    private var player: AVPlayer?
+    private var playerItem: AVPlayerItem?
+    private var timeObserver: Any?
+    private var progressReportTimer: Timer?
+    private var lastReportedSecond: Int = 0
+    private var didFinishObserver: NSObjectProtocol?
+    private var statusObservation: NSKeyValueObservation?
+    private var completionFired = false
+
     var autoDismissMs: Double? {
         return config.autoDismissMs
     }
@@ -42,12 +53,213 @@ class NowPlayingTemplate: AutoPlayTemplate {
         }
     }
 
+    // MARK: - Native Audio Playback
+
+    @MainActor
+    func playAudio(url: String, startFrom: Double) -> Bool {
+        // Clean up any existing player
+        cleanupPlayer()
+        completionFired = false
+        lastReportedSecond = Int(startFrom)
+
+        guard let audioURL = URL(string: url) else {
+            print("[NowPlayingTemplate] Invalid audio URL: \(url)")
+            return false
+        }
+
+        // Ensure AVAudioSession is active
+        NowPlayingSessionManager.shared.ensureSessionActive()
+
+        let asset = AVURLAsset(url: audioURL)
+        playerItem = AVPlayerItem(asset: asset)
+
+        // KVO: detect duration as soon as asset loads (critical for progress bar)
+        statusObservation = playerItem?.observe(\.status, options: [.new]) { [weak self] item, _ in
+            guard item.status == .readyToPlay else {
+                if item.status == .failed {
+                    print("[NowPlayingTemplate] AVPlayerItem failed: \(item.error?.localizedDescription ?? "unknown")")
+                }
+                return
+            }
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                let duration = CMTimeGetSeconds(item.duration)
+                if !duration.isNaN && !duration.isInfinite && duration > 0 {
+                    self.currentDuration = duration
+                    self.updateNowPlayingInfo()
+                    print("[NowPlayingTemplate] Duration resolved via KVO: \(duration)s")
+                }
+            }
+        }
+
+        player = AVPlayer(playerItem: playerItem)
+
+        // Seek to start position
+        if startFrom > 0 {
+            let time = CMTime(seconds: startFrom, preferredTimescale: 600)
+            player?.seek(to: time)
+        }
+
+        // Periodic time observer (every 1 second) for MPNowPlayingInfoCenter updates
+        let interval = CMTime(seconds: 1.0, preferredTimescale: 600)
+        timeObserver = player?.addPeriodicTimeObserver(
+            forInterval: interval,
+            queue: .main
+        ) { [weak self] time in
+            self?.handleTimeUpdate(time: time)
+        }
+
+        // Playback finished notification
+        didFinishObserver = NotificationCenter.default.addObserver(
+            forName: .AVPlayerItemDidPlayToEndTime,
+            object: playerItem,
+            queue: .main
+        ) { [weak self] _ in
+            self?.handlePlaybackFinished()
+        }
+
+        // Progress report timer (every 30 seconds) — calls JS callback for backend reporting
+        progressReportTimer = Timer.scheduledTimer(
+            withTimeInterval: 30.0,
+            repeats: true
+        ) { [weak self] _ in
+            self?.reportProgress()
+        }
+
+        // Play
+        player?.play()
+
+        // Update NowPlaying UI
+        config.isPlaying = true
+        updateNowPlayingInfo()
+        MPNowPlayingInfoCenter.default().playbackState = .playing
+
+        print("[NowPlayingTemplate] Native audio playback started: \(url)")
+        return true
+    }
+
+    private func handleTimeUpdate(time: CMTime) {
+        let currentTime = CMTimeGetSeconds(time)
+        let duration = CMTimeGetSeconds(playerItem?.duration ?? .zero)
+
+        guard !currentTime.isNaN else { return }
+
+        currentElapsedTime = currentTime
+        if !duration.isNaN && !duration.isInfinite && duration > 0 {
+            currentDuration = duration
+        }
+
+        // Use existing info or create fresh if nil (race condition safety)
+        var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [String: Any]()
+
+        // Ensure title/artist are present if this is a fresh dictionary
+        if nowPlayingInfo[MPMediaItemPropertyTitle] == nil {
+            let titleText = Parser.parseText(text: config.title) ?? ""
+            nowPlayingInfo[MPMediaItemPropertyTitle] = titleText
+            if let subtitle = config.subtitle {
+                nowPlayingInfo[MPMediaItemPropertyArtist] = Parser.parseText(text: subtitle)
+            }
+        }
+
+        if currentDuration > 0 {
+            nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = currentDuration
+        }
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentElapsedTime
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = config.isPlaying ? 1.0 : 0.0
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+
+        // 95% completion check
+        if !completionFired && currentDuration > 0 && currentTime / currentDuration >= 0.95 {
+            completionFired = true
+            config.onComplete?()
+        }
+    }
+
+    private func reportProgress() {
+        let currentSecond = Int(currentElapsedTime)
+        guard currentSecond != lastReportedSecond && currentSecond > 0 else { return }
+        lastReportedSecond = currentSecond
+        config.onProgressUpdate?(currentElapsedTime, currentDuration)
+    }
+
+    private func handlePlaybackFinished() {
+        config.isPlaying = false
+        MPNowPlayingInfoCenter.default().playbackState = .stopped
+        // Fire completion if not already fired
+        if !completionFired {
+            completionFired = true
+            config.onComplete?()
+        }
+        config.onPlaybackFinished?()
+    }
+
+    @MainActor
+    func pauseAudio() {
+        player?.pause()
+        config.isPlaying = false
+        updatePlaybackState(isPlaying: false)
+        reportProgress()
+    }
+
+    @MainActor
+    func resumeAudio() {
+        NowPlayingSessionManager.shared.ensureSessionActive()
+        player?.play()
+        config.isPlaying = true
+        updatePlaybackState(isPlaying: true)
+    }
+
+    @MainActor
+    func seekForward(seconds: Double) {
+        guard let player = player else { return }
+        let newTime = CMTimeGetSeconds(player.currentTime()) + seconds
+        let clampedTime = min(newTime, currentDuration)
+        player.seek(to: CMTime(seconds: clampedTime, preferredTimescale: 600))
+    }
+
+    @MainActor
+    func seekBackward(seconds: Double) {
+        guard let player = player else { return }
+        let newTime = CMTimeGetSeconds(player.currentTime()) - seconds
+        let clampedTime = max(newTime, 0)
+        player.seek(to: CMTime(seconds: clampedTime, preferredTimescale: 600))
+    }
+
+    @MainActor
+    func stopAudio() {
+        reportProgress()
+        cleanupPlayer()
+        config.isPlaying = false
+        MPNowPlayingInfoCenter.default().playbackState = .stopped
+    }
+
+    private func cleanupPlayer() {
+        statusObservation?.invalidate()
+        statusObservation = nil
+        if let timeObserver = timeObserver {
+            player?.removeTimeObserver(timeObserver)
+            self.timeObserver = nil
+        }
+        if let didFinishObserver = didFinishObserver {
+            NotificationCenter.default.removeObserver(didFinishObserver)
+            self.didFinishObserver = nil
+        }
+        progressReportTimer?.invalidate()
+        progressReportTimer = nil
+        player?.pause()
+        player = nil
+        playerItem = nil
+    }
+
+    // MARK: - CarPlay UI
+
     private func setupNowPlayingButtons() {
         var buttons: [CPNowPlayingButton] = []
 
         let skipBackButton = CPNowPlayingImageButton(
             image: UIImage(systemName: "gobackward.30")!
         ) { [weak self] _ in
+            self?.seekBackward(seconds: 30)
             self?.config.onSkipBackward?()
         }
         buttons.append(skipBackButton)
@@ -55,6 +267,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
         let skipForwardButton = CPNowPlayingImageButton(
             image: UIImage(systemName: "goforward.30")!
         ) { [weak self] _ in
+            self?.seekForward(seconds: 30)
             self?.config.onSkipForward?()
         }
         buttons.append(skipForwardButton)
@@ -97,6 +310,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
         commandCenter.playCommand.isEnabled = true
         commandCenter.playCommand.removeTarget(nil)
         commandCenter.playCommand.addTarget { [weak self] _ in
+            self?.resumeAudio()
             self?.config.onPlay?()
             return .success
         }
@@ -104,6 +318,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
         commandCenter.pauseCommand.isEnabled = true
         commandCenter.pauseCommand.removeTarget(nil)
         commandCenter.pauseCommand.addTarget { [weak self] _ in
+            self?.pauseAudio()
             self?.config.onPause?()
             return .success
         }
@@ -112,6 +327,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
         commandCenter.skipForwardCommand.preferredIntervals = [30]
         commandCenter.skipForwardCommand.removeTarget(nil)
         commandCenter.skipForwardCommand.addTarget { [weak self] _ in
+            self?.seekForward(seconds: 30)
             self?.config.onSkipForward?()
             return .success
         }
@@ -120,6 +336,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
         commandCenter.skipBackwardCommand.preferredIntervals = [30]
         commandCenter.skipBackwardCommand.removeTarget(nil)
         commandCenter.skipBackwardCommand.addTarget { [weak self] _ in
+            self?.seekBackward(seconds: 30)
             self?.config.onSkipBackward?()
             return .success
         }
@@ -131,6 +348,8 @@ class NowPlayingTemplate: AutoPlayTemplate {
                   let positionEvent = event as? MPChangePlaybackPositionCommandEvent else {
                 return .commandFailed
             }
+            let time = CMTime(seconds: positionEvent.positionTime, preferredTimescale: 600)
+            self.player?.seek(to: time)
             self.currentElapsedTime = positionEvent.positionTime
             self.updateNowPlayingInfo()
             return .success
@@ -153,6 +372,9 @@ class NowPlayingTemplate: AutoPlayTemplate {
         }
     }
 
+    // MARK: - AutoPlayTemplate Protocol
+
+    @MainActor
     func invalidate() {
         setupNowPlayingButtons()
         updateNowPlayingInfo()
@@ -180,6 +402,8 @@ class NowPlayingTemplate: AutoPlayTemplate {
 
     func onPopped() {
         config.onPopped?()
+        cleanupPlayer()
+
         let commandCenter = MPRemoteCommandCenter.shared()
         commandCenter.playCommand.removeTarget(nil)
         commandCenter.pauseCommand.removeTarget(nil)
@@ -207,13 +431,21 @@ class NowPlayingTemplate: AutoPlayTemplate {
             isSetupComplete = true
         }
 
-        // Update playback rate in existing nowPlayingInfo
-        if var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo {
-            nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPlaying ? 1.0 : 0.0
-            nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentElapsedTime
-            MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+        // Update playback rate — use existing info or create fresh if nil
+        var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [String: Any]()
+
+        if nowPlayingInfo[MPMediaItemPropertyTitle] == nil {
+            let titleText = Parser.parseText(text: config.title) ?? ""
+            nowPlayingInfo[MPMediaItemPropertyTitle] = titleText
+            if let subtitle = config.subtitle {
+                nowPlayingInfo[MPMediaItemPropertyArtist] = Parser.parseText(text: subtitle)
+            }
         }
 
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPlaying ? 1.0 : 0.0
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentElapsedTime
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+
         MPNowPlayingInfoCenter.default().playbackState = isPlaying ? .playing : .paused
     }
 
@@ -229,12 +461,20 @@ class NowPlayingTemplate: AutoPlayTemplate {
         self.currentElapsedTime = elapsedTime
         self.currentDuration = duration
 
-        // Update only time-related fields without rebuilding everything
-        if var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo {
-            nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration
-            nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsedTime
-            nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = config.isPlaying ? 1.0 : 0.0
-            MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+        // Update time-related fields — use existing info or create fresh if nil
+        var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [String: Any]()
+
+        if nowPlayingInfo[MPMediaItemPropertyTitle] == nil {
+            let titleText = Parser.parseText(text: config.title) ?? ""
+            nowPlayingInfo[MPMediaItemPropertyTitle] = titleText
+            if let subtitle = config.subtitle {
+                nowPlayingInfo[MPMediaItemPropertyArtist] = Parser.parseText(text: subtitle)
+            }
         }
+
+        nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsedTime
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = config.isPlaying ? 1.0 : 0.0
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
     }
 }

package/lib/specs/NowPlayingTemplate.nitro.d.ts

@@ -11,5 +11,11 @@ export interface NowPlayingTemplate extends HybridObject<{
     updateNowPlayingTemplatePlaybackState(templateId: string, isPlaying: boolean): Promise<void>;
     updateNowPlayingTemplateInfo(templateId: string, title: string, subtitle: string): Promise<void>;
     updateNowPlayingTemplateElapsedTime(templateId: string, elapsedTime: number, duration: number): Promise<void>;
+    playAudio(templateId: string, url: string, startFrom: number): Promise<boolean>;
+    pauseAudio(templateId: string): Promise<void>;
+    resumeAudio(templateId: string): Promise<void>;
+    seekForward(templateId: string, seconds: number): Promise<void>;
+    seekBackward(templateId: string, seconds: number): Promise<void>;
+    stopAudio(templateId: string): Promise<void>;
 }
 export {};

package/lib/templates/NowPlayingTemplate.d.ts

@@ -14,6 +14,8 @@ export interface NitroNowPlayingTemplateConfig extends TemplateConfig {
     onSkipForward?: () => void;
     onSkipBackward?: () => void;
     onComplete?: () => void;
+    onProgressUpdate?: (currentTime: number, duration: number) => void;
+    onPlaybackFinished?: () => void;
 }
 export type NowPlayingTemplateConfig = Omit<NitroNowPlayingTemplateConfig, 'image'> & {
     image?: AutoImage;
@@ -23,4 +25,10 @@ export declare class NowPlayingTemplate extends Template<NowPlayingTemplateConfi
     updatePlaybackState(isPlaying: boolean): Promise<void>;
     updateNowPlayingInfo(title: string, subtitle: string): Promise<void>;
     updateElapsedTime(elapsedTime: number, duration: number): Promise<void>;
+    playAudio(url: string, startFrom?: number): Promise<boolean>;
+    pauseAudio(): Promise<void>;
+    resumeAudio(): Promise<void>;
+    seekForward(seconds?: number): Promise<void>;
+    seekBackward(seconds?: number): Promise<void>;
+    stopAudio(): Promise<void>;
 }

package/lib/templates/NowPlayingTemplate.js

@@ -22,4 +22,22 @@ export class NowPlayingTemplate extends Template {
     updateElapsedTime(elapsedTime, duration) {
         return HybridNowPlayingTemplate.updateNowPlayingTemplateElapsedTime(this.id, elapsedTime, duration);
     }
+    playAudio(url, startFrom = 0) {
+        return HybridNowPlayingTemplate.playAudio(this.id, url, startFrom);
+    }
+    pauseAudio() {
+        return HybridNowPlayingTemplate.pauseAudio(this.id);
+    }
+    resumeAudio() {
+        return HybridNowPlayingTemplate.resumeAudio(this.id);
+    }
+    seekForward(seconds = 30) {
+        return HybridNowPlayingTemplate.seekForward(this.id, seconds);
+    }
+    seekBackward(seconds = 30) {
+        return HybridNowPlayingTemplate.seekBackward(this.id, seconds);
+    }
+    stopAudio() {
+        return HybridNowPlayingTemplate.stopAudio(this.id);
+    }
 }

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -45,6 +45,7 @@
 #include "JHybridMessageTemplateSpec.hpp"
 #include "JHybridNeoSkolaTemplateSpec.hpp"
 #include "JHybridNowPlayingTemplateSpec.hpp"
+#include "JFunc_void_double_double.hpp"
 #include "JHybridSearchTemplateSpec.hpp"
 #include "JHybridSectionListTemplateSpec.hpp"
 #include "JHybridSubscriptionGateTemplateSpec.hpp"
@@ -89,6 +90,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridMessageTemplateSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridNeoSkolaTemplateSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridNowPlayingTemplateSpec::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_double_double_cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSearchTemplateSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSectionListTemplateSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSubscriptionGateTemplateSpec::registerNatives();

package/nitrogen/generated/android/c++/JFunc_void_double_double.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(currentTime: Double, duration: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double: public jni::JavaClass<JFunc_void_double_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_double_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double` instance holds through JNI.
+     */
+    void invoke(double currentTime, double duration) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* currentTime */, double /* duration */)>("invoke");
+      method(self(), currentTime, duration);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_cxx final: public jni::HybridClass<JFunc_void_double_double_cxx, JFunc_void_double_double> {
+  public:
+    static jni::local_ref<JFunc_void_double_double::javaobject> fromCpp(const std::function<void(double /* currentTime */, double /* duration */)>& func) {
+      return JFunc_void_double_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_cxx` instance holds.
+     */
+    void invoke_cxx(double currentTime, double duration) {
+      _func(currentTime, duration);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* currentTime */, double /* duration */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_double_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_cxx(const std::function<void(double /* currentTime */, double /* duration */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* currentTime */, double /* duration */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay