/*

    File: MainViewController.m

Abstract: View controller class for AddMusic. Sets up user interface, responds 

to and manages user interaction.

 Version: 1.1

Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple

Inc. ("Apple") in consideration of your agreement to the following

terms, and your use, installation, modification or redistribution of

this Apple software constitutes acceptance of these terms.  If you do

not agree with these terms, please do not use, install, modify or

redistribute this Apple software.

In consideration of your agreement to abide by the following terms, and

subject to these terms, Apple grants you a personal, non-exclusive

license, under Apple's copyrights in this original Apple software (the

"Apple Software"), to use, reproduce, modify and redistribute the Apple

Software, with or without modifications, in source and/or binary forms;

provided that if you redistribute the Apple Software in its entirety and

without modifications, you must retain this notice and the following

text and disclaimers in all such redistributions of the Apple Software.

Neither the name, trademarks, service marks or logos of Apple Inc. may

be used to endorse or promote products derived from the Apple Software

without specific prior written permission from Apple.  Except as

expressly stated in this notice, no other rights or licenses, express or

implied, are granted by Apple herein, including but not limited to any

patent rights that may be infringed by your derivative works or by other

works in which the Apple Software may be incorporated.

The Apple Software is provided by Apple on an "AS IS" basis.  APPLE

MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION

THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND

OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.

IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL

OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,

MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED

AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),

STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

Copyright (C) 2009 Apple Inc. All Rights Reserved.

*/

#import "MainViewController.h"

#import <Foundation/Foundation.h>

#pragma mark Audio session callbacks_______________________

// Audio session callback function for responding to audio route changes. If playing 

//      back application audio when the headset is unplugged, this callback pauses 

//      playback and displays an alert that allows the user to resume or stop playback.

//

//      The system takes care of iPod audio pausing during route changes--this callback  

//      is not involved with pausing playback of iPod audio.

void audioRouteChangeListenerCallback (

   void                      *inUserData,

   AudioSessionPropertyID    inPropertyID,

   UInt32                    inPropertyValueSize,

   const void                *inPropertyValue

) {

    // ensure that this callback was invoked for a route change

    if (inPropertyID != kAudioSessionProperty_AudioRouteChange) return;

    // This callback, being outside the implementation block, needs a reference to the

    //      MainViewController object, which it receives in the inUserData parameter.

    //      You provide this reference when registering this callback (see the call to 

    //      AudioSessionAddPropertyListener).

    MainViewController *controller = (MainViewController *) inUserData;

    // if application sound is not playing, there's nothing to do, so return.

    if (controller.appSoundPlayer.playing == 0 ) {

        NSLog (@"Audio route change while application audio is stopped.");

        return;

    } else {

        // Determines the reason for the route change, to ensure that it is not

        //      because of a category change.

        CFDictionaryRef routeChangeDictionary = inPropertyValue;

        CFNumberRef routeChangeReasonRef =

                        CFDictionaryGetValue (

                            routeChangeDictionary,

                            CFSTR (kAudioSession_AudioRouteChangeKey_Reason)

                        );

        SInt32 routeChangeReason;

        CFNumberGetValue (

            routeChangeReasonRef,

            kCFNumberSInt32Type,

            &routeChangeReason

        );

        // "Old device unavailable" indicates that a headset was unplugged, or that the

        //  device was removed from a dock connector that supports audio output. This is

        //  the recommended test for when to pause audio.

        if (routeChangeReason == kAudioSessionRouteChangeReason_OldDeviceUnavailable) {

            [controller.appSoundPlayer pause];

            NSLog (@"Output device removed, so application audio was paused.");

            UIAlertView *routeChangeAlertView = 

                    [[UIAlertView alloc]    initWithTitle: NSLocalizedString (@"Playback Paused", @"Title for audio hardware route-changed alert view")

                                                  message: NSLocalizedString (@"Audio output was changed", @"Explanation for route-changed alert view")

                                                 delegate: controller

                                        cancelButtonTitle: NSLocalizedString (@"StopPlaybackAfterRouteChange", @"Stop button title")

                                        otherButtonTitles: NSLocalizedString (@"ResumePlaybackAfterRouteChange", @"Play button title"), nil];

            [routeChangeAlertView show];

            // release takes place in alertView:clickedButtonAtIndex: method

        } else {

            NSLog (@"A route change occurred that does not require pausing of application audio.");

        }

    }

}

@implementation MainViewController

@synthesize artworkItem;                // the now-playing media item's artwork image, displayed in the Navigation bar

@synthesize userMediaItemCollection;    // the media item collection created by the user, using the media item picker   

@synthesize playBarButton;              // the button for invoking Play on the music player

@synthesize pauseBarButton;             // the button for invoking Pause on the music player

@synthesize musicPlayer;                // the music player, which plays media items from the iPod library

@synthesize navigationBar;              // the application's Navigation bar

@synthesize noArtworkImage;             // an image to display when a media item has no associated artwork

@synthesize backgroundColorTimer;       // a timer for changing the background color -- represents an application that is

                                        //      doing something else while iPod music is playing

@synthesize nowPlayingLabel;            // descriptive text shown on the main screen about the now-playing media item

@synthesize appSoundButton;             // the button to invoke playback for the application sound

@synthesize addOrShowMusicButton;       // the button for invoking the media item picker. if the user has already 

                                        //      specified a media item collection, the title changes to "Show Music" and

                                        //      the button invokes a table view that shows the specified collection

@synthesize appSoundPlayer;             // An AVAudioPlayer object for playing application sound

@synthesize soundFileURL;               // The path to the application sound

@synthesize interruptedOnPlayback;      // A flag indicating whether or not the application was interrupted during 

                                        //      application audio playback

@synthesize playedMusicOnce;            // A flag indicating if the user has played iPod library music at least one time

                                        //      since application launch.

@synthesize playing;                    // An application that responds to interruptions must keep track of its playing/

                                        //      not-playing state.

#pragma mark Music control________________________________

// A toggle control for playing or pausing iPod library music playback, invoked

//      when the user taps the 'playBarButton' in the Navigation bar. 

- (IBAction) playOrPauseMusic: (id)sender {

    MPMusicPlaybackState playbackState = [musicPlayer playbackState];

    if (playbackState == MPMusicPlaybackStateStopped || playbackState == MPMusicPlaybackStatePaused) {

        [musicPlayer play];

    } else if (playbackState == MPMusicPlaybackStatePlaying) {

        [musicPlayer pause];

    }

}

// If there is no selected media item collection, display the media item picker. If there's 

// already a selected collection, display the list of selected songs.

- (IBAction) AddMusicOrShowMusic: (id) sender {    

    // if the user has already chosen some music, display that list

    if (userMediaItemCollection) {

        MusicTableViewController *controller = [[MusicTableViewController alloc] initWithNibName: @"MusicTableView" bundle: nil];

        controller.delegate = self;

        controller.modalTransitionStyle = UIModalTransitionStyleCoverVertical;

        [self presentModalViewController: controller animated: YES];

        [controller release];

    // else, if no music is chosen yet, display the media item picker

    } else {

        MPMediaPickerController *picker =

            [[MPMediaPickerController alloc] initWithMediaTypes: MPMediaTypeMusic];

        picker.delegate                     = self;

        picker.allowsPickingMultipleItems   = YES;

        picker.prompt                       = NSLocalizedString (@"Add songs to play", "Prompt in media item picker");

        // The media item picker uses the default UI style, so it needs a default-style

        //      status bar to match it visually

        [[UIApplication sharedApplication] setStatusBarStyle: UIStatusBarStyleDefault animated: YES];

        [self presentModalViewController: picker animated: YES];

        [picker release];

    }

}

// Invoked by the delegate of the media item picker when the user is finished picking music.

//      The delegate is either this class or the table view controller, depending on the 

//      state of the application.

- (void) updatePlayerQueueWithMediaCollection: (MPMediaItemCollection *) mediaItemCollection {

    // Configure the music player, but only if the user chose at least one song to play

    if (mediaItemCollection) {

        // If there's no playback queue yet...

        if (userMediaItemCollection == nil) {

            // apply the new media item collection as a playback queue for the music player

            [self setUserMediaItemCollection: mediaItemCollection];

            [musicPlayer setQueueWithItemCollection: userMediaItemCollection];

            [self setPlayedMusicOnce: YES];

            [musicPlayer play];

        // Obtain the music player's state so it can then be

        //      restored after updating the playback queue.

        } else {

            // Take note of whether or not the music player is playing. If it is

            //      it needs to be started again at the end of this method.

            BOOL wasPlaying = NO;

            if (musicPlayer.playbackState == MPMusicPlaybackStatePlaying) {

                wasPlaying = YES;

            }

            // Save the now-playing item and its current playback time.

            MPMediaItem *nowPlayingItem         = musicPlayer.nowPlayingItem;

            NSTimeInterval currentPlaybackTime  = musicPlayer.currentPlaybackTime;

            // Combine the previously-existing media item collection with the new one

            NSMutableArray *combinedMediaItems  = [[userMediaItemCollection items] mutableCopy];

            NSArray *newMediaItems              = [mediaItemCollection items];

            [combinedMediaItems addObjectsFromArray: newMediaItems];

            [self setUserMediaItemCollection: [MPMediaItemCollection collectionWithItems: (NSArray *) combinedMediaItems]];

            [combinedMediaItems release];

            // Apply the new media item collection as a playback queue for the music player.

            [musicPlayer setQueueWithItemCollection: userMediaItemCollection];

            // Restore the now-playing item and its current playback time.

            musicPlayer.nowPlayingItem          = nowPlayingItem;

            musicPlayer.currentPlaybackTime     = currentPlaybackTime;

            // If the music player was playing, get it playing again.

            if (wasPlaying) {

                [musicPlayer play];

            }

        }

        // Finally, because the music player now has a playback queue, ensure that 

        //      the music play/pause button in the Navigation bar is enabled.

        navigationBar.topItem.leftBarButtonItem.enabled = YES;

        [addOrShowMusicButton   setTitle: NSLocalizedString (@"Show Music", @"Alternate title for 'Add Music' button, after user has chosen some music")

                                forState: UIControlStateNormal];

    }

}

// If the music player was paused, leave it paused. If it was playing, it will continue to

//      play on its own. The music player state is "stopped" only if the previous list of songs

//      had finished or if this is the first time the user has chosen songs after app 

//      launch--in which case, invoke play.

- (void) restorePlaybackState {

    if (musicPlayer.playbackState == MPMusicPlaybackStateStopped && userMediaItemCollection) {

        [addOrShowMusicButton   setTitle: NSLocalizedString (@"Show Music", @"Alternate title for 'Add Music' button, after user has chosen some music")

                                forState: UIControlStateNormal];

        if (playedMusicOnce == NO) {

            [self setPlayedMusicOnce: YES];

            [musicPlayer play];

        }

    }

}

#pragma mark Media item picker delegate methods________

// Invoked when the user taps the Done button in the media item picker after having chosen

//      one or more media items to play.

- (void) mediaPicker: (MPMediaPickerController *) mediaPicker didPickMediaItems: (MPMediaItemCollection *) mediaItemCollection {

    // Dismiss the media item picker.

    [self dismissModalViewControllerAnimated: YES];

    // Apply the chosen songs to the music player's queue.

    [self updatePlayerQueueWithMediaCollection: mediaItemCollection];

    [[UIApplication sharedApplication] setStatusBarStyle: UIStatusBarStyleBlackOpaque animated: YES];

}

// Invoked when the user taps the Done button in the media item picker having chosen zero

//      media items to play

- (void) mediaPickerDidCancel: (MPMediaPickerController *) mediaPicker {

    [self dismissModalViewControllerAnimated: YES];

    [[UIApplication sharedApplication] setStatusBarStyle: UIStatusBarStyleBlackOpaque animated: YES];

}

#pragma mark Music notification handlers__________________

// When the now-playing item changes, update the media item artwork and the now-playing label.

- (void) handle_NowPlayingItemChanged: (id) notification {

    MPMediaItem *currentItem = [musicPlayer nowPlayingItem];

    // Assume that there is no artwork for the media item.

    UIImage *artworkImage = noArtworkImage;

    // Get the artwork from the current media item, if it has artwork.

    MPMediaItemArtwork *artwork = [currentItem valueForProperty: MPMediaItemPropertyArtwork];

    // Obtain a UIImage object from the MPMediaItemArtwork object

    if (artwork) {

        artworkImage = [artwork imageWithSize: CGSizeMake (30, 30)];

    }

    // Obtain a UIButton object and set its background to the UIImage object

    UIButton *artworkView = [[UIButton alloc] initWithFrame: CGRectMake (0, 0, 30, 30)];

    [artworkView setBackgroundImage: artworkImage forState: UIControlStateNormal];

    // Obtain a UIBarButtonItem object and initialize it with the UIButton object

    UIBarButtonItem *newArtworkItem = [[UIBarButtonItem alloc] initWithCustomView: artworkView];

    [self setArtworkItem: newArtworkItem];

    [newArtworkItem release];

    [artworkItem setEnabled: NO];

    // Display the new media item artwork

    [navigationBar.topItem setRightBarButtonItem: artworkItem animated: YES];

    // Display the artist and song name for the now-playing media item

    [nowPlayingLabel setText: [

            NSString stringWithFormat: @"%@ %@ %@ %@",

            NSLocalizedString (@"Now Playing:", @"Label for introducing the now-playing song title and artist"),

            [currentItem valueForProperty: MPMediaItemPropertyTitle],

            NSLocalizedString (@"by", @"Article between song name and artist name"),

            [currentItem valueForProperty: MPMediaItemPropertyArtist]]];

    if (musicPlayer.playbackState == MPMusicPlaybackStateStopped) {

        // Provide a suitable prompt to the user now that their chosen music has 

        //      finished playing.

        [nowPlayingLabel setText: [

                NSString stringWithFormat: @"%@",

                NSLocalizedString (@"Music-ended Instructions", @"Label for prompting user to play music again after it has stopped")]];

    }

}

// When the playback state changes, set the play/pause button in the Navigation bar

//      appropriately.

- (void) handle_PlaybackStateChanged: (id) notification {

    MPMusicPlaybackState playbackState = [musicPlayer playbackState];

    if (playbackState == MPMusicPlaybackStatePaused) {

        navigationBar.topItem.leftBarButtonItem = playBarButton;

    } else if (playbackState == MPMusicPlaybackStatePlaying) {

        navigationBar.topItem.leftBarButtonItem = pauseBarButton;

    } else if (playbackState == MPMusicPlaybackStateStopped) {

        navigationBar.topItem.leftBarButtonItem = playBarButton;

        // Even though stopped, invoking 'stop' ensures that the music player will play  

        //      its queue from the start.

        [musicPlayer stop];

    }

}

- (void) handle_iPodLibraryChanged: (id) notification {

    // Implement this method to update cached collections of media items when the 

    // user performs a sync while your application is running. This sample performs 

    // no explicit media queries, so there is nothing to update.

}

#pragma mark Application playback control_________________

- (IBAction) playAppSound: (id) sender {

    [appSoundPlayer play];

    playing = YES;

    [appSoundButton setEnabled: NO];

}

// delegate method for the audio route change alert view; follows the protocol specified

//  in the UIAlertViewDelegate protocol.

- (void) alertView: routeChangeAlertView clickedButtonAtIndex: buttonIndex {

    if ((NSInteger) buttonIndex == 1) {

        [appSoundPlayer play];

    } else {

        [appSoundPlayer setCurrentTime: 0];

        [appSoundButton setEnabled: YES];

    }

    [routeChangeAlertView release];         

}

#pragma mark AV Foundation delegate methods____________

- (void) audioPlayerDidFinishPlaying: (AVAudioPlayer *) appSoundPlayer successfully: (BOOL) flag {

    playing = NO;

    [appSoundButton setEnabled: YES];

}

- (void) audioPlayerBeginInterruption: player {

    NSLog (@"Interrupted. The system has paused audio playback.");

    if (playing) {

        playing = NO;

        interruptedOnPlayback = YES;

    }

}

- (void) audioPlayerEndInterruption: player {

    NSLog (@"Interruption ended. Resuming audio playback.");

    // Reactivates the audio session, whether or not audio was playing

    //      when the interruption arrived.

    [[AVAudioSession sharedInstance] setActive: YES error: nil];

    if (interruptedOnPlayback) {

        [appSoundPlayer prepareToPlay];

        [appSoundPlayer play];

        playing = YES;

        interruptedOnPlayback = NO;

    }

}

#pragma mark Table view delegate methods________________

// Invoked when the user taps the Done button in the table view.

- (void) musicTableViewControllerDidFinish: (MusicTableViewController *) controller {

    [self dismissModalViewControllerAnimated: YES];

    [self restorePlaybackState];

}

#pragma mark Application setup____________________________

#if TARGET_IPHONE_SIMULATOR

#warning *** Simulator mode: iPod library access works only when running on a device.

#endif

- (void) setupApplicationAudio {

    // Gets the file system path to the sound to play.

    NSString *soundFilePath = [[NSBundle mainBundle]    pathForResource:    @"sound"

                                                        ofType:             @"caf"];

    // Converts the sound's file path to an NSURL object

    NSURL *newURL = [[NSURL alloc] initFileURLWithPath: soundFilePath];

    self.soundFileURL = newURL;

    [newURL release];

    // Registers this class as the delegate of the audio session.

    [[AVAudioSession sharedInstance] setDelegate: self];

    // The AmbientSound category allows application audio to mix with Media Player

    // audio. The category also indicates that application audio should stop playing 

    // if the Ring/Siilent switch is set to "silent" or the screen locks.

    [[AVAudioSession sharedInstance] setCategory: AVAudioSessionCategoryAmbient error: nil];

/*

    // Use this code instead to allow the app sound to continue to play when the screen is locked.

    [[AVAudioSession sharedInstance] setCategory: AVAudioSessionCategoryPlayback error: nil];

    UInt32 doSetProperty = 0;

    AudioSessionSetProperty (

        kAudioSessionProperty_OverrideCategoryMixWithOthers,

        sizeof (doSetProperty),

        &doSetProperty

    );

*/

    // Registers the audio route change listener callback function

    AudioSessionAddPropertyListener (

        kAudioSessionProperty_AudioRouteChange,

        audioRouteChangeListenerCallback,

        self

    );

    // Activates the audio session.

    NSError *activationError = nil;

    [[AVAudioSession sharedInstance] setActive: YES error: &activationError];

    // Instantiates the AVAudioPlayer object, initializing it with the sound

    AVAudioPlayer *newPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL: soundFileURL error: nil];

    self.appSoundPlayer = newPlayer;

    [newPlayer release];

    // "Preparing to play" attaches to the audio hardware and ensures that playback

    //      starts quickly when the user taps Play

    [appSoundPlayer prepareToPlay];

    [appSoundPlayer setVolume: 1.0];

    [appSoundPlayer setDelegate: self];

}

// To learn about notifications, see "Notifications" in Cocoa Fundamentals Guide.

- (void) registerForMediaPlayerNotifications {

    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];

    [notificationCenter addObserver: self

                           selector: @selector (handle_NowPlayingItemChanged:)

                               name: MPMusicPlayerControllerNowPlayingItemDidChangeNotification

                             object: musicPlayer];

    [notificationCenter addObserver: self

                           selector: @selector (handle_PlaybackStateChanged:)

                               name: MPMusicPlayerControllerPlaybackStateDidChangeNotification

                             object: musicPlayer];

/*

    // This sample doesn't use libray change notifications; this code is here to show how

    //      it's done if you need it.

    [notificationCenter addObserver: self

                           selector: @selector (handle_iPodLibraryChanged:)

                               name: MPMediaLibraryDidChangeNotification

                             object: musicPlayer];

    [[MPMediaLibrary defaultMediaLibrary] beginGeneratingLibraryChangeNotifications];

*/

    [musicPlayer beginGeneratingPlaybackNotifications];

}

// To learn about the Settings bundle and user preferences, see User Defaults Programming Topics

//      for Cocoa and "The Settings Bundle" in iPhone Application Programming Guide 

// Returns whether or not to use the iPod music player instead of the application music player.

- (BOOL) useiPodPlayer {

    if ([[NSUserDefaults standardUserDefaults] boolForKey: PLAYER_TYPE_PREF_KEY]) {

        return YES;     

    } else {

        return NO;

    }       

}

// Configure the application.

- (void) viewDidLoad {

    [super viewDidLoad];

    [self setupApplicationAudio];

    [self setPlayedMusicOnce: NO];

    [self setNoArtworkImage:    [UIImage imageNamed: @"no_artwork.png"]];       

    [self setPlayBarButton:     [[UIBarButtonItem alloc]    initWithBarButtonSystemItem: UIBarButtonSystemItemPlay

                                                                                 target: self

                                                                                 action: @selector (playOrPauseMusic:)]];

    [self setPauseBarButton:    [[UIBarButtonItem alloc]    initWithBarButtonSystemItem: UIBarButtonSystemItemPause

                                                                                 target: self

                                                                                 action: @selector (playOrPauseMusic:)]];

    [addOrShowMusicButton   setTitle: NSLocalizedString (@"Add Music", @"Title for 'Add Music' button, before user has chosen some music")

                            forState: UIControlStateNormal];

    [appSoundButton         setTitle: NSLocalizedString (@"Play App Sound", @"Title for 'Play App Sound' button")

                            forState: UIControlStateNormal];

    [nowPlayingLabel setText: NSLocalizedString (@"Instructions", @"Brief instructions to user, shown at launch")];

    // Instantiate the music player. If you specied the iPod music player in the Settings app,

    //      honor the current state of the built-in iPod app.

    if ([self useiPodPlayer]) {

        [self setMusicPlayer: [MPMusicPlayerController iPodMusicPlayer]];

        if ([musicPlayer nowPlayingItem]) {

            navigationBar.topItem.leftBarButtonItem.enabled = YES;

            // Update the UI to reflect the now-playing item. 

            [self handle_NowPlayingItemChanged: nil];

            if ([musicPlayer playbackState] == MPMusicPlaybackStatePaused) {

                navigationBar.topItem.leftBarButtonItem = playBarButton;

            }

        }

    } else {

        [self setMusicPlayer: [MPMusicPlayerController applicationMusicPlayer]];

        // By default, an application music player takes on the shuffle and repeat modes

        //      of the built-in iPod app. Here they are both turned off.

        [musicPlayer setShuffleMode: MPMusicShuffleModeOff];

        [musicPlayer setRepeatMode: MPMusicRepeatModeNone];

    }   

    [self registerForMediaPlayerNotifications];

    // Configure a timer to change the background color. The changing color represents an 

    //      application that is doing something else while iPod music is playing.

    [self setBackgroundColorTimer: [NSTimer scheduledTimerWithTimeInterval: 3.5

                                                                    target: self

                                                                  selector: @selector (updateBackgroundColor)

                                                                  userInfo: nil

                                                                   repeats: YES]];

}

// Invoked by the backgroundColorTimer.

- (void) updateBackgroundColor {

    [UIView beginAnimations: nil context: nil];

    [UIView setAnimationDuration: 3.0];

    CGFloat redLevel    = rand() / (float) RAND_MAX;

    CGFloat greenLevel  = rand() / (float) RAND_MAX;

    CGFloat blueLevel   = rand() / (float) RAND_MAX;

    self.view.backgroundColor = [UIColor colorWithRed: redLevel

                                                green: greenLevel

                                                 blue: blueLevel

                                                alpha: 1.0];

    [UIView commitAnimations];

}

#pragma mark Application state management_____________

- (void) didReceiveMemoryWarning {

    // Releases the view if it doesn't have a superview.

    [super didReceiveMemoryWarning];

    // Release any cached data, images, etc that aren't in use.

}

- (void) viewDidUnload {

    // Release any retained subviews of the main view.

    // e.g. self.myOutlet = nil;

}

- (void)dealloc {

/*

    // This sample doesn't use libray change notifications; this code is here to show how

    //      it's done if you need it.

    [[NSNotificationCenter defaultCenter] removeObserver: self

                                                    name: MPMediaLibraryDidChangeNotification

                                                  object: musicPlayer];

    [[MPMediaLibrary defaultMediaLibrary] endGeneratingLibraryChangeNotifications];

*/

    [[NSNotificationCenter defaultCenter] removeObserver: self

                                                    name: MPMusicPlayerControllerNowPlayingItemDidChangeNotification

                                                  object: musicPlayer];

    [[NSNotificationCenter defaultCenter] removeObserver: self

                                                    name: MPMusicPlayerControllerPlaybackStateDidChangeNotification

                                                  object: musicPlayer];

    [musicPlayer endGeneratingPlaybackNotifications];

    [musicPlayer                release];

    [artworkItem                release]; 

    [backgroundColorTimer       invalidate];

    [backgroundColorTimer       release];

    [navigationBar              release];

    [noArtworkImage             release];

    [nowPlayingLabel            release];

    [pauseBarButton             release];

    [playBarButton              release];

    [soundFileURL               release];

    [userMediaItemCollection    release];

    [super dealloc];

}

@end