CocoaTouch

Previously I have written a blog post about doing simple animations with UIViews, which you can find here. Starting in iOS 4.0 you can now do this with blocks.

Blocks have two major benefits (although there are more):

• They can be used in conjunction with Grand Central Dispatch (GCD), as an alternative to threading.
• They can be used for callbacks, instead of NSNotifications, callback selectors, function pointers etc. This is usually done by providing a callback/completion block, and this is what we will be looking at here.

The most common method that you will use to animate views using blocks, is the following class method on UIView:

+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion;

This method allows you to set a time interval, along with an animations block and a completion block.

Lets say we have a UIView variable called redView.

redView = [[UIView alloc] initWithFrame:CGRectMake(0,0,320,320)];
redView.backgroundColor = [UIColor redColor];

We will then add redView as a subview of the view controller’s view

[self.view addSubview:redView];

A common situation you may find your self in, is when you finish animating a view (e.g. changing its alpha), you would then want to remove it from it’s superview, and then release it from memory.

So if you had (for example) a method called animate to trigger off the animation, you would need to add an “animation did stop selector” to the animation. In the following example I have called it cleanUp.

- (void)animate{
 
   [UIView beginAnimations:@"" context:NULL];
   [UIView setAnimationDuration:5.0];
   [UIView setAnimationDidStopSelector:@selector(cleanUp)];
   [redView setAlpha:0.0];
   [UIView commitAnimations];
 
}
 
- (void)cleanUp{
 
    [redView removeFromSuperview];
    //I do release and = nil on the same line as a coding convention
    //so I don't forget to "nil" the variable
    [redView release], redView = nil;	
}

Although this works well enough, it does mean that your code is split up into the animation code and the (completion) clean up code. If you end up doing this a lot, your code can end up becoming very fragmented and hard to follow.

Using blocks we can do the following:

- (void)animate{
 
[UIView animateWithDuration:5.0
 
                            animations:^{ 
	                          redView.alpha = 0.0; 
	                     }
 
                           completion:^(BOOL  completed){
	                          [redView removeFromSuperview];
                                  [redView release],redView = nil;
	                    }
 ];
 
 
}

This keeps things nice and simple, and it means that you can easily see what code will be executed when the animation completes.

All of the animations you wish to do are passed in using a block:

 
^{ 
redView.alpha = 0.0; 
}

This block takes no arguments, and it also does not have a return type (so it defaults to void).

Instead of calling the cleanUp selector, we can simply pass in a completion block:

 
^(BOOL  completed){
[redView removeFromSuperview];
[redView release],redView = nil;
}

This block takes one parameter, which is a bool signifying if the animation has completed when the block is executed. In this example we ignore the completed variable, and we assume that the animation has completed for simplicity reasons. In the body of the block we do same as we did in the cleanUp selector, we remove redView from its super view and then release it from memory.

In some situations you won’t need to use blocks for Core Animation, but when you do, you will find it cleans up your code no end.

One question I keep hearing is “Can you find out what music track a user is listening to? as I want to use it for …”, where the reason usually revolves around posting it to a social network network site, or using it as IM status. Thankfully retrieving the currently being played music track is very easy thanks to the MediaPlayer Framework.

Each application has its own MPMusicPlayerController, but it also has access to the iPod’s MPMusicPlayerController, using the class method iPodMusicPlayer.

MPMusicPlayerController *iPodMusicPlayerController = [MPMusicPlayerController iPodMusicPlayer];

After you have got the iPod music player, you can then get the now playing item

MPMediaItem *nowPlayingItem = [iPodMusicPlayerController nowPlayingItem];

If the now playing item is nil, you know that the user is not playing a music track on their iPod.

Unlike many of the other APIs in iOS, you can’t access information such as the track name, via a simple string property. You have to use one of the following keys:

NSString *const MPMediaItemPropertyPersistentID;
NSString *const MPMediaItemPropertyMediaType; 
NSString *const MPMediaItemPropertyTitle;
NSString *const MPMediaItemPropertyAlbumTitle; 
NSString *const MPMediaItemPropertyArtist; 
NSString *const MPMediaItemPropertyAlbumArtist; 
NSString *const MPMediaItemPropertyGenre;
NSString *const MPMediaItemPropertyComposer; 
NSString *const MPMediaItemPropertyPlaybackDuration;
NSString *const MPMediaItemPropertyAlbumTrackNumber;
NSString *const MPMediaItemPropertyAlbumTrackCount;
NSString *const MPMediaItemPropertyDiscNumber;
NSString *const MPMediaItemPropertyDiscCount;
NSString *const MPMediaItemPropertyArtwork;
NSString *const MPMediaItemPropertyLyrics;
NSString *const MPMediaItemPropertyIsCompilation;  
NSString *const MPMediaItemPropertyReleaseDate;
NSString *const MPMediaItemPropertyBeatsPerMinute;
NSString *const MPMediaItemPropertyComments;
NSString *const MPMediaItemPropertyAssetURL;

And then query the Media Player Item, using the instance method valueForProperty:.

NSString *itemTitle = [nowPlayingItem valueForProperty:MPMediaItemPropertyTitle];

And thus you will end up with a code snippet like this:

MPMusicPlayerController *iPodMusicPlayerController = [MPMusicPlayerController iPodMusicPlayer];
 
MPMediaItem *nowPlayingItem = [iPodMusicPlayerController nowPlayingItem];	
 
if(nowPlayingItem)
{
    NSString *itemTitle = [nowPlayingItem valueForProperty:MPMediaItemPropertyTitle];
    NSLog(@"User is playing the following song: %@",itemTitle);
}else {
    NSLog(@"User is not playing a song");
}

As always this is just a small code snippet to get you started. There are situations for instance, where the user can have a now playing item that has no title (strange I know). So as always you will have to handle these edge cases appropriately.

Although for complex animation sequences on the iPhone you need to use either the OpenGL or Apple’s very own Core Animation Framework, a lot of simple animations can be achieved with the methods found in the UIView class. All these animations are actually built upon Core Animation, but they have been wrapped up for you to use with very little code.

All animations triggered by the UIView class happen within a animation block.

To start an animation block you use the UIView Class method:

+ (void)beginAnimations:(NSString *)animationID context:(void *)context;


The animation ID is used in delegate call backs for such things as the beginning and end of animation blocks. The context is an additional piece of information that can be passed through.

As both of these parameters are optional, you comenly see:

[UIView beginAnimations:@"" context:NULL];


To commit these animations, and therefore end the animation block, you need to use the UIView class method:

+ (void)commitAnimations


So what types of animations can you do ? well quite a few.

You can animate views by:

• Changing their alpha
• Changing there size
• Changing there location

In a single animation block you can animate multiple views, and you are also able to nest animation blocks.

So lets do a common example. When a UITableViewCell is being edited you often want to make a UILabel’s (label) alpha change to 0 so it is hidden:

For those new to C programming:

(editing ? 0.0 : 1.0)


Is equivlant to:

if(editing)
{
0.0;
}else{
1.0;
}


So for the second example we also have a UILabel (label), that we want to grow when the animation code is run. We also want this animation to last 2 seconds, so the user can admire our work. In addition to this, we want the animation to “ease in”. This is known as the animation curve. The animation curves that are available are

• ease in (slow then fast)
• ease out (fast then slow)
• ease in and out (slow, fast, slow)
• linear (constant speed)

We would do this animation using the following animation block:

This is just a brief overview of the animations you can do using the UIView class, but it should be enough to get you started. The UIView methods also include delegate call backs for when an animation starts and end. For more information see Apple’s Documentation.

If the UIView class does not have what you need, you will probably need to use the Core Animation framework. While using this framework is not trivial, it is not as hard as using OpenGL (which is used commonly for 3D games), and you can build some fantastic animations using it.