In a recent application I wrote a method with one parameter, an integer, that is expected to be 1 or 0. In creating a demo of the application I wanted to pass in alternating values of 1 and 0 as part of a test for a specific use case. Instead of using an if statement in the calling method to decide when to send a 1 or 0, I wrote something similar to the code below:

- (void)someMethod
{
  static int x = 0;
 
  // Toggles 1 to 0 and 0 to 1 using xor
  x ^= 1;
 
  // Call the method that expects a 1 or 0
  [methodCallHere toggle:x];
}

More often than not, exclusive-OR (^), AND (&) and inclusive-OR (|) are consider a bit-level operations (see this post on bitfields). However, there are times when these operators work equally well with integer values.

The code that follows is pure C. Given that Objective-C is a superset of C, don’t forget that you can leverage all that C has to offer, beyond working with objects.

1
2
3
4
5
6

struct
{
  unsigned preLoaded: 1;
  unsigned saveState: 1;
  unsigned saveLoginName: 1;
} statusFlags;

I’ve defines three bitfields, all which will be saved within an unsigned integer. Accessing the bits is as easy as this:

1
2
3
4
5
6
7

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  ... do something here...

Using the sizeof() function, let’s compare the size of an integer to the size of the structure we created:

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

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  NSLog(@"saveLoginName bit is on.");
else
  NSLog(@"saveLoginName bit is off.");  
 
NSLog(@"Sizeof int: %d", sizeof(int)); 
NSLog(@"Sizeof statusFlags: %d", sizeof(statusFlags));

The output looks as follows, which verifies that the bitfields are maintained within a single unsigned integer.

What’s interesting is that we now know that an integer is 4 bytes, this would imply that we can store up to 32 separate flags within our structure. To verify this the case, let’s create a new structure that looks as follows:

1
2
3
4
5
6
7
8

struct
{
  unsigned preLoaded: 1;
  unsigned saveState: 1;
  unsigned saveLoginName: 1;
  unsigned buffer: 28;
  unsigned savePassword: 1;
} statusFlagsExtended;

In this structure, ‘buffer’ is nothing more than a means for me to soak up 28 bits such that I can add one more bit on the end. Let’s take a look at the sizeof this structure with the code below:

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

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  NSLog(@"saveLoginName bit is on.");
else
  NSLog(@"saveLoginName bit is off.");  
 
NSLog(@"Sizeof int: %d", sizeof(int)); 
NSLog(@"Sizeof statusFlags: %d", sizeof(statusFlags));
NSLog(@"Sizeof statusFlagsExtended: %d", sizeof(statusFlagsExtended));

As expected, the structure ‘statusFlagsExtended’ is also stored as an integer.

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.

1
2
3
4
5
6
7
8
9

NSInteger x = 0;
 
// Increment x
x += 1;
 
...
 
// Decrement x
x -+ 1;

One small problem here, there is a typo in the code for decrementing x, which is easy to do given the + and = are on the say key.

It took some time to track down this problem as the compiler does not provide a warning for operations such as this that don’t have any effect.

Let’s add a compiler option so we receive a warning when we write a statement has no effect.

Option #1: User Defined GCC Options

- Make sure the Active SDK is set to one of the Simulator options
- Expand the Target option in the project settings
- Right click on the target
- Choose the Build settings
- Scroll to the bottom to the user defined settings
- Add an entry: GCC_WARN_UNUSED_VALUE and set the value to YES

Option #2: GCC Warning Options

- Make sure the Active SDK is set to one of the Device options
- Expand the Target option in the project settings
- Right click on the target
- Choose the Build settings
- Scroll to the section GCC 4.0 – Warnings
- Select the entry Unused Values

Either of the above will suffice, it just depends on what you have set as the Active SDK.

Upon making this change, for statements that have no effect, you will now get a warning generated by the compiler:

In an upcoming post I’ll show you how to set this as an option for all project templates.

As an example, begin by entering ifelse into Xcode and follow this by pressing Control . (control period) and you’ll see the following code block inserted:

At this point you can add code into the placeholder fields, moving from one field to the next using Control / (control forward-slash).

If you enter a code snippet in which there is more than one possible match, you can cycle through the options by pressing F5 which will bring up a list of options in a popup window, or pressing Command . will cycle through the choices inline in your code.

For example, if you enter if and follow this by pressing F5, you will be shown the window below:

List of Available Macros

The Xcode documentation includes a list of macros available for C, C++ and Objective-C. Some of the macros I use on a regular basis are shown below:

• nss -> NSString
• nsms -> NSMutableString
• nsd -> NSDictionary
• nsmd -> NSMutableDictionary
• a -> array (press Control-. to toggle through options)
• log -> NSLog
• if -> if else (press Control-. to toggle through options)

Text Macros from the Menu System
Xcode includes a menu of text macros for C, C++, HTML among others. You can find these macros in the Edit menu under Insert Text Macro.

Let’s say I want to insert a CGRectMake method. I can begin by typing CG and pressing F5 (or Option-esc), which will popup a list of possible matches:

If I choose an entry from this list, Xcode takes care of the rest. If I continue to type characters (instead of hitting F5), Xcode will further narrow the available matches (assuming there is more than one). Again, at any point I can press F5 to bring up the matching list.

As an alternative to using F5 for a list of suggestions, I can hit tab at any point and Xcode will insert the matched text currently displayed. For example, in the figure below I entered CGRe and Xcode inserted the suggestion shown below:

If I’d like to go with this suggestion, pressing the Tab key will insert the code.

Filling in Placeholder Fields
The next step is to fill in any required fields that Xcode has recognized. If there are parameters, Xcode will highlight the first field as shown:

Enter the value you want in the field and press Control / to move to the next field.

Code Sense Preference Settings
If you have any trouble getting these suggestions to work, I’ve included a screenshot of the Code Sense settings that I have configured in Xcode:

In the next post I’ll show how you can use various built-in macros to quickly insert blocks of code.

Apple recently released Safari 4 beta and if you haven’t given it a try, I highly recommend you do.

The primary reason for passing on this tip is that my web browsing experience with Firefox over the past few months has been extremely frustrating (read slow!). From the moment I started the Safari 4 beta it was clear the performance was superior to Firefox. I realize there may be more to this than simply a faster browser, as my system could use a good house cleaning. However, I continue to go between both browsers and Safari is no doubt my new browser of choice for the bulk of my time on the net.

There is one default setting that I immediately had to change in Safari, and that’s the location of the tabs. If you haven’t tried the new browser, the figure below shows how the tab bar is now on top.

I just couldn’t get used to this. Here’s how to change the tabbar to the “normal” location – from a terminal enter the following:

defaults write com.apple.Safari DebugSafari4TabBarIsOnTop -bool NO

You can find a list of additional configuration changes available in Safari 4 here. Beyond the tips, the About page is worth a visit, an interesting bit of trivia to be had…

In Objective-C there is a directive, @defs(), that outputs (at compile time) the list of instance variables for a class. We can use this list to create a C structure with the variables of a specified class.

For instance, if we have a class named TestClass, here is how one might create a structure using the @defs directive:

struct testClassStructure
{
  @defs(TestClass);
} *testClassAsStruct;

Before we look at how to use this structure to access the variables of TestClass, let’s look at a simple interface and implementation of TestClass:

TestClass Interface

//  TestClass.h
//
#import <UIKit/UIKit.h>
 
@interface TestClass : NSObject 
{
  NSString *testString;
  int      testInteger;
  BOOL     testBoolean;
}
 
@property (nonatomic, retain) NSString *testString;
@property (readonly) int testInteger;
@property BOOL testBoolean;
 
@end

TestClass Implementation

//  TestClass.m
//  
#import "TestClass.h"
 
/*-------------------------------------
* TestClass implementation
*-------------------------------------*/
@implementation TestClass
 
@synthesize testString;
@synthesize testInteger;
@synthesize testBoolean;
 
- (id)init 
{
  if (self = [super init]) 
  {
    testString = [[NSString alloc] initWithString:@"Fubar"];
    testInteger = 99;
    testBoolean = YES;
  }
  return self;
}
 
- (void)dealloc 
{
  [testString release];
  [super dealloc];
}
@end

Pretty simple stuff. Our interface defines three instance variables, a string, an integer and a boolean. The implementation file, upon initialization of a TestClass object sets defaults values for each instance variable.

So, let’s look at how to use a C structure to read/write the instance variables of TestClass:

AppDelegate Interface

//  UntitledAppDelegate.h
 
#import <UIKit/UIKit.h>
 
@interface UntitledAppDelegate : NSObject <UIApplicationDelegate> 
{
    UIWindow *window;
}
 
@property (nonatomic, retain) IBOutlet UIWindow *window;
 
@end

AppDelegate Implementation

//  UntitledAppDelegate.m
 
#import "UntitledAppDelegate.h"
#import "testClass.h"
 
@implementation UntitledAppDelegate
 
@synthesize window;
 
struct testClassStructure
{
  @defs(TestClass);
} *testClassAsStruct;
 
- (void)applicationDidFinishLaunching:(UIApplication *)application 
{ 
 
  TestClass *tmp;
 
  tmp = [[TestClass alloc] init];
 
  testClassAsStruct = (struct testClassStructure *) tmp;
 
  NSLog(@"testString: %@", testClassAsStruct->testString);
  NSLog(@"testInteger: %d", testClassAsStruct->testInteger);
  NSLog(@"testBoolean: %s", testClassAsStruct->testBoolean == YES ? "Yes" : "No");
 
  testClassAsStruct->testString = @"A new string";
  testClassAsStruct->testInteger = 0;
  testClassAsStruct->testBoolean = NO;
 
  NSLog(@"testString: %@", testClassAsStruct->testString);
  NSLog(@"testInteger: %d", testClassAsStruct->testInteger);
  NSLog(@"testBoolean: %s", testClassAsStruct->testBoolean == YES ? "Yes" : "No");
 
  [tmp release];
}
 
- (void)dealloc 
{
  [window release];
  [super dealloc];
}
 
@end

And of course, the output:

There you have it. An inside look at how to work with an Objective-C object using a C structure.

In the process of creating screenshots to accompany applications submitted to the App Store, you can include up to 5 images. Although the images can be anything you like, typically the images consist of screenshots of an application running in the iPhone simulator. When working with the simulator there are two sizes used most frequently, 320w x 460h (Apple recommends not to show the status bar across the top) and 480w x 320h (landscape mode).

Until I found Capture Me, I would use the built-in screen capture, command-shift-4, to capture screenshots. Problem is, there was no means to specify the exact image size to capture, so this approach requires either a very steady hand and a good eye, or capturing an area obviously larger than needed and cropping in Preview or another tool.

To use Capture Me, you specify the size of the area to capture and then drag a semi-transparent window over the capture area. Clicking inside the capture area creates a screenshot. You can save screenshots to the desktop (filename will be automatically generated) or have the screenshot copied to the clipboard, or both!

Capture Me also offers a screen recording feature, however, I haven’t given this a go as of yet.

Additional Features:
Here are a few things that I think would make for some nice additions to Capture Me:

#1 – Specify the location to save the file

#2 – Specify the filename for the screenshot. For example, when capturing/uploading screenshots to the App Store I use the filenames “screenshot1.jpg” “screenshot2.jpg” etc. If I could tell Capture Me to use this same format, it would save me the trouble of renaming the files.

#3 – The third feature is a little harder to describe, so let me explain how I use the tool which should help clarify what I am after. As I mentioned above, I use Capture Me to create screenshots of the iPhone simulator, what this entails is dragging Capture Me over the simulator and clicking inside the Capture Me window. In order to create the next screenshot, I need to click/drag the Capture Me window and move it to the side, click on the iPhone simulator to setup the next screenshot, then drag the Capture Me window back over the simulator for the next capture.

If I could tell the Capture Me window to move to the left/right the same width of the area I am capturing (+/- a few pixles) I could quickly capture a series of screenshots with ease. Even better if one keyboard shortcut would tell Capture Me to slide to the left/right, and one shortcut to tell Capture Me to slide it back to it’s original location.

I hope to get some time over the coming weeks and/or months to poke around the Capture Me code and see how far I can get to add the features above. If you beat me to the punch, drop me a note, and count me in as a beta tester.

Many thanks to Chimoosoft for creating, and open sourcing, Capture Me.