Update podspec.

Bump version to 0.6.2

Example/Tests/AVPlayerWrapperTests.swift

@@ -30,10 +30,6 @@ class AVPlayerWrapperTests: QuickSpec {
                     beforeEach {
                         wrapper.load(from: URL(fileURLWithPath: Source.path), playWhenReady: false)
                     }
-                    
-                    it("should be loading", closure: {
-                        expect(wrapper.state).to(equal(AVPlayerWrapperState.loading))
-                    })
 
                     it("should eventually be ready", closure: {
                         expect(wrapper.state).toEventually(equal(AVPlayerWrapperState.ready))
@@ -128,6 +124,17 @@ class AVPlayerWrapperTests: QuickSpec {
                         expect(wrapper.state).to(equal(AVPlayerWrapperState.idle))
                     })
                 })
+                
+                context("when loading source with initial time", closure: {
+                    let initialTime: TimeInterval = 4.0
+                    beforeEach {
+                        wrapper.load(from: LongSource.url, playWhenReady: true, initialTime: initialTime)
+                    }
+                    
+                    it("should eventually be playing", closure: {
+                        expect(wrapper.state).toEventually(equal(AVPlayerWrapperState.playing))
+                    })
+                })
             })
             
             describe("its duration", {
@@ -163,6 +170,17 @@ class AVPlayerWrapperTests: QuickSpec {
                         expect(wrapper.currentTime).toEventually(equal(seekTime))
                     })
                 })
+                
+                context("when playing from initial time", closure: {
+                    let initialTime: TimeInterval = 4.0
+                    beforeEach {
+                        wrapper.load(from: LongSource.url, playWhenReady: false, initialTime: initialTime)
+                    }
+                    
+                    it("should eventuallt be equal to the initial time", closure: {
+                        expect(wrapper.currentTime).toEventually(equal(initialTime))
+                    })
+                })
             })
             
             describe("its rate", {

Example/Tests/AudioPlayerTests.swift

@@ -106,18 +106,26 @@ class AudioPlayerTests: QuickSpec {
                 })
                 
                 context("when seeking to a time", {
-                    var passed = false
-                    let holder = AudioPlayerDelegateHolder()
-                    let seekTime: TimeInterval = 0.5
+                    let seekTime: TimeInterval = 1.0
                     beforeEach {
-                        audioPlayer.delegate = holder
-                        holder.seekCompletion = { passed = true }
                         try? audioPlayer.load(item: Source.getAudioItem(), playWhenReady: false)
                         audioPlayer.seek(to: seekTime)
                     }
                     
                     it("should eventually be equal to the seeked time", closure: {
-                        expect(passed).toEventually(beTrue())
+                        expect(audioPlayer.currentTime).toEventually(equal(seekTime))
+                    })
+                })
+                
+                context("when playing an item with an initial time", {
+                    var item: DefaultAudioItemInitialTime!
+                    beforeEach {
+                        item = DefaultAudioItemInitialTime(audioUrl: LongSource.path, artist: nil, title: nil, albumTitle: nil, sourceType: .file, artwork: nil, initialTime: 4.0)
+                        try? audioPlayer.load(item: item, playWhenReady: false)
+                    }
+                    
+                    it("should eventaully be equal to the initial time", closure: {
+                        expect(audioPlayer.currentTime).toEventually(equal(item.getInitialTime()))
                     })
                 })
             })

README.md

@@ -23,13 +23,13 @@ SwiftAudio is available through [CocoaPods](http://cocoapods.org). To install
 it, simply add the following line to your Podfile:
 
 ```ruby
-pod 'SwiftAudio', '~> 0.6.1'
+pod 'SwiftAudio', '~> 0.6.2'
 ```
 
 ### Carthage
 SwiftAudio supports [Carthage](https://github.com/Carthage/Carthage). Add this to your Cartfile:
 ```ruby
-github "jorgenhenrichsen/SwiftAudio" ~> 0.6.1
+github "jorgenhenrichsen/SwiftAudio" ~> 0.6.2
 ```
 Then follow the rest of Carthage instructions on [adding a framework](https://github.com/Carthage/Carthage#adding-frameworks-to-an-application).
 
@@ -126,6 +126,9 @@ player.remoteCommandController.handlePlayCommand = { (event) in
 ```
 All available overrides can be found by looking at `RemoteCommandController`.
 
+### Start playback from a certain point in time
+Make your `AudioItem`-subclass conform to `InitialTiming` to be able to start playback from a certain time.
+
 ## Author
 
 Jørgen Henrichsen

SwiftAudio.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'SwiftAudio'
-  s.version          = '0.6.1'
+  s.version          = '0.6.2'
   s.summary          = 'Easy audio streaming for iOS'
 
 # This description is used to generate tags and improve search results.

SwiftAudio/Classes/AVPlayerWrapper/AVPlayerWrapper.swift

@@ -36,6 +36,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
      True if the last call to load(from:playWhenReady) had playWhenReady=true.
      */
     fileprivate var _playWhenReady: Bool = true
+    fileprivate var _initialTime: TimeInterval?
     
     fileprivate var _state: AVPlayerWrapperState = AVPlayerWrapperState.idle {
         didSet {
@@ -147,6 +148,12 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     
     func seek(to seconds: TimeInterval) {
         avPlayer.seek(to: CMTimeMakeWithSeconds(seconds, preferredTimescale: 1000)) { (finished) in
+            if let _ = self._initialTime {
+                self._initialTime = nil
+                if self._playWhenReady {
+                    self.play()
+                }
+            }
             self.delegate?.AVWrapper(seekTo: Int(seconds), didFinish: finished)
         }
     }
@@ -154,7 +161,6 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     func load(from url: URL, playWhenReady: Bool) {
         reset(soft: true)
         _playWhenReady = playWhenReady
-        _state = .loading
 
         // Set item
         let currentAsset = AVURLAsset(url: url)
@@ -169,6 +175,12 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         playerItemObserver.startObserving(item: currentItem)
     }
     
+    func load(from url: URL, playWhenReady: Bool, initialTime: TimeInterval?) {
+        _initialTime = initialTime
+        self.pause()
+        self.load(from: url, playWhenReady: playWhenReady)
+    }
+    
     // MARK: - Util
     
     private func reset(soft: Bool) {
@@ -205,12 +217,17 @@ extension AVPlayerWrapper: AVPlayerObserverDelegate {
     
     func player(statusDidChange status: AVPlayer.Status) {
         switch status {
-
+            
         case .readyToPlay:
             self._state = .ready
-            if _playWhenReady {
+            
+            if let initialTime = _initialTime {
+                self.seek(to: initialTime)
+            }
+            else if _playWhenReady {
                 self.play()
             }
+            
             break
 
         case .failed:

SwiftAudio/Classes/AVPlayerWrapper/AVPlayerWrapperProtocol.swift

@@ -49,4 +49,6 @@ protocol AVPlayerWrapperProtocol {
     
     func load(from url: URL, playWhenReady: Bool)
     
+    func load(from url: URL, playWhenReady: Bool, initialTime: TimeInterval?)
+    
 }

SwiftAudio/Classes/AudioItem.swift

@@ -31,6 +31,11 @@ public protocol TimePitching {
     
 }
 
+/// Make your `AudioItem`-subclass conform to this protocol to control enable the ability to start an item at a specific time of playback.
+public protocol InitialTiming {
+    func getInitialTime() -> TimeInterval
+}
+
 public class DefaultAudioItem: AudioItem {
     
     public var audioUrl: String
@@ -99,3 +104,24 @@ public class DefaultAudioItemTimePitching: DefaultAudioItem, TimePitching {
         return pitchAlgorithmType
     }
 }
+
+/// 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?) {
+        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
+    }
+    
+}

SwiftAudio/Classes/AudioPlayer.swift

@@ -156,19 +156,23 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
      - 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`.
      */
     public func load(item: AudioItem, playWhenReady: Bool = true) throws {
-        print("Loading: \(item)")
+        let url: URL
         switch item.getSourceType() {
         case .stream:
-            if let url = URL(string: item.getSourceUrl()) {
-                wrapper.load(from: url, playWhenReady: playWhenReady)
+            if let itemUrl = URL(string: item.getSourceUrl()) {
+                url = itemUrl
             }
             else {
                 throw APError.LoadError.invalidSourceUrl(item.getSourceUrl())
             }
         case .file:
-            wrapper.load(from: URL(fileURLWithPath: item.getSourceUrl()), playWhenReady: playWhenReady)
+            url = URL(fileURLWithPath: item.getSourceUrl())
         }
         
+        wrapper.load(from: url,
+                     playWhenReady: playWhenReady,
+                     initialTime: (item as? InitialTiming)?.getInitialTime())
+        
         if let item = item as? TimePitching {
             wrapper.currentItem?.audioTimePitchAlgorithm = item.getPitchAlgorithmType()
         }