The line of code below is a slight modification that shows how to get the name that will appear on the iPhone below the icon:

[[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleDisplayName"];

The CFBundleDisplayName value corresponds to the Bundle Display Name in the application plist file, see the figure below:

You can see the application icon for this example in this figure:

NSRange Definition

NSRange is a structure defined as follows:

typedef struct _NSRange 
{
  NSUInteger location;
  NSUInteger length;
} NSRange;

location is the starting index in the range (zero based) and length is the number of entries in the range. NSUInteger is simply an unsigned value that supports both 32 and 64 bit systems. Here is how NSUInteger is defined:

#if __LP64__ || TARGET_OS_EMBEDDED || TARGET_OS_IPHONE || TARGET_OS_WIN32 || NS_BUILD_32_LIKE_64
typedef unsigned long NSUInteger;
#else
typedef unsigned int NSUInteger;
#endif

NSRange and Strings

The example below shows one approach for creating a range and using the same to extract a substring – the output from below is IPA

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
 
// Starting at position 25, get 3 characters
NSRange range = NSMakeRange (25, 3);
 
// This would also work:
// NSRange range = {25, 3};
 
NSLog (@"Beer shortname: %@", [homebrew substringWithRange:range]);

If you want to search for a substring, you could write something like the following:

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
NSRange range = [homebrew rangeOfString:@"IPA"];
 
// Did we find the string "IPA" ?
if (range.length > 0)
  NSLog(@"Range is: %@", NSStringFromRange(range));

The output from above will display: Range is: {25, 3}. Notice the call to NSStringFromRange() which will display the return value (a range) as an NSString. There is also a function to create a range from a string: NSRangeFromString().

Let’s look at one more example, the code below will search for the string “ia” starting at the end of the string moving towards the beginning:

NSString *homebrew = @"Imperial India Pale Ale (IPA)";
 
// Search for the "ia" starting at the end of string
NSRange range = [homebrew rangeOfString:@"ia" options:NSBackwardsSearch];
 
// What did we find
if (range.length > 0)
  NSLog(@"Range is: %@", NSStringFromRange(range));

The result from above is: Range is: {12, 2} (the “ia” inside the word “India”).

NSRange Functions

Here is a list of functions that work with ranges:

NSEqualRanges()
NSIntersectionRange()
NSLocationInRange()
NSMakeRange()
NSMaxRange()
NSRangeFromString()
NSStringFromRange()
NSUnionRange()

Compare NSString objects with ==

NSString *str1 = @"Homebrew";
NSString *str2 = @"Homebrew";
 
// This compares the addresses of the string
if (str1 == str2)
  NSLog (@"str1 equals str2");
else 
  NSLog (@"str1 does not equal str2");

Although this seems to give the results we are after (see the figure below showing Xcode console output), the reason this works is that the compiler can manage strings internally when you define them using the shortcut method (@”stringhere”) and will store only one reference internally to duplicates. You can verify that the strings refer to the same content by looking at the locations in memory where the variables are stored:

NSLog (@"str1 address in memory: %p", str1);
NSLog (@"str2 address in memory: %p", str2);

As shown in the figure below, notice the addresses are the same for both strings.

Let’s modify the above code to compare two more strings, this time with one of the strings being created from a C string:

// Create a C string
char *cStr = "Homebrew";
NSString *str3 = [NSString stringWithUTF8String:cStr];
NSString *str4 = @"Homebrew";
 
// Wrong - this compares the address of the string
if (str3 == str4)
  NSLog (@"str3 equals str4");
else
  NSLog (@"str3 does not equal str4");

Looking at the memory addresses we can do a quick sanity check, notice in the figure below that the addresses are not equal, even though the string “Homebrew” is the same for each variable:

NSLog (@"str3 address in memory: %p", str3);
NSLog (@"str4 address in memory: %p", str4);

Compare NSString Objects with isEqualToString

The right way to go about this is use the isEqualToString: method in the NSString class:

char *cStr = "Homebrew";
NSString *str3 = [NSString stringWithUTF8String:cStr];
NSString *str4 = @"Homebrew";
 
if ([str3 isEqualToString:str4])
  NSLog (@"str3 equals str4");
else 
  NSLog (@"str3 does not equal str4");

URL to Remote Image

We start by creating a URL to the remote resource:

NSURL *url = [NSURL URLWithString: 
   @"http://iphonedevelopertips.com/images/logo-iphone-dev-tips.png"];

Create UIImage from NSData

The next step is to build a UIImage using the data downloaded from the URL, which consists of an NSData object that holds the remote image contents:

UIImage *image = [UIImage imageWithData: [NSData dataWithContentsOfURL:url]];

Putting it Together

Here’s how to wrap it all together, adding the remote image as a subview to an existing view by creating a UIImageView from the above UIImage:

NSURL *url = [NSURL URLWithString: 
   @"http://iphonedevelopertips.com/images/logo-iphone-dev-tips.png"];
UIImage *image = [UIImage imageWithData: [NSData dataWithContentsOfURL:url]]; 
[self.view addSubview:[[UIImageView alloc] initWithImage:image]];

However, if you need to display a date in a locale other than the current setting on the device, here’s how to do it:

// Create date object  
NSDate *date = [NSDate date];
 
// Create date formatter
NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
[dateFormat setDateFormat:@"EEEE MMMM d, YYYY"];
 
// Set the locale as needed in the formatter (this example uses Japanese)
[dateFormat setLocale:[[[NSLocale alloc] initWithLocaleIdentifier:@"ja_JP"]
    autorelease]];
 
// Create date string from formatter, using the current date
NSString *dateString = [dateFormat stringFromDate:date];  
 
// We're done with this now
[dateFormat release];
 
// Show that the locale on the device is still set to US 
NSLocale *locale = [NSLocale currentLocale];
NSLog(@"Current Locale: %@", [locale localeIdentifier]);
 
// Display the date string in format we set above
NSLog(@"Date: %@:", dateString);

The output from the code above looks as follows:

More on Date Formatting:

Date Formatter Examples – Take 1: NSDateFormatter
Date Formatter Examples – Take 2: Format Strings
Date Formatter Examples – Take 3: Date from String

Here is how I came about this in my most recent app. I have a subclass of UITableViewCell that looks as follows:

@interface WeaponCell : UITableViewCell 
{
  UIImageView *image; 
  ...
}
 
...
 
// An instance of WeaponCell
WeaponCell *cell;

Prior to installing the 3.0 SDK, I would set the image as follows:

  cell.image = [UIImage imageNamed:@"weapon.png"];

However, with 3.0, the image method for UITableViewCell now states this: “Deprecated. Instead use the imageView property to get UIImageView object and then get or set the encapsulated image.”

Trouble is, you can’t simply make the appropriate code change if there’s any chance you need to build for a device that is running 2.x (or earlier). For example, I had to create an adhoc release today for someone who is running a device that has not been upgraded, and rolling back the code to pre-3.0 was not on the agenda. Here’s a much better solution:

// That's two underscores before IPHONE
#if __IPHONE_3_0
  cell.imageView.image = [UIImage imageNamed:@"weapon.png"];
#else
  cell.image = [UIImage imageNamed:@"weapon.png"];
#endif

Likewise, the font property of UIButton has been deprecated and you now are directed to use titleLabel property instead.

UIButton *backButton = [[UIButton alloc] initWithFrame:frame];
 
#if __IPHONE_3_0
  backButton.titleLabel.font = [UIFont systemFontOfSize:15.0];
#else
  backButton.font = [UIFont systemFontOfSize:15];
#endif

Deprecated methods, one of those things that you get to live with as a software developer. Good news is, there are reasonable work-arounds that make for managing this issue pretty painless.

 #define RGB(r, g, b) 
    [UIColor colorWithRed:r/255.0 green:g/255.0 blue:b/255.0 alpha:1]
 #define RGBA(r, g, b, a) 
    [UIColor colorWithRed:r/255.0 green:g/255.0 blue:b/255.0 alpha:a]

Here’s the code without/with the macro:

 // Code without the macro
  msgLabel.textColor = 
     [UIColor colorWithRed:255/255.0 green:251/255.0 blue:204/255.0 alpha:1];
 
  // Or like this...
  msgLabel.textColor = [UIColor colorWithRed:1.0 green:.98 blue:.8 alpha:1];
 
 // Code with macro
  msgLabel.textColor = RGB(255, 251, 204);

UIColor expects its parameters to be expressed as values in the range of 0.0 to 1.0, so I pass in the color value I’m looking for between 0 and 255, and let the macro do the math for me.

Let me show you how I use the macro with the color picker application. The figure below shows a screenshot of the color picker – at this point I have selected the color I am interested in, so I choose rgb from the dropdown menu.

From here, I copy the value from the field “Hex:”, paste this into my project and finish by changing rgb to RGB.

For views to be shown in landscape mode, you must manually rotate the coordinate system 90 degrees. Here’s one way you can do that, let’s assume we have a class that is of type UIViewController:

1
2
3
4
5

@interface SomeViewController : UIViewController 
{
...
}
@end

Inside the implementation file of SomeViewController, here’s one approach you can use within the viewDidLoad method:

1
2
3
4
5
6

- (void)viewDidLoad
{
  self.view.transform = CGAffineTransformIdentity;
  self.view.transform = CGAffineTransformMakeRotation((M_PI * (90) / 180.0)); 
  self.view.bounds = CGRectMake(0.0, 0.0, 480, 320);
}

Specifying CGAffineTransformMakeRotation call with 90 degrees as shown above will show the view in the UIInterfaceOrientationLandscapeRight. Setting this value to -90 will show the view in the UIInterfaceOrientationLandscapeLeft.

If you set the orientation in the plist file, you’ll need to coordinate the value set in the loadView method so the status bar appears as expected, that is, across the top of the display. If you choose set the orientation in the plist as UIInterfaceOrientationLandscapeLeft, use -90 as the rotation value, set to 90 for UIInterfaceOrientationLandscapeRight.

There are more ways than one to rotate views to landscape mode, if you have a preferred means, please post a comment.

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 iPhone 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. For more information, you can read Introduction to Notification Programming Topics available in the iPhone Reference Library.

Download: Xcode project