Allow looping of queue player

SwiftAudio/Classes/AudioItem.swift

@@ -14,21 +14,21 @@ public enum SourceType {
 }
 
 public protocol AudioItem {
-    
+
     func getSourceUrl() -> String
     func getArtist() -> String?
     func getTitle() -> String?
     func getAlbumTitle() -> String?
     func getSourceType() -> SourceType
     func getArtwork(_ handler: @escaping (UIImage?) -> Void)
-    
+    func getVolume() -> Float
 }
 
 /// Make your `AudioItem`-subclass conform to this protocol to control which AVAudioTimePitchAlgorithm is used for each item.
 public protocol TimePitching {
-    
+
     func getPitchAlgorithmType() -> AVAudioTimePitchAlgorithm
-    
+
 }
 
 /// Make your `AudioItem`-subclass conform to this protocol to control enable the ability to start an item at a specific time of playback.
@@ -42,44 +42,46 @@ public protocol AssetOptionsProviding {
 }
 
 public class DefaultAudioItem: AudioItem {
-    
+    public var audioVolume: Float
+
     public var audioUrl: String
-    
+
     public var artist: String?
-    
+
     public var title: String?
-    
+
     public var albumTitle: String?
-    
+
     public var sourceType: SourceType
-    
+
     public var artwork: UIImage?
-    
-    public init(audioUrl: String, artist: String? = nil, title: String? = nil, albumTitle: String? = nil, sourceType: SourceType, artwork: UIImage? = nil) {
+
+    public init(audioUrl: String, artist: String? = nil, title: String? = nil, albumTitle: String? = nil, sourceType: SourceType, artwork: UIImage? = nil, audioVolume: Float = 1.0) {
         self.audioUrl = audioUrl
         self.artist = artist
         self.title = title
         self.albumTitle = albumTitle
         self.sourceType = sourceType
         self.artwork = artwork
+        self.audioVolume = audioVolume
     }
-    
+
     public func getSourceUrl() -> String {
         return audioUrl
     }
-    
+
     public func getArtist() -> String? {
         return artist
     }
-    
+
     public func getTitle() -> String? {
         return title
     }
-    
+
     public func getAlbumTitle() -> String? {
         return albumTitle
     }
-    
+
     public func getSourceType() -> SourceType {
         return sourceType
     }
@@ -87,24 +89,27 @@ public class DefaultAudioItem: AudioItem {
     public func getArtwork(_ handler: @escaping (UIImage?) -> Void) {
         handler(artwork)
     }
-    
+
+    public func getVolume() -> Float {
+        return audioVolume
+    }
 }
 
 /// An AudioItem that also conforms to the `TimePitching`-protocol
 public class DefaultAudioItemTimePitching: DefaultAudioItem, TimePitching {
-    
+
     public var pitchAlgorithmType: AVAudioTimePitchAlgorithm
-    
-    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?) {
+
+    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, audioVolume: Float?) {
         self.pitchAlgorithmType = AVAudioTimePitchAlgorithm.lowQualityZeroLatency
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, audioTimePitchAlgorithm: AVAudioTimePitchAlgorithm) {
         self.pitchAlgorithmType = audioTimePitchAlgorithm
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public func getPitchAlgorithmType() -> AVAudioTimePitchAlgorithm {
         return pitchAlgorithmType
     }
@@ -112,42 +117,42 @@ public class DefaultAudioItemTimePitching: DefaultAudioItem, TimePitching {
 
 /// An AudioItem that also conforms to the `InitialTiming`-protocol
 public class DefaultAudioItemInitialTime: DefaultAudioItem, InitialTiming {
-    
+
     public var initialTime: TimeInterval
-    
-    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?) {
+
+    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, audioVolume: Float?) {
         self.initialTime = 0.0
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, initialTime: TimeInterval) {
         self.initialTime = initialTime
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public func getInitialTime() -> TimeInterval {
         return initialTime
     }
-    
+
 }
 
 /// An AudioItem that also conforms to the `AssetOptionsProviding`-protocol
 public class DefaultAudioItemAssetOptionsProviding: DefaultAudioItem, AssetOptionsProviding {
-    
+
     public var options: [String: Any]
-    
-    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?) {
+
+    public override init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, audioVolume: Float?) {
         self.options = [:]
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public init(audioUrl: String, artist: String?, title: String?, albumTitle: String?, sourceType: SourceType, artwork: UIImage?, options: [String: Any]) {
         self.options = options
         super.init(audioUrl: audioUrl, artist: artist, title: title, albumTitle: albumTitle, sourceType: sourceType, artwork: artwork)
     }
-    
+
     public func getAssetOptions() -> [String: Any] {
         return options
     }
-    
+
 }

SwiftAudio/Classes/AudioPlayer.swift

@@ -11,84 +11,84 @@ import MediaPlayer
 public typealias AudioPlayerState = AVPlayerWrapperState
 
 public class AudioPlayer: AVPlayerWrapperDelegate {
-    
+
     private var _wrapper: AVPlayerWrapperProtocol
-    
+
     /// The wrapper around the underlying AVPlayer
     var wrapper: AVPlayerWrapperProtocol {
         return _wrapper
     }
-    
+
     public let nowPlayingInfoController: NowPlayingInfoControllerProtocol
     public let remoteCommandController: RemoteCommandController
     public let event = EventHolder()
-    
+
     var _currentItem: AudioItem?
     public var currentItem: AudioItem? {
         return _currentItem
     }
-    
+
     /**
      Set this to false to disable automatic updating of now playing info for control center and lock screen.
      */
     public var automaticallyUpdateNowPlayingInfo: Bool = true
-    
+
     /**
      Controls the time pitch algorithm applied to each item loaded into the player.
      If the loaded `AudioItem` conforms to `TimePitcher`-protocol this will be overriden.
      */
     public var audioTimePitchAlgorithm: AVAudioTimePitchAlgorithm = AVAudioTimePitchAlgorithm.lowQualityZeroLatency
-    
+
     /**
      Default remote commands to use for each playing item
      */
     public var remoteCommands: [RemoteCommand] = []
-    
-    
+
+
     // MARK: - Getters from AVPlayerWrapper
-    
+
     /**
      The elapsed playback time of the current item.
      */
     public var currentTime: Double {
         return wrapper.currentTime
     }
-    
+
     /**
      The duration of the current AudioItem.
      */
     public var duration: Double {
         return wrapper.duration
     }
-    
+
     /**
      The bufferedPosition of the current AudioItem.
      */
     public var bufferedPosition: Double {
         return wrapper.bufferedPosition
     }
-    
+
     /**
      The current state of the underlying `AudioPlayer`.
      */
     public var playerState: AudioPlayerState {
         return wrapper.state
     }
-    
+
     // MARK: - Setters for AVPlayerWrapper
-    
+
     /**
      The amount of seconds to be buffered by the player. Default value is 0 seconds, this means the AVPlayer will choose an appropriate level of buffering.
-     
+
      [Read more from Apple Documentation](https://developer.apple.com/documentation/avfoundation/avplayeritem/1643630-preferredforwardbufferduration)
-     
+
      - Important: This setting will have no effect if `automaticallyWaitsToMinimizeStalling` is set to `true` in the AVPlayer
      */
     public var bufferDuration: TimeInterval {
         get { return wrapper.bufferDuration }
         set { _wrapper.bufferDuration = newValue }
     }
-    
+
     /**
      Set this to decide how often the player should call the delegate with time progress events.
      */
@@ -96,7 +96,7 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         get { return wrapper.timeEventFrequency }
         set { _wrapper.timeEventFrequency = newValue }
     }
-    
+
     /**
      Indicates whether the player should automatically delay playback in order to minimize stalling
      */
@@ -104,12 +104,12 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         get { return wrapper.automaticallyWaitsToMinimizeStalling }
         set { _wrapper.automaticallyWaitsToMinimizeStalling = newValue }
     }
-    
+
     public var volume: Float {
         get { return wrapper.volume }
         set { _wrapper.volume = newValue }
     }
-    
+
     public var isMuted: Bool {
         get { return wrapper.isMuted }
         set { _wrapper.isMuted = newValue }
@@ -119,12 +119,25 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         get { return wrapper.rate }
         set { _wrapper.rate = newValue }
     }
-    
+
+    public var volumeMultiplier: Float = 1 {
+        didSet {
+            guard let currentVolume = currentItem?.getVolume() else { return }
+            self.volume = currentVolume * volumeMultiplier
+        }
+    }
+
+    /**
+     Set wether the player should loop when a song is finished.
+     Default is `false`.
+     */
+    public var loop: Bool = false
+
     // MARK: - Init
-    
+
     /**
      Create a new AudioPlayer.
-     
+
      - parameter infoCenter: The InfoCenter to update. Default is `MPNowPlayingInfoCenter.default()`.
      */
     public init(nowPlayingInfoController: NowPlayingInfoControllerProtocol = NowPlayingInfoController(),
@@ -132,16 +145,16 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         self._wrapper = AVPlayerWrapper()
         self.nowPlayingInfoController = nowPlayingInfoController
         self.remoteCommandController = remoteCommandController
-        
+
         self._wrapper.delegate = self
         self.remoteCommandController.audioPlayer = self
     }
-    
+
     // MARK: - Player Actions
-    
+
     /**
      Load an AudioItem into the manager.
-     
+
      - parameter item: The AudioItem to load. The info given in this item is the one used for the InfoCenter.
      - parameter playWhenReady: Immediately start playback when the item is ready. Default is `true`. If you disable this you have to call play() or togglePlay() when the `state` switches to `ready`.
      */
@@ -158,41 +171,43 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         case .file:
             url = URL(fileURLWithPath: item.getSourceUrl())
         }
-        
+
         wrapper.load(from: url,
                      playWhenReady: playWhenReady,
                      initialTime: (item as? InitialTiming)?.getInitialTime(),
                      options:(item as? AssetOptionsProviding)?.getAssetOptions())
-        
+
         self._currentItem = item
-        
+
         if (automaticallyUpdateNowPlayingInfo) {
             self.loadNowPlayingMetaValues()
         }
         enableRemoteCommands(forItem: item)
+
+        self.volume = item.getVolume() * volumeMultiplier
     }
-    
+
     /**
      Toggle playback status.
      */
     public func togglePlaying() {
         self.wrapper.togglePlaying()
     }
-    
+
     /**
      Start playback
      */
     public func play() {
         self.wrapper.play()
     }
-    
+
     /**
      Pause playback
      */
     public func pause() {
         self.wrapper.pause()
     }
-    
+
     /**
      Stop playback, resetting the player.
      */
@@ -201,7 +216,7 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         self.wrapper.stop()
         self.event.playbackEnd.emit(data: .playerStopped)
     }
-    
+
     /**
      Seek to a specific time in the item.
      */
@@ -211,13 +226,13 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         }
         self.wrapper.seek(to: seconds)
     }
-    
+
     // MARK: - Remote Command Center
-    
+
     func enableRemoteCommands(_ commands: [RemoteCommand]) {
         self.remoteCommandController.enable(commands: commands)
     }
-    
+
     func enableRemoteCommands(forItem item: AudioItem) {
         if let item = item as? RemoteCommandable {
             self.enableRemoteCommands(item.getCommands())
@@ -226,12 +241,12 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
             self.enableRemoteCommands(remoteCommands)
         }
     }
-    
+
     // MARK: - NowPlayingInfo
-    
+
     /**
      Loads NowPlayingInfo-meta values with the values found in the current `AudioItem`. Use this if a change to the `AudioItem` is made and you want to update the `NowPlayingInfoController`s values.
-     
+
      Reloads:
      - Artist
      - Title
@@ -240,19 +255,19 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
      */
     public func loadNowPlayingMetaValues() {
         guard let item = currentItem else { return }
-        
+
         nowPlayingInfoController.set(keyValues: [
             MediaItemProperty.artist(item.getArtist()),
             MediaItemProperty.title(item.getTitle()),
             MediaItemProperty.albumTitle(item.getAlbumTitle()),
         ])
-        
+
         loadArtwork(forItem: item)
     }
-    
+
     /**
      Resyncs the playbackvalues of the currently playing `AudioItem`.
-     
+
      Will resync:
      - Current time
      - Duration
@@ -263,19 +278,19 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         updateNowPlayingCurrentTime(currentTime)
         updateNowPlayingRate(rate)
     }
-    
+
     private func updateNowPlayingDuration(_ duration: Double) {
         nowPlayingInfoController.set(keyValue: MediaItemProperty.duration(duration))
     }
-    
+
     private func updateNowPlayingRate(_ rate: Float) {
         nowPlayingInfoController.set(keyValue: NowPlayingInfoProperty.playbackRate(Double(rate)))
     }
-    
+
     private func updateNowPlayingCurrentTime(_ currentTime: Double) {
         nowPlayingInfoController.set(keyValue: NowPlayingInfoProperty.elapsedPlaybackTime(currentTime))
     }
-    
+
     private func loadArtwork(forItem item: AudioItem) {
         item.getArtwork { (image) in
             if let image = image {
@@ -286,13 +301,13 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
             }
         }
     }
-    
+
     // MARK: - Private
-    
+
     func reset() {
         self._currentItem = nil
     }
-    
+
     private func setTimePitchingAlgorithmForCurrentItem() {
         if let item = currentItem as? TimePitching {
             wrapper.currentItem?.audioTimePitchAlgorithm = item.getPitchAlgorithmType()
@@ -301,9 +316,9 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
             wrapper.currentItem?.audioTimePitchAlgorithm = audioTimePitchAlgorithm
         }
     }
-    
+
     // MARK: - AVPlayerWrapperDelegate
-    
+
     func AVWrapper(didChangeState state: AVPlayerWrapperState) {
         switch state {
         case .ready, .loading:
@@ -319,32 +334,37 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
         }
         self.event.stateChange.emit(data: state)
     }
-    
+
     func AVWrapper(secondsElapsed seconds: Double) {
         self.event.secondElapse.emit(data: seconds)
     }
-    
+
     func AVWrapper(failedWithError error: Error?) {
         self.event.fail.emit(data: error)
     }
-    
+
     func AVWrapper(seekTo seconds: Int, didFinish: Bool) {
         if !didFinish && automaticallyUpdateNowPlayingInfo {
             updateNowPlayingCurrentTime(currentTime)
         }
         self.event.seek.emit(data: (seconds, didFinish))
     }
-    
+
     func AVWrapper(didUpdateDuration duration: Double) {
         self.event.updateDuration.emit(data: duration)
     }
-    
+
     func AVWrapperItemDidPlayToEndTime() {
+        if loop {
+            seek(to: .zero)
+            play()
+        }
+
         self.event.playbackEnd.emit(data: .playedUntilEnd)
     }
-    
+
     func AVWrapperDidRecreateAVPlayer() {
         self.event.didRecreateAVPlayer.emit(data: ())
     }
-    
+
 }

SwiftAudio/Classes/QueueManager.swift

@@ -9,32 +9,32 @@ import Foundation
 
 
 class QueueManager<T> {
-    
+
     private var _items: [T] = []
-    
+
     /**
      All items held by the queue.
      */
     public var items: [T] {
         return _items
     }
-    
+
     public var nextItems: [T] {
         guard _currentIndex + 1 < _items.count else {
             return []
         }
         return Array(_items[_currentIndex + 1..<_items.count])
     }
-    
+
     public var previousItems: [T] {
         if (_currentIndex == 0) {
             return []
         }
         return Array(_items[0..<_currentIndex])
     }
-    
+
     private var _currentIndex: Int = 0
-    
+
     /**
      The index of the current item.
      Will be populated event though there is no current item (When the queue is empty).
@@ -42,7 +42,7 @@ class QueueManager<T> {
     public var currentIndex: Int {
         return _currentIndex
     }
-    
+
     /**
      The current item for the queue.
      */
@@ -52,28 +52,28 @@ class QueueManager<T> {
         }
         return nil
     }
-    
+
     /**
      Add a single item to the queue.
-     
+
      - parameter item: The `AudioItem` to be added.
      */
     public func addItem(_ item: T) {
         _items.append(item)
     }
-    
+
     /**
      Add an array of items to the queue.
-     
+
      - parameter items: The `AudioItem`s to be added.
      */
     public func addItems(_ items: [T]) {
         _items.append(contentsOf: items)
     }
-    
+
     /**
      Add an array of items to the queue at a given index.
-     
+
      - parameter items: The `AudioItem`s to be added.
      - parameter at: The index to insert the items at.
      */
@@ -81,15 +81,15 @@ class QueueManager<T> {
         guard index >= 0 && _items.count > index else {
             throw APError.QueueError.invalidIndex(index: index, message: "Index for addition has to be positive and smaller than the count of current items (\(_items.count))")
         }
-        
+
         _items.insert(contentsOf: items, at: index)
         if (_currentIndex >= index) { _currentIndex = _currentIndex + items.count }
     }
-    
+
     /**
      Get the next item in the queue, if there are any.
      Will update the current item.
-     
+
      - throws: `APError.QueueError`
      - returns: The next item.
      */
@@ -102,7 +102,7 @@ class QueueManager<T> {
         _currentIndex = nextIndex
         return _items[nextIndex]
     }
-    
+
     /**
      Get the previous item in the queue, if there are any.
      Will update the current item.
@@ -119,21 +119,21 @@ class QueueManager<T> {
         _currentIndex = previousIndex
         return _items[previousIndex]
     }
-    
+
     /**
      Jump to a position in the queue.
      Will update the current item.
-     
+
      - parameter index: The index to jump to.
      - throws: `APError.QueueError`
      - returns: The item at the index.
      */
     @discardableResult
-    func jump(to index: Int) throws -> T {
-        guard index != currentIndex else {
+    func jump(to index: Int, allowSameIndex: Bool = false) throws -> T {
+        guard index != currentIndex || allowSameIndex else {
             throw APError.QueueError.invalidIndex(index: index, message: "Cannot jump to the current item")
         }
-        
+
         guard index >= 0 && _items.count > index else {
             throw APError.QueueError.invalidIndex(index: index, message: "The jump index has to be positive and smaller thant the count of current items (\(_items.count))")
         }
@@ -141,35 +141,35 @@ class QueueManager<T> {
         _currentIndex = index
         return _items[index]
     }
-    
+
     /**
      Move an item in the queue.
-     
+
      - parameter fromIndex: The index of the item to be moved.
      - parameter toIndex: The index to move the item to.
      - throws: `APError.QueueError`
      */
     func moveItem(fromIndex: Int, toIndex: Int) throws {
-        
+
         guard fromIndex != _currentIndex else {
             throw APError.QueueError.invalidIndex(index: fromIndex, message: "The fromIndex cannot be equal to the current index.")
         }
-        
+
         guard fromIndex >= 0 && fromIndex < _items.count else {
             throw APError.QueueError.invalidIndex(index: fromIndex, message: "The fromIndex has to be positive and smaller than the count of current items (\(_items.count)).")
         }
-        
+
         guard toIndex >= 0 && toIndex < _items.count else {
             throw APError.QueueError.invalidIndex(index: toIndex, message: "The toIndex has to be positive and smaller than the count of current items (\(_items.count)).")
         }
-        
+
         let item = try removeItem(at: fromIndex)
         try addItems([item], at: toIndex)
     }
-    
+
     /**
      Remove an item.
-     
+
      - parameter index: The index of the item to remove.
      - throws: APError.QueueError
      - returns: The removed item.
@@ -179,31 +179,31 @@ class QueueManager<T> {
         guard index != _currentIndex else {
             throw APError.QueueError.invalidIndex(index: index, message: "Cannot remove the current item!")
         }
-        
+
         guard index >= 0 && _items.count > index else {
             throw APError.QueueError.invalidIndex(index: index, message: "Index for removal has to be positive and smaller than the count of current items (\(_items.count)).")
         }
-        
+
         if index < _currentIndex {
             _currentIndex = _currentIndex - 1
         }
 
         return _items.remove(at: index)
     }
-    
+
     /**
      Replace the current item with a new one. If there is no current item, it is equivalent to calling add(item:).
-     
+
      - parameter item: The item to set as the new current item.
      */
     public func replaceCurrentItem(with item: T) {
         if current == nil  {
             self.addItem(item)
         }
-        
+
         self._items[_currentIndex] = item
     }
-    
+
     /**
      Remove all previous items in the queue.
      If no previous items exist, no action will be taken.
@@ -223,7 +223,7 @@ class QueueManager<T> {
         guard nextIndex < _items.count else { return }
         _items.removeSubrange(nextIndex..<_items.count)
     }
-    
+
     /**
      Removes all items for queue
      */

SwiftAudio/Classes/QueuedAudioPlayer.swift

@@ -12,72 +12,80 @@ import MediaPlayer
  An audio player that can keep track of a queue of AudioItems.
  */
 public class QueuedAudioPlayer: AudioPlayer {
-    
+
     let queueManager: QueueManager = QueueManager<AudioItem>()
-    
+
     /**
      Set wether the player should automatically play the next song when a song is finished.
      Default is `true`.
      */
     public var automaticallyPlayNextSong: Bool = true
-    
+
     public override var currentItem: AudioItem? {
         return queueManager.current
     }
-    
+
     /**
      The index of the current item.
      */
     public var currentIndex: Int {
         return queueManager.currentIndex
     }
-    
+
      /**
      Stops the player and clears the queue.
      */
     public override func stop() {
         super.stop()
     }
-    
+
     override func reset() {
         queueManager.clearQueue()
     }
-    
+
     /**
      All items currently in the queue.
      */
     public var items: [AudioItem] {
         return queueManager.items
     }
-    
+
     /**
      The previous items held by the queue.
      */
     public var previousItems: [AudioItem] {
         return queueManager.previousItems
     }
-    
+
     /**
      The upcoming items in the queue.
      */
     public var nextItems: [AudioItem] {
         return queueManager.nextItems
     }
-    
+
+    public override var volumeMultiplier: Float {
+        didSet {
+            guard let currentVolume = queueManager.current?.getVolume() else { return }
+            self.volume = currentVolume * volumeMultiplier
+        }
+    }
+
     /**
      Will replace the current item with a new one and load it into the player.
-     
+
      - parameter item: The AudioItem to replace the current item.
      - throws: APError.LoadError
      */
     public override func load(item: AudioItem, playWhenReady: Bool) throws {
         try super.load(item: item, playWhenReady: playWhenReady)
+
         queueManager.replaceCurrentItem(with: item)
     }
-    
+
     /**
      Add a single item to the queue.
-     
+
      - parameter item: The item to add.
      - parameter playWhenReady: If the AudioPlayer has no item loaded, it will load the `item`. If this is `true` it will automatically start playback. Default is `true`.
      - throws: `APError`
@@ -91,10 +99,10 @@ public class QueuedAudioPlayer: AudioPlayer {
             queueManager.addItem(item)
         }
     }
-    
+
     /**
      Add items to the queue.
-     
+
      - parameter items: The items to add to the queue.
      - parameter playWhenReady: If the AudioPlayer has no item loaded, it will load the first item in the list. If this is `true` it will automatically start playback. Default is `true`.
      - throws: `APError`
@@ -108,22 +116,30 @@ public class QueuedAudioPlayer: AudioPlayer {
             queueManager.addItems(items)
         }
     }
-    
+
     public func add(items: [AudioItem], at index: Int) throws {
         try queueManager.addItems(items, at: index)
     }
-    
+
     /**
-     Step to the next item in the queue.
-     
+     Step to the next item in the queue. If the queue has no next items, it starts again from the first item.
+     - parameter canRepeatSingleItem: if there is only one item in the queue, allow repeating it forever
      - throws: `APError`
      */
-    public func next() throws {
+    public func next(canRepeatSingleItem: Bool = false) throws {
         event.playbackEnd.emit(data: .skippedToNext)
-        let nextItem = try queueManager.next()
-        try self.load(item: nextItem, playWhenReady: true)
+
+        let nextItem: AudioItem?
+
+        do {
+            nextItem = try queueManager.next()
+        } catch {
+            nextItem = try queueManager.jump(to: 0, allowSameIndex: canRepeatSingleItem)
+        }
+
+        try self.load(item: nextItem!, playWhenReady: true)
     }
-    
+
     /**
      Step to the previous item in the queue.
      */
@@ -132,20 +148,20 @@ public class QueuedAudioPlayer: AudioPlayer {
         let previousItem = try queueManager.previous()
         try self.load(item: previousItem, playWhenReady: true)
     }
-    
+
     /**
      Remove an item from the queue.
-     
+
      - parameter index: The index of the item to remove.
      - throws: `APError.QueueError`
      */
     public func removeItem(at index: Int) throws {
         try queueManager.removeItem(at: index)
     }
-    
+
     /**
      Jump to a certain item in the queue.
-     
+
      - parameter index: The index of the item to jump to.
      - parameter playWhenReady: Wether the item should start playing when ready. Default is `true`.
      - throws: `APError`
@@ -155,10 +171,10 @@ public class QueuedAudioPlayer: AudioPlayer {
         let item = try queueManager.jump(to: index)
         try self.load(item: item, playWhenReady: playWhenReady)
     }
-    
+
     /**
      Move an item in the queue from one position to another.
-     
+
      - parameter fromIndex: The index of the item to move.
      - parameter toIndex: The index to move the item to.
      - throws: `APError.QueueError`
@@ -166,28 +182,28 @@ public class QueuedAudioPlayer: AudioPlayer {
     func moveItem(fromIndex: Int, toIndex: Int) throws {
         try queueManager.moveItem(fromIndex: fromIndex, toIndex: toIndex)
     }
-    
+
     /**
      Remove all upcoming items, those returned by `next()`
      */
     public func removeUpcomingItems() {
         queueManager.removeUpcomingItems()
     }
-    
+
     /**
      Remove all previous items, those returned by `previous()`
      */
     public func removePreviousItems() {
         queueManager.removePreviousItems()
     }
-    
+
     // MARK: - AVPlayerWrapperDelegate
-    
+
     override func AVWrapperItemDidPlayToEndTime() {
-        super.AVWrapperItemDidPlayToEndTime()
         if automaticallyPlayNextSong {
-            try? self.next()
+            try? self.next(canRepeatSingleItem: true)
         }
+
+        super.AVWrapperItemDidPlayToEndTime()
     }
-    
 }