@neoskola/auto-play 0.2.9 → 0.2.11

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

@@ -33,4 +33,14 @@ class HybridNowPlayingTemplate : HybridNowPlayingTemplateSpec() {
             template.updateInfo(title, subtitle)
         }
     }
+
+    override fun updateNowPlayingTemplateElapsedTime(
+        templateId: String,
+        elapsedTime: Double,
+        duration: Double
+    ): Promise<Unit> {
+        return Promise.async {
+            // Android Auto manages its own playback UI
+        }
+    }
 }

package/ios/hybrid/HybridNowPlayingTemplate.swift

@@ -41,4 +41,21 @@ class HybridNowPlayingTemplate: HybridNowPlayingTemplateSpec {
             await template.updateInfo(title: title, subtitle: subtitle)
         }
     }
+
+    func updateNowPlayingTemplateElapsedTime(
+        templateId: String,
+        elapsedTime: Double,
+        duration: Double
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? NowPlayingTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.updateElapsedTime(elapsedTime: elapsedTime, duration: duration)
+        }
+    }
 }

package/ios/scenes/AutoPlayInterfaceController.swift

@@ -51,14 +51,17 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
         _ templateToPush: CPTemplate,
         animated: Bool
     ) async throws -> Bool {
-        // CPNowPlayingTemplate.shared must NEVER be pushed via pushTemplate().
-        // Apple's CarPlay framework throws an uncatchable NSException (Objective-C)
-        // when attempting to push this singleton. The Now Playing UI appears
-        // automatically when MPNowPlayingInfoCenter is configured and playbackState
-        // is set to .playing.
+        // CPNowPlayingTemplate.shared can throw an ObjC NSException when pushed.
+        // Swift try/catch cannot catch NSExceptions, so we use an ObjC wrapper.
         if templateToPush is CPNowPlayingTemplate {
-            print("[AutoPlay] CPNowPlayingTemplate cannot be pushed — skipping. Configure MPNowPlayingInfoCenter instead.")
-            return true
+            // Skip if already in the stack
+            let alreadyInStack = interfaceController.templates.contains(where: { $0 is CPNowPlayingTemplate })
+            if alreadyInStack {
+                print("[AutoPlay] CPNowPlayingTemplate already in stack, skipping push")
+                return true
+            }
+
+            return await pushNowPlayingTemplateSafely(animated: animated)
         }
 
         return try await interfaceController.pushTemplate(
@@ -67,6 +70,29 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
         )
     }
 
+    /// Pushes CPNowPlayingTemplate using ObjC @try/@catch to prevent crash from NSException.
+    private func pushNowPlayingTemplateSafely(animated: Bool) async -> Bool {
+        return await withCheckedContinuation { continuation in
+            var pushError: NSError?
+            let success = ObjCExceptionCatcher.tryBlock({
+                self.interfaceController.pushTemplate(
+                    CPNowPlayingTemplate.shared,
+                    animated: animated
+                ) { success, error in
+                    if let error = error {
+                        print("[AutoPlay] CPNowPlayingTemplate push completion error: \(error)")
+                    }
+                    continuation.resume(returning: success)
+                }
+            }, error: &pushError)
+
+            if !success {
+                print("[AutoPlay] CPNowPlayingTemplate push threw ObjC exception: \(pushError?.localizedDescription ?? "unknown")")
+                continuation.resume(returning: false)
+            }
+        }
+    }
+
     func setRootTemplate(
         _ rootTemplate: CPTemplate,
         animated: Bool

package/ios/templates/NowPlayingTemplate.swift

@@ -5,6 +5,9 @@ class NowPlayingTemplate: AutoPlayTemplate {
     var template: CPNowPlayingTemplate
     var config: NowPlayingTemplateConfig
     private var loadedImage: UIImage?
+    private var isSetupComplete = false
+    private var currentElapsedTime: Double = 0
+    private var currentDuration: Double = 0
 
     var autoDismissMs: Double? {
         return config.autoDismissMs
@@ -22,12 +25,17 @@ class NowPlayingTemplate: AutoPlayTemplate {
 
         // Constructor runs on the JS thread. Dispatch all CarPlay UI setup to main thread.
         // CPNowPlayingTemplate.shared is Apple's singleton — must be modified on main thread.
-        // This also ensures MPNowPlayingInfoCenter and MPRemoteCommandCenter are configured
-        // even if push() is never called (CarPlay shows "Now Playing" bar automatically).
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
+
+            // Activate AVAudioSession FIRST — iOS needs this to recognize the app
+            // as a media player before MPNowPlayingInfoCenter metadata is meaningful.
+            NowPlayingSessionManager.shared.ensureSessionActive()
+
             self.setupNowPlayingButtons()
             self.updateNowPlayingInfo()
+            self.isSetupComplete = true
+
             if let image = config.image {
                 self.loadImageAsync(image: image)
             }
@@ -71,6 +79,13 @@ class NowPlayingTemplate: AutoPlayTemplate {
             nowPlayingInfo[MPMediaItemPropertyArtwork] = artwork
         }
 
+        // Include duration and elapsed time for the progress bar
+        if currentDuration > 0 {
+            nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = currentDuration
+            nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentElapsedTime
+            nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = config.isPlaying ? 1.0 : 0.0
+        }
+
         MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
 
         setupRemoteCommandCenter()
@@ -108,6 +123,18 @@ class NowPlayingTemplate: AutoPlayTemplate {
             self?.config.onSkipBackward?()
             return .success
         }
+
+        commandCenter.changePlaybackPositionCommand.isEnabled = true
+        commandCenter.changePlaybackPositionCommand.removeTarget(nil)
+        commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
+            guard let self = self,
+                  let positionEvent = event as? MPChangePlaybackPositionCommandEvent else {
+                return .commandFailed
+            }
+            self.currentElapsedTime = positionEvent.positionTime
+            self.updateNowPlayingInfo()
+            return .success
+        }
     }
 
     private func loadImageAsync(image: Variant_GlyphImage_AssetImage) {
@@ -158,11 +185,35 @@ class NowPlayingTemplate: AutoPlayTemplate {
         commandCenter.pauseCommand.removeTarget(nil)
         commandCenter.skipForwardCommand.removeTarget(nil)
         commandCenter.skipBackwardCommand.removeTarget(nil)
+        commandCenter.changePlaybackPositionCommand.removeTarget(nil)
+
+        // Clear now playing info so CarPlay hides the Now Playing bar
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
+        MPNowPlayingInfoCenter.default().playbackState = .stopped
     }
 
     @MainActor
     func updatePlaybackState(isPlaying: Bool) {
         config.isPlaying = isPlaying
+
+        // Ensure AVAudioSession is active — required for CarPlay Now Playing bar
+        NowPlayingSessionManager.shared.ensureSessionActive()
+
+        // If constructor's DispatchQueue.main.async hasn't run yet,
+        // nowPlayingInfo could be nil. Set it up now to fix the race condition.
+        if !isSetupComplete {
+            setupNowPlayingButtons()
+            updateNowPlayingInfo()
+            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
+        }
+
         MPNowPlayingInfoCenter.default().playbackState = isPlaying ? .playing : .paused
     }
 
@@ -172,4 +223,18 @@ class NowPlayingTemplate: AutoPlayTemplate {
         config.subtitle = AutoText(text: subtitle, distance: nil, duration: nil)
         updateNowPlayingInfo()
     }
+
+    @MainActor
+    func updateElapsedTime(elapsedTime: Double, duration: Double) {
+        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
+        }
+    }
 }

package/ios/utils/NowPlayingSessionManager.swift

@@ -0,0 +1,49 @@
+import AVFoundation
+
+/// Manages AVAudioSession activation for CarPlay Now Playing integration.
+/// iOS requires an explicit AVAudioSession.setCategory(.playback) + setActive(true)
+/// for MPNowPlayingInfoCenter to be recognized by the system and the Now Playing
+/// bar to appear in CarPlay.
+class NowPlayingSessionManager {
+    static let shared = NowPlayingSessionManager()
+
+    private var isSessionActivated = false
+
+    private init() {}
+
+    /// Ensures AVAudioSession is configured for playback and activated.
+    /// Safe to call multiple times — only activates once.
+    func ensureSessionActive() {
+        guard !isSessionActivated else { return }
+
+        let session = AVAudioSession.sharedInstance()
+
+        do {
+            try session.setCategory(
+                .playback,
+                mode: .default,
+                options: []
+            )
+            try session.setActive(true)
+            isSessionActivated = true
+            print("[NowPlayingSessionManager] AVAudioSession activated with .playback category")
+        } catch {
+            print("[NowPlayingSessionManager] Failed to activate AVAudioSession: \(error)")
+        }
+    }
+
+    /// Deactivates the audio session.
+    func deactivateSession() {
+        guard isSessionActivated else { return }
+
+        let session = AVAudioSession.sharedInstance()
+
+        do {
+            try session.setActive(false, options: .notifyOthersOnDeactivation)
+            isSessionActivated = false
+            print("[NowPlayingSessionManager] AVAudioSession deactivated")
+        } catch {
+            print("[NowPlayingSessionManager] Failed to deactivate AVAudioSession: \(error)")
+        }
+    }
+}

package/ios/utils/ObjCExceptionCatcher.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+
+/// Provides Objective-C @try/@catch exception handling for Swift code.
+/// Swift's try/catch cannot catch Objective-C NSExceptions, which causes
+/// crashes when Apple frameworks throw them (e.g., CPInterfaceController.pushTemplate
+/// with CPNowPlayingTemplate). This wrapper makes those exceptions catchable.
+@interface ObjCExceptionCatcher : NSObject
+
++ (BOOL)tryBlock:(void(NS_NOESCAPE ^_Nonnull)(void))tryBlock
+           error:(NSError * _Nullable * _Nullable)error;
+
+@end

package/ios/utils/ObjCExceptionCatcher.m

@@ -0,0 +1,23 @@
+#import "ObjCExceptionCatcher.h"
+
+@implementation ObjCExceptionCatcher
+
++ (BOOL)tryBlock:(void(NS_NOESCAPE ^)(void))tryBlock error:(NSError **)error {
+    @try {
+        tryBlock();
+        return YES;
+    } @catch (NSException *exception) {
+        NSLog(@"[ObjCExceptionCatcher] Caught exception: %@ — %@", exception.name, exception.reason);
+        if (error) {
+            *error = [NSError errorWithDomain:@"ObjCExceptionCatcher"
+                                         code:0
+                                     userInfo:@{
+                NSLocalizedDescriptionKey: exception.reason ?: @"Unknown Objective-C exception",
+                @"ExceptionName": exception.name ?: @"Unknown"
+            }];
+        }
+        return NO;
+    }
+}
+
+@end

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

@@ -10,5 +10,6 @@ export interface NowPlayingTemplate extends HybridObject<{
     createNowPlayingTemplate(config: NowPlayingTemplateConfig): void;
     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>;
 }
 export {};

package/lib/templates/NowPlayingTemplate.d.ts

@@ -22,4 +22,5 @@ export declare class NowPlayingTemplate extends Template<NowPlayingTemplateConfi
     constructor(config: NowPlayingTemplateConfig);
     updatePlaybackState(isPlaying: boolean): Promise<void>;
     updateNowPlayingInfo(title: string, subtitle: string): Promise<void>;
+    updateElapsedTime(elapsedTime: number, duration: number): Promise<void>;
 }

package/lib/templates/NowPlayingTemplate.js

@@ -19,4 +19,7 @@ export class NowPlayingTemplate extends Template {
     updateNowPlayingInfo(title, subtitle) {
         return HybridNowPlayingTemplate.updateNowPlayingTemplateInfo(this.id, title, subtitle);
     }
+    updateElapsedTime(elapsedTime, duration) {
+        return HybridNowPlayingTemplate.updateNowPlayingTemplateElapsedTime(this.id, elapsedTime, duration);
+    }
 }

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

@@ -113,5 +113,20 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<void>> JHybridNowPlayingTemplateSpec::updateNowPlayingTemplateElapsedTime(const std::string& templateId, double elapsedTime, double duration) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, double /* elapsedTime */, double /* duration */)>("updateNowPlayingTemplateElapsedTime");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), elapsedTime, duration);
+    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

@@ -57,6 +57,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     void createNowPlayingTemplate(const NowPlayingTemplateConfig& config) override;
     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;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridNowPlayingTemplateSpec.kt

@@ -57,6 +57,10 @@ abstract class HybridNowPlayingTemplateSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun updateNowPlayingTemplateInfo(templateId: String, title: String, subtitle: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun updateNowPlayingTemplateElapsedTime(templateId: String, elapsedTime: Double, duration: Double): Promise<Unit>
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/ios/c++/HybridNowPlayingTemplateSpecSwift.hpp

@@ -106,6 +106,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> updateNowPlayingTemplateElapsedTime(const std::string& templateId, double elapsedTime, double duration) override {
+      auto __result = _swiftPart.updateNowPlayingTemplateElapsedTime(templateId, std::forward<decltype(elapsedTime)>(elapsedTime), std::forward<decltype(duration)>(duration));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeAutoPlay::HybridNowPlayingTemplateSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridNowPlayingTemplateSpec.swift

@@ -17,6 +17,7 @@ public protocol HybridNowPlayingTemplateSpec_protocol: HybridObject {
   func createNowPlayingTemplate(config: NowPlayingTemplateConfig) throws -> Void
   func updateNowPlayingTemplatePlaybackState(templateId: String, isPlaying: Bool) throws -> Promise<Void>
   func updateNowPlayingTemplateInfo(templateId: String, title: String, subtitle: String) throws -> Promise<Void>
+  func updateNowPlayingTemplateElapsedTime(templateId: String, elapsedTime: Double, duration: Double) throws -> Promise<Void>
 }
 
 public extension HybridNowPlayingTemplateSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNowPlayingTemplateSpec_cxx.swift

@@ -165,4 +165,23 @@ open class HybridNowPlayingTemplateSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func updateNowPlayingTemplateElapsedTime(templateId: std.string, elapsedTime: Double, duration: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.updateNowPlayingTemplateElapsedTime(templateId: String(templateId), elapsedTime: elapsedTime, duration: duration)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
 }

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

@@ -17,6 +17,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("createNowPlayingTemplate", &HybridNowPlayingTemplateSpec::createNowPlayingTemplate);
       prototype.registerHybridMethod("updateNowPlayingTemplatePlaybackState", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplatePlaybackState);
       prototype.registerHybridMethod("updateNowPlayingTemplateInfo", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplateInfo);
+      prototype.registerHybridMethod("updateNowPlayingTemplateElapsedTime", &HybridNowPlayingTemplateSpec::updateNowPlayingTemplateElapsedTime);
     });
   }
 

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

@@ -54,6 +54,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual void createNowPlayingTemplate(const NowPlayingTemplateConfig& config) = 0;
       virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplatePlaybackState(const std::string& templateId, bool isPlaying) = 0;
       virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplateInfo(const std::string& templateId, const std::string& title, const std::string& subtitle) = 0;
+      virtual std::shared_ptr<Promise<void>> updateNowPlayingTemplateElapsedTime(const std::string& templateId, double elapsedTime, double duration) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neoskola/auto-play",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/specs/NowPlayingTemplate.nitro.ts

@@ -8,4 +8,5 @@ export interface NowPlayingTemplate extends HybridObject<{ android: 'kotlin'; io
   createNowPlayingTemplate(config: NowPlayingTemplateConfig): void;
   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>;
 }

package/src/templates/NowPlayingTemplate.ts

@@ -59,4 +59,8 @@ export class NowPlayingTemplate extends Template<
   public updateNowPlayingInfo(title: string, subtitle: string) {
     return HybridNowPlayingTemplate.updateNowPlayingTemplateInfo(this.id, title, subtitle);
   }
+
+  public updateElapsedTime(elapsedTime: number, duration: number) {
+    return HybridNowPlayingTemplate.updateNowPlayingTemplateElapsedTime(this.id, elapsedTime, duration);
+  }
 }