Player for streaming local and remote audio files. Written in Swift.
Clone or download

README.md

Jukebox: audio player in Swift

Swift3 Platform Build Status Version Carthage Compatible License

Jukebox is an iOS audio player written in Swift.

Contents

  1. Features
  2. Installation
  3. Supported OS & SDK versions
  4. Usage
  5. Handling remote events
  6. Public interface
  7. Delegation
  8. License
  9. Contact

## Features

  • Support for streaming both remote and local audio files
  • Support for streaming live audio feeds
  • Functions to play, pause, stop, replay, play next, play previous, control volume and seek to a certain second.
  • Background mode integration with MPNowPlayingInfoCenter

Installation

CocoaPods

CocoaPods is a dependency manager for Cocoa projects.

CocoaPods 0.36 adds supports for Swift and embedded frameworks. You can install it with the following command:

$ gem install cocoapods

To integrate Jukebox into your Xcode project using CocoaPods, specify it in your Podfile:

pod 'Jukebox'

Then, run the following command:

$ pod install

Carthage

Carthage is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.

You can install Carthage with Homebrew using the following command:

$ brew update
$ brew install carthage

To integrate Jukebox into your Xcode project using Carthage, specify it in your Cartfile:

github "teodorpatras/Jukebox"

Run carthage update to build the framework and drag the built Jukebox.framework into your Xcode project.

Manually

If you prefer not to use either of the aforementioned dependency managers, you can integrate Jukebox into your project manually.

## Supported OS & SDK versions

  • iOS 8.0+
  • Xcode 7+

## Usage

Prerequisites

  • In order to support background mode, append the following to your Info.plist:
<key>UIBackgroundModes</key>
<array>
    <string>audio</string>
</array>
  • If you want to stream from http:// URLs, append the following to your Info.plist:
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
        <true/>
</dict>

Getting started

  1. Create an instance of Jukebox:
// configure jukebox
jukebox = Jukebox(delegate: self, items: [
    JukeboxItem(URL: NSURL(string: "http://www.noiseaddicts.com/samples_1w72b820/2514.mp3")!),
    JukeboxItem(URL: NSURL(string: "http://www.noiseaddicts.com/samples_1w72b820/2958.mp3")!)
    ])
  1. Play and enjoy:
jukebox?.play()

## Handling remote events

In order to handle remote events, you should do the following:

  • First, you need to call for receiving remote events:

UIApplication.sharedApplication().beginReceivingRemoteControlEvents()

  • Secondly, override remoteControlReceivedWithEvent(event:):
override func remoteControlReceived(with event: UIEvent?) {
    if event?.type == .remoteControl {
        switch event!.subtype {
        case .remoteControlPlay :
            jukebox.play()
        case .remoteControlPause :
            jukebox.pause()
        case .remoteControlNextTrack :
            jukebox.playNext()
        case .remoteControlPreviousTrack:
            jukebox.playPrevious()
        case .remoteControlTogglePlayPause:
            if jukebox.state == .playing {
               jukebox.pause()
            } else {
                jukebox.play()
            }
        default:
            break
        }
    }
}

##Public interface

##Public methods##

/**
 Starts item playback.
*/
public func play()
    
/**
Plays the item indicated by the passed index
     
 - parameter index: index of the item to be played
*/
public func play(atIndex index: Int)
    
/**
 Pauses the playback.
*/
public func pause()
    
/**
 Stops the playback.
*/
public func stop()
    
/**
 Starts playback from the beginning of the queue.
*/
public func replay()
    
/**
 Plays the next item in the queue.
*/
public func playNext()
    
/**
 Restarts the current item or plays the previous item in the queue
*/
public func playPrevious()
    
/**
 Restarts the playback for the current item
*/
public func replayCurrentItem()
    
/**
 Seeks to a certain second within the current AVPlayerItem and starts playing
     
 - parameter second: the second to seek to
 - parameter shouldPlay: pass true if playback should be resumed after seeking
*/
public func seek(toSecond second: Int, shouldPlay: Bool = false)
    
/**
 Appends and optionally loads an item
     
 - parameter item:            the item to be appended to the play queue
 - parameter loadingAssets:   pass true to load item's assets asynchronously
*/
public func append(item: JukeboxItem, loadingAssets: Bool)

/**
 Removes an item from the play queue
    
 - parameter item: item to be removed
*/
public func remove(item: JukeboxItem)
    
/**
 Removes all items from the play queue matching the URL
     
 - parameter url: the item URL
*/
public func removeItems(withURL url : URL)

##Public properties##

Property Type Description
volume Float volume of the player
currentItem JukeboxItem object encapsulating the meta of the current player item

## Delegation

Jukebox defines a delegate protocol which you can use if you want to be announced when about custom events:

public protocol JukeboxDelegate: class {
    func jukeboxStateDidChange(_ state : Jukebox)
    func jukeboxPlaybackProgressDidChange(_ jukebox : Jukebox)
    func jukeboxDidLoadItem(_ jukebox : Jukebox, item : JukeboxItem)
    func jukeboxDidUpdateMetadata(_ jukebox : Jukebox, forItem: JukeboxItem)
}

## License

Jukebox is released under the MIT license. See the LICENSE file for details.

## Contact

You can follow or drop me a line on my Twitter account. If you find any issues on the project, you can open a ticket. Pull requests are also welcome.