react-native-nitro-player 0.0.1 → 0.3.0-alpha.5

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAudioDevices.kt

@@ -7,21 +7,21 @@ import android.os.Build
 import com.margelo.nitro.NitroModules
 
 class HybridAudioDevices : HybridAudioDevicesSpec() {
-
-    val applicationContext = NitroModules.applicationContext;
+    val applicationContext = NitroModules.applicationContext
     private val audioManager = applicationContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    
+
     // Device types that can be set as communication devices
     private val validCommunicationDeviceTypes: Set<Int> by lazy {
-        val types = mutableSetOf(
-            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE,
-            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
-            AudioDeviceInfo.TYPE_WIRED_HEADSET,
-            AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-            AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
-            AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-            AudioDeviceInfo.TYPE_USB_HEADSET
-        )
+        val types =
+            mutableSetOf(
+                AudioDeviceInfo.TYPE_BUILTIN_EARPIECE,
+                AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
+                AudioDeviceInfo.TYPE_WIRED_HEADSET,
+                AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+                AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+                AudioDeviceInfo.TYPE_USB_HEADSET,
+            )
         // BLE types are only available on Android S (API 31) and above
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             types.add(AudioDeviceInfo.TYPE_BLE_HEADSET)
@@ -29,7 +29,7 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
         }
         types
     }
-    
+
     override fun getAudioDevices(): Array<TAudioDevice> {
         val devices = audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
         var activeDevice: AudioDeviceInfo? = null
@@ -37,20 +37,23 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             activeDevice = audioManager.communicationDevice
         }
-        
+
         // Filter to only include valid communication devices
-        return devices.filter { device ->
-            validCommunicationDeviceTypes.contains(device.type)
-        }.map { device -> TAudioDevice(
-            id = device.id.toDouble(),
-            name = device.productName?.toString() ?: getDeviceTypeName(device.type),
-            type = device.type.toDouble(),
-            isActive = device == activeDevice
-        ) }.toTypedArray()
+        return devices
+            .filter { device ->
+                validCommunicationDeviceTypes.contains(device.type)
+            }.map { device ->
+                TAudioDevice(
+                    id = device.id.toDouble(),
+                    name = device.productName?.toString() ?: getDeviceTypeName(device.type),
+                    type = device.type.toDouble(),
+                    isActive = device == activeDevice,
+                )
+            }.toTypedArray()
     }
-    
-    private fun getDeviceTypeName(type: Int): String {
-        return when (type) {
+
+    private fun getDeviceTypeName(type: Int): String =
+        when (type) {
             AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> "Built-in Earpiece"
             AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "Built-in Speaker"
             AudioDeviceInfo.TYPE_WIRED_HEADSET -> "Wired Headset"
@@ -62,11 +65,11 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
             27 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Speaker" else "Type 27"
             else -> "Type $type"
         }
-    }
 
     override fun setAudioDevice(deviceId: Double): Boolean {
         val device =
-            audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
+            audioManager
+                .getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
                 .firstOrNull { it.id == deviceId.toInt() }
                 ?: return false
 
@@ -83,21 +86,26 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
                 // Pre-Android 12 fallback (best-effort)
                 when (device.type) {
                     android.media.AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
-                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+                    -> {
                         audioManager.startBluetoothSco()
                         audioManager.isBluetoothScoOn = true
                         true
                     }
+
                     android.media.AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
                         audioManager.isSpeakerphoneOn = true
                         true
                     }
+
                     android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET,
-                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> {
+                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                    -> {
                         audioManager.isSpeakerphoneOn = false
                         audioManager.isBluetoothScoOn = false
                         true
                     }
+
                     else -> {
                         android.util.Log.w(TAG, "Unsupported device type for pre-Android 12: ${device.type}")
                         false

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridTrackPlayer.kt

@@ -57,6 +57,10 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     @Keep
     override fun getState(): PlayerState = core.getState()
 
+    @DoNotStrip
+    @Keep
+    override fun setRepeatMode(mode: RepeatMode): Boolean = core.setRepeatMode(mode)
+
     override fun onChangeTrack(callback: (track: TrackItem, reason: Reason?) -> Unit) {
         core.onChangeTrack = callback
     }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -13,6 +13,7 @@ import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.NitroPlayerPackage
 import com.margelo.nitro.nitroplayer.PlayerState
 import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
@@ -476,6 +477,21 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    fun setRepeatMode(mode: RepeatMode): Boolean {
+        println("🔁 TrackPlayerCore: setRepeatMode called with mode: $mode")
+        handler.post {
+            val exoRepeatMode =
+                when (mode) {
+                    RepeatMode.OFF -> Player.REPEAT_MODE_OFF
+                    RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+                    RepeatMode.PLAYLIST -> Player.REPEAT_MODE_ALL
+                }
+            player.repeatMode = exoRepeatMode
+            println("🔁 TrackPlayerCore: ExoPlayer repeat mode set to: $exoRepeatMode")
+        }
+        return true
+    }
+
     fun getState(): PlayerState {
         // Check if we're already on the main thread
         if (android.os.Looper.myLooper() == handler.looper) {

package/ios/HybridAudioRoutePicker.swift

@@ -1,53 +1,54 @@
-import Foundation
-import UIKit
 import AVKit
+import Foundation
 import NitroModules
+import UIKit
 
 class HybridAudioRoutePicker: HybridAudioRoutePickerSpec {
-    
-    // Approximate memory footprint of this instance's reference
-    private func getSizeOf(_ object: AnyObject) -> Int {
-        // For class instances, MemoryLayout reports the size of the reference (pointer)
-        return MemoryLayout.size(ofValue: object)
-    }
-    
-    var memorySize: Int {
-        return getSizeOf(self)
-    }
-    
-    func showRoutePicker() throws -> Void {
-        DispatchQueue.main.async {
-            // Create AVRoutePickerView
-            let routePickerView = AVRoutePickerView()
-            routePickerView.frame = CGRect(x: 0, y: 0, width: 44, height: 44)
-            routePickerView.tintColor = .systemBlue
-            routePickerView.activeTintColor = .systemBlue
-            
-            // Get the key window
-            guard let window = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .flatMap({ $0.windows })
-                .first(where: { $0.isKeyWindow }) else {
-                print("HybridAudioRoutePicker: Could not find key window")
-                return
-            }
-            
-            // Add the route picker to the window temporarily
-            window.addSubview(routePickerView)
-            
-            // Trigger the route picker button programmatically
-            for view in routePickerView.subviews {
-                if let button = view as? UIButton {
-                    button.sendActions(for: .touchUpInside)
-                    break
-                }
-            }
-            
-            // Remove the view after a short delay
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                routePickerView.removeFromSuperview()
-            }
+
+  // Approximate memory footprint of this instance's reference
+  private func getSizeOf(_ object: AnyObject) -> Int {
+    // For class instances, MemoryLayout reports the size of the reference (pointer)
+    return MemoryLayout.size(ofValue: object)
+  }
+
+  var memorySize: Int {
+    return getSizeOf(self)
+  }
+
+  func showRoutePicker() throws {
+    DispatchQueue.main.async {
+      // Create AVRoutePickerView
+      let routePickerView = AVRoutePickerView()
+      routePickerView.frame = CGRect(x: 0, y: 0, width: 44, height: 44)
+      routePickerView.tintColor = .systemBlue
+      routePickerView.activeTintColor = .systemBlue
+
+      // Get the key window
+      guard
+        let window = UIApplication.shared.connectedScenes
+          .compactMap({ $0 as? UIWindowScene })
+          .flatMap({ $0.windows })
+          .first(where: { $0.isKeyWindow })
+      else {
+        print("HybridAudioRoutePicker: Could not find key window")
+        return
+      }
+
+      // Add the route picker to the window temporarily
+      window.addSubview(routePickerView)
+
+      // Trigger the route picker button programmatically
+      for view in routePickerView.subviews {
+        if let button = view as? UIButton {
+          button.sendActions(for: .touchUpInside)
+          break
         }
+      }
+
+      // Remove the view after a short delay
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+        routePickerView.removeFromSuperview()
+      }
     }
+  }
 }
-

package/ios/HybridTrackPlayer.swift

@@ -52,6 +52,10 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     return core.getState()
   }
 
+  func setRepeatMode(mode: RepeatMode) throws -> Bool {
+    return core.setRepeatMode(mode: mode)
+  }
+
   // MARK: - Configuration
 
   func configure(config: PlayerConfig) throws {

package/ios/core/TrackPlayerCore.swift

@@ -42,6 +42,7 @@ class TrackPlayerCore: NSObject {
   private var currentTrackIndex: Int = -1
   private var currentTracks: [TrackItem] = []
   private var isManuallySeeked = false
+  private var repeatMode: RepeatMode = .off
   private var boundaryTimeObserver: Any?
   private var currentItemObservers: [NSKeyValueObservation] = []
 
@@ -232,6 +233,38 @@ class TrackPlayerCore: NSObject {
       print("📋 Remaining items in queue: \(player.items().count)")
     }
 
+    // Handle repeat modes
+    switch repeatMode {
+    case .track:
+      // Repeat current track - seek to beginning and play
+      print("🔁 TrackPlayerCore: Repeat mode is TRACK - replaying current track")
+      DispatchQueue.main.async { [weak self] in
+        guard let self = self, let player = self.player else { return }
+        // Recreate the current track item and play it
+        self.playFromIndex(index: self.currentTrackIndex)
+      }
+      return
+
+    case .playlist:
+      // Check if we're at the end of the playlist
+      if currentTrackIndex >= currentTracks.count - 1 {
+        print("🔁 TrackPlayerCore: Repeat mode is PLAYLIST - restarting from beginning")
+        DispatchQueue.main.async { [weak self] in
+          guard let self = self else { return }
+          // Go back to the first track
+          self.playFromIndex(index: 0)
+        }
+        return
+      } else {
+        // Not at end, just continue to next track
+        print("🔁 TrackPlayerCore: Repeat mode is PLAYLIST - continuing to next track")
+      }
+
+    case .off:
+      // Default behavior - stop at end of playlist
+      print("🔁 TrackPlayerCore: Repeat mode is OFF")
+    }
+
     // Track ended naturally
     onChangeTrack?(
       getCurrentTrack()
@@ -867,6 +900,14 @@ class TrackPlayerCore: NSObject {
     }
   }
 
+  // MARK: - Repeat Mode
+
+  func setRepeatMode(mode: RepeatMode) -> Bool {
+    print("🔁 TrackPlayerCore: setRepeatMode called with mode: \(mode)")
+    self.repeatMode = mode
+    return true
+  }
+
   // MARK: - State Management
 
   func getState() -> PlayerState {

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

@@ -13,6 +13,8 @@ namespace margelo::nitro::nitroplayer { struct PlayerState; }
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
@@ -31,6 +33,8 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "JVariant_NullType_String.hpp"
 #include "TrackPlayerState.hpp"
 #include "JTrackPlayerState.hpp"
+#include "RepeatMode.hpp"
+#include "JRepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "JPlayerConfig.hpp"
 #include "Reason.hpp"
@@ -104,6 +108,11 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
+  bool JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");
+    auto __result = method(_javaPart, JRepeatMode::fromCpp(mode));
+    return static_cast<bool>(__result);
+  }
   void JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
     method(_javaPart, JPlayerConfig::fromCpp(config));

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

@@ -61,6 +61,7 @@ namespace margelo::nitro::nitroplayer {
     void skipToPrevious() override;
     void seek(double position) override;
     PlayerState getState() override;
+    bool setRepeatMode(RepeatMode mode) override;
     void configure(const PlayerConfig& config) override;
     void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override;
     void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) override;

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

@@ -0,0 +1,62 @@
+///
+/// JRepeatMode.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 "RepeatMode.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RepeatMode" and the the Kotlin enum "RepeatMode".
+   */
+  struct JRepeatMode final: public jni::JavaClass<JRepeatMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/RepeatMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RepeatMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RepeatMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RepeatMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRepeatMode> fromCpp(RepeatMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOFF = clazz->getStaticField<JRepeatMode>("OFF");
+      static const auto fieldPLAYLIST = clazz->getStaticField<JRepeatMode>("PLAYLIST");
+      static const auto fieldTRACK = clazz->getStaticField<JRepeatMode>("TRACK");
+      
+      switch (value) {
+        case RepeatMode::OFF:
+          return clazz->getStaticFieldValue(fieldOFF);
+        case RepeatMode::PLAYLIST:
+          return clazz->getStaticFieldValue(fieldPLAYLIST);
+        case RepeatMode::TRACK:
+          return clazz->getStaticFieldValue(fieldTRACK);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridTrackPlayerSpec.kt

@@ -73,6 +73,10 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @Keep
   abstract fun getState(): PlayerState
   
+  @DoNotStrip
+  @Keep
+  abstract fun setRepeatMode(mode: RepeatMode): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun configure(config: PlayerConfig): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/RepeatMode.kt

@@ -0,0 +1,22 @@
+///
+/// RepeatMode.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "RepeatMode".
+ */
+@DoNotStrip
+@Keep
+enum class RepeatMode(@DoNotStrip @Keep val value: Int) {
+  OFF(0),
+  PLAYLIST(1),
+  TRACK(2);
+}

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Umbrella.hpp

@@ -24,6 +24,8 @@ namespace margelo::nitro::nitroplayer { struct Playlist; }
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -38,6 +40,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "Playlist.hpp"
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
+#include "RepeatMode.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include <NitroModules/Null.hpp>

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

@@ -18,6 +18,8 @@ namespace margelo::nitro::nitroplayer { struct PlayerState; }
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
@@ -30,6 +32,7 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "TrackItem.hpp"
 #include <variant>
 #include "TrackPlayerState.hpp"
+#include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "Reason.hpp"
 #include <functional>
@@ -122,6 +125,14 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool setRepeatMode(RepeatMode mode) override {
+      auto __result = _swiftPart.setRepeatMode(static_cast<int>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void configure(const PlayerConfig& config) override {
       auto __result = _swiftPart.configure(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -21,6 +21,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func skipToPrevious() throws -> Void
   func seek(position: Double) throws -> Void
   func getState() throws -> PlayerState
+  func setRepeatMode(mode: RepeatMode) throws -> Bool
   func configure(config: PlayerConfig) throws -> Void
   func onChangeTrack(callback: @escaping (_ track: TrackItem, _ reason: Reason?) -> Void) throws -> Void
   func onPlaybackStateChange(callback: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -202,6 +202,18 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setRepeatMode(mode: Int32) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setRepeatMode(mode: margelo.nitro.nitroplayer.RepeatMode(rawValue: mode)!)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func configure(config: PlayerConfig) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/RepeatMode.swift

@@ -0,0 +1,44 @@
+///
+/// RepeatMode.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `RepeatMode`, backed by a C++ enum.
+ */
+public typealias RepeatMode = margelo.nitro.nitroplayer.RepeatMode
+
+public extension RepeatMode {
+  /**
+   * Get a RepeatMode for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "off":
+        self = .off
+      case "Playlist":
+        self = .playlist
+      case "track":
+        self = .track
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this RepeatMode represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .off:
+        return "off"
+      case .playlist:
+        return "Playlist"
+      case .track:
+        return "track"
+    }
+  }
+}

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

@@ -21,6 +21,7 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("skipToPrevious", &HybridTrackPlayerSpec::skipToPrevious);
       prototype.registerHybridMethod("seek", &HybridTrackPlayerSpec::seek);
       prototype.registerHybridMethod("getState", &HybridTrackPlayerSpec::getState);
+      prototype.registerHybridMethod("setRepeatMode", &HybridTrackPlayerSpec::setRepeatMode);
       prototype.registerHybridMethod("configure", &HybridTrackPlayerSpec::configure);
       prototype.registerHybridMethod("onChangeTrack", &HybridTrackPlayerSpec::onChangeTrack);
       prototype.registerHybridMethod("onPlaybackStateChange", &HybridTrackPlayerSpec::onPlaybackStateChange);

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

@@ -15,6 +15,8 @@
 
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `TrackItem` to properly resolve imports.
@@ -27,6 +29,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include <string>
 #include <optional>
 #include "PlayerState.hpp"
+#include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "TrackItem.hpp"
 #include "Reason.hpp"
@@ -71,6 +74,7 @@ namespace margelo::nitro::nitroplayer {
       virtual void skipToPrevious() = 0;
       virtual void seek(double position) = 0;
       virtual PlayerState getState() = 0;
+      virtual bool setRepeatMode(RepeatMode mode) = 0;
       virtual void configure(const PlayerConfig& config) = 0;
       virtual void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) = 0;
       virtual void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) = 0;