FreeStreamer meta data example in Swift (stripped out of shipped code)

PlayerViewController.swift

import Foundation
import AVFoundation

// My app doesn't use meta data, so you're on your own with the following code.

public class PlayerViewController: UIViewController, FSPCMAudioStreamDelegate {

    private var _cachedAudioController: FSAudioController?
    private var _audioController: FSAudioController! {
        get {
            if self._cachedAudioController != nil {
                return self._cachedAudioController
            } else {
                self._cachedAudioController = FSAudioController()
                self._enableEventHandlersForStream(self._cachedAudioController!.stream)
                return _cachedAudioController
            }
        }
        set(newValue) {
            if newValue != nil {
                self._cachedAudioController = newValue
                self._enableEventHandlersForStream(self._cachedAudioController!.stream)
            } else {
                self._cachedAudioController = nil
            }
        }
    }


    private func _enableEventHandlersForStream(stream: FSAudioStream) {
        stream.onStateChange = self._streamStateChangeHandler()
        stream.onFailure = self._streamFailureHandler()
        stream.onMetaDataAvailable = self._streamMetaDataAvailableHandler()
    }


    private func _streamStateChangeHandler() -> (FSAudioStreamState) -> Void {
        return { state in
            switch state.value {
            case kFsAudioStreamRetrievingURL.value:
                    // Removed code to keep it short
                break
            case kFsAudioStreamBuffering.value:
                break
            case kFsAudioStreamSeeking.value:
                break
            case kFsAudioStreamPlaying.value:
                break
            case kFsAudioStreamPlaybackCompleted.value:
                break
            case kFsAudioStreamPaused.value:
                break
            case kFsAudioStreamStopped.value:
                break
            case kFsAudioStreamFailed.value:
                break
            default:
                break
            }
        }
    }


    private func _streamFailureHandler() -> (FSAudioStreamError, String!) -> Void {
        return { error, errorDescription in
            var errorCategory: String!
            switch error.value {
            case kFsAudioStreamErrorOpen.value:
                errorCategory = "Cannot open the audio stream: "
                break
            case kFsAudioStreamErrorStreamParse.value:
                errorCategory = "Cannot read the audio stream: "
                break
            case kFsAudioStreamErrorNetwork.value:
                errorCategory = "Network failed: cannot play the audio stream: "
                break
            case kFsAudioStreamErrorUnsupportedFormat.value:
                errorCategory = "Unsupported format: "
                break
            case kFsAudioStreamErrorStreamBouncing.value:
                errorCategory = "Network failed. cannot get enough data to play: "
                break
            default:
                errorCategory = "Unknown error occurred: "
                break
            }
            let formattedError = String(format: "%@ %@", errorCategory, errorDescription)
            self.statusLabel.text = formattedError
            self.stop()
        }
    }


    private func _streamMetaDataAvailableHandler() -> ([NSObject : AnyObject]!) -> Void {
        return { metaData in
            var streamInfo: String = ""
        
            if self.selectedPlaylistItem != nil && self.selectedPlaylistItem.title != nil {
                streamInfo = String(format: "Now Playing %@", self.selectedPlaylistItem.title)
            }
        
            self._determineAudioNameWithMetaData(metaData)

            var nowPlayingInfo: [NSObject : AnyObject] = [:]
            if contains(metaData.keys, "MPMediaItemPropertyTitle") {
                nowPlayingInfo[MPMediaItemPropertyTitle] = metaData["MPMediaItemPropertyTitle"]
            } else if contains(metaData.keys, "StreamTitle") {
                nowPlayingInfo[MPMediaItemPropertyTitle] = metaData["StreamTitle"]
            }
            if contains(metaData.keys, "MPMediaItemPropertyArtist") {
                nowPlayingInfo[MPMediaItemPropertyArtist] = metaData["MPMediaItemPropertyArtist"]
            }
        
            MPNowPlayingInfoCenter.defaultCenter().nowPlayingInfo = nowPlayingInfo
        
            if contains(metaData.keys, "MPMediaItemPropertyTitle") && contains(metaData.keys, "MPMediaItemPropertyArtist") {
                streamInfo += metaData["MPMediaItemPropertyArtist"] as String
                streamInfo += " - "
                streamInfo += metaData["MPMediaItemPropertyTitle"] as String
            } else if contains(metaData.keys, "StreamTitle") {
                streamInfo = metaData["StreamTitle"] as String
            }

            if contains(metaData.keys, "StreamUrl") && countElements(metaData["StreamUrl"] as String) > 0 {
                self._streamURL = NSURL(string: metaData["StreamUrl"] as String)
            }
        
            self.statusLabel.text = streamInfo
        }
    }


    private func _determineAudioNameWithMetaData(metaData: [NSObject : AnyObject]) {
        if contains(metaData.keys, "IcecastStationName") && countElements(metaData["IcecastStationName"] as String) > 0 {
            self.title = metaData["IcecastStationName"] as String!
        } else {
            let playlistItem = self._audioController.currentPlaylistItem
        
            if playlistItem != nil && playlistItem.title != nil && countElements(playlistItem.title) > 0 {
                self.title = playlistItem.title
            } else {
                // The last resort.
                // Use the URL as the title, if available.
                if contains(metaData.keys, "StreamUrl") && countElements(metaData["StreamUrl"] as String) > 0 {
                    self.title = metaData["StreamUrl"] as String!
                }
            }
        }
    }
    
}