Cocoa uses protocols to support interprocess communication through Objective-C messages. In addition, since Objective-C does not support multiple inheritance, you can achieve similar functionality with protocols, as a class can adopt more than one protocol.

A good example of a protocol is NSCoding, which has two required methods that a class must implement. This protocol is used to enable classes to be encoded and decoded, that is, archiving of objects by writing to permanent storage.

@protocol NSCoding
- (void)encodeWithCoder:(NSCoder *)aCoder;
- (id)initWithCoder:(NSCoder *)aDecoder;
@end

To adopt a protocol, enclose the name of the protocol in <> as below:

// Interface
@interface SomeClass : NSObject <NSCoding> 
{
  ...
}
 
// Implementation
@implementation SomeClass
 
-(void)encodeWithCoder:(NSCoder *)aCoder
{
  ...
}
 
-(id)initWithCoder:(NSCoder *)aDecoder
{
  ...
}

Defining a Protocol

You can create both required an optional methods within a protocol. What follows is a definion of a protocol named ‘Fubar’:

@protocol Fubar
- (BOOL)send:(id)data;
- (id)receive;
@optional
- (int)status;
@end

To use the protocol, as with the example above, specify the protocol in the interface and write the required methods in the class implementation:

// Interface
@interface AnotherClass : NSObject <Fubar> 
{
  ...
}
 
// Implementation
@implementation AnotherClass
 
- (BOOL)send:(id)data
{
  ...
}
 
- (id)receive
{
  ...
}
 
// Optional methods
- (int)status
{
  ...
}
 
@end

If you are from a Java background, protocols should look familiar as they are analogous to an interface.

There is an instance of NSNotificationCenter available to every running application. This class acts as an intermediary to facilitate communication between objects that are interested in being notified at some point in the future (these objects are known as the observers) and a poster that posts to the notification center, resulting in all observers (registered for a specific notification) being called.

To give you an idea of where you might use notifications, consider how you might handle downloading of data in a background thread. I recently used notifications in this scenario as I wanted to be notified when a web-service call completed. Upon receiving a notification, I then proceeded to populate a view with the data retrieved, or with an error message if the data access failed.

The 30,000 foot view consists of two steps:

Step #1
Register an observer, which requests that a selector to be called when a specific notification is posted.

Step #2
Post a notification, which will result in all registered observers being called.

For example:

1
2
3
4

// Register observer to be notified when download of data is complete
[[NSNotificationCenter defaultCenter] addObserver:self 
                                   selector:@selector(downloadDataComplete:) 
                                   name:NOTIF_DataComplete object:nil];

This code registers an observer for a notification with the name NOTIF_DataComplete (more on that below). When a notification is posted with the same name, the method downloadDataComplete will be called.

Posting a notification with the name NOTIF_DataComplete would look as follows:

1
2
3

// Post notification that the download is complete  
[[NSNotificationCenter defaultCenter] 
                    postNotificationName:NOTIF_DataComplete object:nil];

Let’s show how this might like in a working example.

Class Registering as Observer

1
2
3
4
5
6
7
8
9
10
11
12
13

//  SomeClass.h
 
#import <Foundation/Foundation.h>
 
@interface SomeClass : NSObject 
{
 
}
 
// For name of notification
extern NSString * const NOTIF_DataComplete;
 
@end

Below is the code for the implementation of SomeClass. Notice on line 6 the name of the notification is defined. On line 40 we register as an observer for the named notification, specifying the selector @selector(downloadDataComplete:). Once the notification is posted, the method on line 26 is called.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//  SomeClass.m
 
#import "SomeClass.h"
 
// Name of notification
NSString * const NOTIF_DataComplete = @"DataComplete";
 
#pragma mark -
#pragma mark Private Interface
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Private interface definitions
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
@interface SomeClass (private)
- (void) dataDownloadComplete:(NSNotification *)notif;
@end
 
@implementation SomeClass
 
#pragma mark -
#pragma mark Private Methods
 
/*---------------------------------------------------------------------------
* Notifications of data downloads 
*--------------------------------------------------------------------------*/
- (void)downloadDataComplete:(NSNotification *)notif 
{
  NSLog(@"Received Notification - Data has been downloaded");
}
 
#pragma mark -
#pragma mark Initialization
 
/*---------------------------------------------------------------------------
* Initialization
*--------------------------------------------------------------------------*/
- (void) init
{
  // Other initialization code here...
 
  // Register observer to be called when download of data is complete
  [[NSNotificationCenter defaultCenter] addObserver:self 
                         selector:@selector(downloadDataComplete:) 
                         name:NOTIF_DataComplete object:nil]; 
 
}
 
#pragma mark -
#pragma mark Cleanup
 
/*---------------------------------------------------------------------------
* Cleanup 
*--------------------------------------------------------------------------*/ 
- (void)dealloc 
{
  [[NSNotificationCenter defaultCenter] removeObserver:self];
  [super dealloc];
}
 
@end

Class That Posts Notification

To keep things simple, I’ll add a few lines to the applicationDidFinishLaunching method to show you how posting a notification might look:

1
2
3
4
5
6
7
8
9
10
11
12
13

- (void)applicationDidFinishLaunching:(UIApplication *)application 
{
  [window makeKeyAndVisible];
 
  SomeClass *someclass = [[SomeClass alloc] init];
 
  // ...
 
  // Post a notification that the data has been downloaded  
  [[NSNotificationCenter defaultCenter] 
            postNotificationName:NOTIF_DataComplete object:nil];
 
}

I create an instance of SomeClass and follow this by posting of a notification of the name NOTIF_DataComplete. This example is a little contrived, however, I’m sure you get the idea. Although a short example, it shows just how easy it is to register an observer and post notifications.

There are various other nuances to working with notifications that can be quite helpful when the time comes that you need more robust support for communication among objects. For example, you could specify that you are interested in receiving a notification by name (as above), however, only if that notification has a specific object affiliated with it. This would allow you to use the same notification name, however, only notify certain objects. One use of this could be if you have multiple downloads and want to use notifications to be notify a specific object that it’s download is complete.

If you are working with multiple threads, which would be the case if you need to fire off multiple downloads in the background, you can look into distributed notifications, which allow notifications to be delivered to a particular thread.

How to get there from here is now obvious, however, when I first encountered this dilemma the solution wasn’t apparent. The reason being, there is significant depth in the Cocoa frameworks and half the battle in becoming proficient as an iPhone developer is to have an opportunity to explore the range of APIs. Albeit the solution was right under my nose the whole time, my first pass was to take a more traditional route of trying to parse the string and rebuild a more “traditional” date format which I could use to create a date object. So, skipping all that, here’s the proper solution…

If you’ve ever worked with dates in Cocoa, chances are you are familiar with the stringFromDate method of the NSDateFormatter. For example, the code below will convert the current date to a string that looks like this: Wednesday November 26, 2008

NSDate *date = [NSDate date];
NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
[dateFormat setDateFormat:@"EEEE MMMM d, YYYY"];
NSString *dateString = [dateFormat stringFromDate:date];  
[dateFormat release];

The trick is two-fold, the date format string to specify desired output, and the method stringFromDate to convert the date object to an NSString.

I’m sure you can see where I’m going with this…the solution I was looking for to convert a date (stored as a string) that was in a pre-defined format (i.e. 20081122) to a date object is as simple as using the method dateFromString. The primary difference is that the format string needs to represent the current format of the date that is to be read (versus the desired output format).

The code below converts a string that represents a date to an NSString object, with the output as follows: Saturday November 22, 2008:

NSString *dateStr = @"20081122";
 
// Convert string to date object
NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
[dateFormat setDateFormat:@"yyyyMMdd"];
NSDate *date = [dateFormat dateFromString:dateStr];  
 
// Convert date object to desired output format
[dateFormat setDateFormat:@"EEEE MMMM d, YYYY"];
dateStr = [dateFormat stringFromDate:date];  
[dateFormat release];

Here is a short list of sample formats using ICU:

The format specifiers are quite straightforward, Y = year, M = month, etc. Changing the number of specifiers for a field, changes the output. For example, MMMM generates the full month name “November”, MMM results in “Nov” and MM outputs “11″.

What follows is an example to create the following date string:

Saturday November 8, 2008:

NSDate *today = [NSDate date];
NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
[dateFormat setDateFormat:@"EEEE MMMM d, YYYY"];
NSString *dateString = [dateFormat stringFromDate:today];
[dateFormat release];

Here’s another example showing the current time:

9:20 AM, PST:

NSDate *today = [NSDate date]; 
NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
[dateFormat setDateFormat:@"h:mm a, zzz"];
NSString *dateString = [dateFormat stringFromDate:today];  
[dateFormat release];

So, to save you some time, here are several simple examples for displaying date information:

 // <strong>Output ->  Date: 10/29/08</strong>
 NSDate *today = [NSDate dateWithTimeIntervalSinceNow:0];
 NSDateFormatter *dateFormat = [[[NSDateFormatter alloc] init] autorelease];
 [dateFormat setDateStyle:NSDateFormatterShortStyle];
 NSString *dateString = [dateFormat stringFromDate:today];
 NSLog(@"Date: %@", dateString);

Notice above how the style of the output is set using NSDateFormatterShortStyle. There are additional canned formats as well such as NSDateFormatterFullStyle and NSDateFormatterNoStyle.

 // <strong>Output ->  Date: 10/29/2008 08:28pm</strong>  
 NSDate *today = [NSDate date];
 NSDateFormatter *dateFormat = [[[NSDateFormatter alloc] 
   initWithDateFormat:@"%m/%d/%Y %I:%M%p" allowNaturalLanguage:NO] autorelease];
 NSString *dateString = [dateFormat stringFromDate:today];
 NSLog(@"Date: %@", [dateString lowercaseString]);

Notice in the above example how I convert the string to lowercase to get “pm” rather than the default “PM”. Obviously, if the date contains text (e.g. October) this wouldn’t be a good approach.

 //<strong>Output -> Date: Thursday, October 30, 2008</strong>
 NSDate *today = [NSDate date];
 NSDateFormatter *dateFormat = [[[NSDateFormatter alloc] 
   initWithDateFormat:@"%A, %B %d, %Y" allowNaturalLanguage:NO] autorelease];
 NSString *dateString = [dateFormat stringFromDate:today];
 NSLog(@"Date: %@", dateString);

The above example is similar to the previous, simply using different specifiers to write out the date with full weekday and month.

 // <strong>Output ->  Date: 10/29/2008 08:29PM</strong>    
 NSDate *today = [NSDate date];
 NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
 [dateFormat setDateFormat:@"MM/dd/yyyy hh:mma"];
 NSString *dateString = [dateFormat stringFromDate:today];
 NSLog(@"date: %@", dateString);
 [dateFormat release];

The example above shows how you can manage memory without using autorelease.

These examples merely skim the surface of what you can do when working with dates. Look at the documentation for specifics on how to tweak the specifier strings to create variations of the date output.

Although I have heard of Lua , I had no idea of the depth of its usefulness. It was impressive to see the extent it’s used in Lightroom, somewhere in the neighborhood of 60% of the code base.

Tim Gogolin was the guy behind designing and developing a nice editor that Adobe uses internally for working with Lua to develop Lightroom. I can’t do it justice to describe it hear, suffice it to say, it was pretty cool, written specifically to meet the needs of the engineering team, from the way it compiles code on the fly to its debugging capabilities.

There was a nice demo showing how Lua (and the editor) are used to create Lightroom, and it was very intriguing to see how deeply ingrained Lua was in the development process. No question, Lua deserves a close look for those needing an embedded scripting language. And if you are into World of Warcraft, you should definitely give Lua a look, as the interface is written using Lua scripting.

You can read the rest of the tip on the iPhone Developer Tips blog.

This is a two part series on creating a new class that wraps NSLog to add several additional debugging features including output of the filename/path, line number information and the option to turn debug messages off/on.

You can read the rest of the tip on the iPhone Developer Tips blog.

The meeting was all about Objective-C. Bob McCune , the organizer of the event, gave a talk that covered Objective-C from beginning to end. One of the most intriguing aspects (at least from my perspective) was how the group would segue into a discussion on a topic. What was quite helpful was insight from those in the group who had significant experience working with Cocoa and Objective-C.

Bob did an excellent job, covering a great deal of ground, and wrapped up with an demo of a calculator application that tied together many of the concepts. If you are new to working with protocols, I highly recommend you download and give the application a look. The example shows how you can define and implement a protocol – no better way to learn a concept than to see it in code (I’ll add a link to the code once it is posted on the MN CocoaHeads site).

Many thanks to Bob McCune for starting MN CocoaHeads , Synergy Information Systems for making the space available, and Vladan Pulec (Synergy) for adding a link to this blog from the CocoaHeads MN website.

If you live in Minnesota, are within reasonable driving distance to Bloomington (or even if not) and are interested in developing applications for the Mac/iPhone, join us on August 14th (the second Thursday of every month) for our next meeting.