@neoskola/auto-play 0.2.18 → 0.3.0

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,15 @@ 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 completionFired = false
+
     var autoDismissMs: Double? {
         return config.autoDismissMs
     }
@@ -42,12 +52,182 @@ 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)
+        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 > 0 {
+            currentDuration = duration
+        }
+
+        // Update MPNowPlayingInfoCenter — no JS roundtrip needed
+        if var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo {
+            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() {
+        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 +235,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 +278,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 +286,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 +295,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 +304,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 +316,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 +340,8 @@ class NowPlayingTemplate: AutoPlayTemplate {
         }
     }
 
+    // MARK: - AutoPlayTemplate Protocol
+
     func invalidate() {
         setupNowPlayingButtons()
         updateNowPlayingInfo()
@@ -180,6 +369,8 @@ class NowPlayingTemplate: AutoPlayTemplate {
 
     func onPopped() {
         config.onPopped?()
+        cleanupPlayer()
+
         let commandCenter = MPRemoteCommandCenter.shared()
         commandCenter.playCommand.removeTarget(nil)
         commandCenter.pauseCommand.removeTarget(nil)

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

package/nitrogen/generated/android/c++/JHybridNowPlayingTemplateSpec.cpp

@@ -46,6 +46,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor;
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JFunc_void_double_double.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -128,5 +129,96 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<bool>> JHybridNowPlayingTemplateSpec::playAudio(const std::string& templateId, const std::string& url, double startFrom) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<jni::JString> /* url */, double /* startFrom */)>("playAudio");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), jni::make_jstring(url), startFrom);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::pauseAudio(const std::string& templateId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("pauseAudio");
+    auto __result = method(_javaPart, jni::make_jstring(templateId));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::resumeAudio(const std::string& templateId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("resumeAudio");
+    auto __result = method(_javaPart, jni::make_jstring(templateId));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::seekForward(const std::string& templateId, double seconds) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, double /* seconds */)>("seekForward");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), seconds);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::seekBackward(const std::string& templateId, double seconds) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, double /* seconds */)>("seekBackward");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), seconds);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::stopAudio(const std::string& templateId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("stopAudio");
+    auto __result = method(_javaPart, jni::make_jstring(templateId));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -58,6 +58,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::shared_ptr<Promise<void>> updateNowPlayingTemplatePlaybackState(const std::string& templateId, bool isPlaying) override;
     std::shared_ptr<Promise<void>> updateNowPlayingTemplateInfo(const std::string& templateId, const std::string& title, const std::string& subtitle) override;
     std::shared_ptr<Promise<void>> updateNowPlayingTemplateElapsedTime(const std::string& templateId, double elapsedTime, double duration) override;
+    std::shared_ptr<Promise<bool>> playAudio(const std::string& templateId, const std::string& url, double startFrom) override;
+    std::shared_ptr<Promise<void>> pauseAudio(const std::string& templateId) override;
+    std::shared_ptr<Promise<void>> resumeAudio(const std::string& templateId) override;
+    std::shared_ptr<Promise<void>> seekForward(const std::string& templateId, double seconds) override;
+    std::shared_ptr<Promise<void>> seekBackward(const std::string& templateId, double seconds) override;
+    std::shared_ptr<Promise<void>> stopAudio(const std::string& templateId) override;
 
   private:
     friend HybridBase;