At that point I decided to use the very handy “Mark Generation” button in instruments. For those of you that haven’t used this button before, what it does is take a snapshot of all the active objects when you tap it. As objects get deallocated, they get removed from the snapshot. The usefulness of this snapshot is for doing a generational analysis of your application. Taking subsequent snapshots of the memory state of your application will show you what objects are still hanging around when they are supposed to be deallocated.

As you can see in the screenshots, the first Generation will be all the objects currently in memory. On each subsequent generation, it is only the objects that have been created, and not deallocated yet, that are shown. In Generation H this screenshot was right after I created the generation so it shows a larger growth. Waiting a few more seconds, it’s growth also dropped to 1.58 KB, with 32 objects.

Immediately I realized, that indeed, I have a fairly large issue, in that roughly every 10 seconds, I was creating and not destroying 1.5 KB… In a long running app, this could really add up.

Now I had to try to debug these increases. If you tap on the grey right arrow next to a generation, it will expand out and show you all the objects still hanging around.

Hrmm, lots of Core Foundation objects, some NSURL’s, and a bunch of strings. None of this is my code. Let’s dig deeper. You can expand each of the types of objects to see all the addresses that are hanging around, and see the stack trace for each of those objects. You do this by looking at the extended detail of the objects, by selecting the third button on the right in the View area to open the Extended Detail.

Looking at the stack traces for a bunch of objects, I see a lot of internal Core Foundation traces, which don’t help, but then I came across a helpful stack trace pointing me at PNReachability. Looking through all the traces of the objects hanging around, the only user land code, was pointing at PNReachability.

Going one level further down, we can see all the retain / release and autoreleases that this object has experienced. Also lets look at the code

One of the components we use is a pub/sub implementation called PubNub. Since this bug seemed to be in that component, I decided to see if I couldn’t replicate it with the demo example of PubNub from https://github.com/pubnub/objective-c/tree/master/iOS at commit  f9e7d59.

Profiling the demo, I was able to see the same 1.58 kb increases every 10 seconds, so I knew that my app wasn’t at fault.

Looking at the code for handleOriginLookupTimer, i see the pretty standard dispatch_async on a background thread, running a synchronous network call, and then calling back to the main thread on another dispatch_async. They are even doing a weak reference to self properly.

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

- (void)handleOriginLookupTimer {
 
    // In case if reachability report that connection is available (not on cellular) we should launch additional lookup service which will
    // allow to check network state for sure
#if __IPHONE_OS_VERSION_MIN_REQUIRED
    BOOL shouldSuspectWrongState = self.reachabilityStatus != PNReachabilityStatusReachableViaCellular;
#else
    BOOL shouldSuspectWrongState = YES;
#endif
 
    // In case if server report that there is connection
    if ([self isServiceAvailableForStatus:self.reachabilityStatus] && shouldSuspectWrongState) {
 
        __block __pn_desired_weak __typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 
            NSError *requestError;
            NSHTTPURLResponse *response;
            NSMutableURLRequest *timeTokenRequest = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:[PNNetworkHelper originLookupResourcePath]]];
            timeTokenRequest.timeoutInterval = kPNReachabilityOriginLookupTimeout;
            NSData *downloadedTimeTokenData = [NSURLConnection sendSynchronousRequest:timeTokenRequest returningResponse:&response error:&requestError];
//            [[NSURLCache sharedURLCache] removeCachedResponseForRequest:timeTokenRequest];
 
            dispatch_async(dispatch_get_main_queue(), ^{
 
                [weakSelf handleOriginLookupCompletionWithData:downloadedTimeTokenData response:response error:requestError];
            });
        });
    }
}

All pretty standard, but since the bug was there, and I know that blocks within blocks can lead to retain cycles, I tried to make sure there weren’t any, that were causing this issue.

I went through several iterations of turning the requestError, response, and downloadedTimeTokenData into weak references, and then back into strong ones, to see if any change to those would fix this 1.58 kb leak. I tried moving the declarations of the objects outside both blocks, and several other things that would break a retain cycle if it existed, but nothing I was doing worked.  The problem didn’t seem to be a retain cycle.

My next step was the always helpful google searching. I searched for  various combinations of sendSynchronousRequest, dispatch_async, iOS Block… and so on trying to see if anyone else had this strange issue.

I finally found http://stackoverflow.com/questions/3116205/getting-leak-in-leak-in-nsurlconnection-sendsynchronousrequesttherequest-retur which the comments pointed to NSURLCache as being the culprit.

1
2
3
4
5
6
7
8
9
10
11

diff --git a/iOS/iPadDemoApp/pubnub/libs/PubNub/Network/PNReachability.m b/iOS/iPadDemoApp/pubnub/libs/PubNub/Network/PNReachability.m
index ee4fdcc..bf457d5 100644
--- a/iOS/iPadDemoApp/pubnub/libs/PubNub/Network/PNReachability.m
+++ b/iOS/iPadDemoApp/pubnub/libs/PubNub/Network/PNReachability.m
@@ -476,6 +476,7 @@ void PNReachabilityCallback(SCNetworkReachabilityRef reachability __unused, SCNe
             NSMutableURLRequest *timeTokenRequest = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:[PNNetworkHelper originLookupResourcePath]]];
             timeTokenRequest.timeoutInterval = kPNReachabilityOriginLookupTimeout;
             NSData *downloadedTimeTokenData = [NSURLConnection sendSynchronousRequest:timeTokenRequest returningResponse:&response error:&requestError];
+            [[NSURLCache sharedURLCache] removeCachedResponseForRequest:timeTokenRequest];
 
             dispatch_async(dispatch_get_main_queue(), ^{

After a simple addition of removeCachedResponseForRequest, after the sendSynchronousRequest I was able to fix the 1.58kb heap growth every 10 seconds.

For more information on using the Mark Generation tool, or instruments in general, check out the WWDC 2013 session 410 “Fixing Memory Issues”.

• 

I received my DICE+ developer kit a couple weeks ago and was excited to get to testing. What is DICE+? DICE+ is a bluetooth connected, smart, 6 sided die that is made out of materials safe to roll directly on your devices. It has a 20hr battery which powers a bunch of cool sensors like accelerometers, magnetic field sensor, touch sensitive faces, and a few more. The built in anti-cheat protection makes sure each roll is fair, and each face can display a wide range of colors due to the red, green and blue LEDs backlighting every side. Balanced to match any standard 6 sided die performance, the DICE+ brings back some of the tactile fun of playing games on digital devices. Although not quite out on the market as of this writing, developers can download the SDK, order kits and start developing. The developers over at DICE+ have also set aside a kit to give away to one of the readers of this post. The first 6 readers who reply to this post and correctly lists all sensors available, will be entered in the drawing. A DICE+ will then be rolled, a winner selected from those replies and sent one of the DICE+ developer kits. Now that I have had some fun, I thought I would share, and show how easy it was to use.

In the following tutorial, I have designed a simple 2 player game in which you are trying to be the first player to get your ship into space. Each player takes a turn rolling the die, the first player to reach 25 is the winner. With the addition of some simple UIView animations to animate our player ships and space background, the race to space can begin. Link to project file and assets are at the end of this post.

First lets create a new, single view, portrait oriented project for iPad called ‘RaceToSpace’ using ARC (Automatic Reference Counting).  After downloading the DICE+ SDK from the website, drag and drop the framework into your project, add the ‘CoreBluetooth’, and QuartzCore frameworks. For DICE+, You will also have to add ‘-all_load’ to your projects build settings, under other linker commands. In Interface Builder, add a UIImageView to your view, setting its size and origin to the following x=0, y=-1024, width=768 and height=2048. Press your editors double column view button, and while holding the control button, left mouse click the newly added UIImageView and link to your .h file creating an IBOutlet reference called ‘spaceBackground’. Add a Play button to start the game, a label at the bottom to show bluetooth connection info and turn status, and 2 labels at the top for displaying player scores. Link all of these to your .h file as you did with the space background UIImageView, using these corresponding names; playButton, status, player1Score, player2Score. You will also need to right click on the PLAYBUTTON, and link the ‘touch up inside’ action onto your ViewController.m file and name it ‘Play’. Now that the basic building blocks are setup, we can get to configuring the software for use with your die.

In your ViewController .h, add the following code to match.

 
#import <UIKit/UIKit.h>
#import <DicePlus/DicePlus.h>
#import "Player.h"

@interface ViewController : UIViewController <DPDiceManagerDelegate>
{
    DPDiceManager* diceManager;
    DPDie* availableDie;
    DPDie* connectedDie;
}
@property (weak, nonatomic) IBOutlet UILabel *player1Score;
@property (weak, nonatomic) IBOutlet UILabel *player2Score;
@property (weak, nonatomic) IBOutlet UIImageView *spaceBackground;
@property (weak, nonatomic) IBOutlet UILabel *status;
@property (nonatomic, retain) NSArray *players;
@property (nonatomic, retain) Player *currentPlayer;
@property (weak, nonatomic) IBOutlet UIButton *play;

@end

In your ViewController.m, add the following code to your viewDidLoad method. This initializes the dice manager, sets the DEV KEY with the [diceManager startScanning] command, and starts scanning for available devices. Also add the #define MaxPoints 25. This defines the winning score.

 
#define MaxPoints 25

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.

    if (connectedDie != nil) {
        return;
    }
    availableDie = nil;
    diceManager = [DPDiceManager sharedDiceManager];
    diceManager.delegate = self;

    //DICE+ generic development key.
    uint8_t key[8] = {0x83, 0xed, 0x60, 0x0e, 0x5d, 0x31, 0x8f, 0xe7};
    [diceManager setKey:key];

    //Start scanning for an available DICE+.
    [diceManager startScan];
    self.status.text = @"Searching for DICE+...";
}

If you notice the error pertaining to the #import Player.h and the player object, we will be adding that in a moment so you can ignore that for now. We do need to add some delegate calls so we can be notified of a DICE+ connection, and some to receive results when the die is rolled. I will also explain in detail the contained code when we walk thru the functionality of the game.

 
- (void)die:(DPDie *)die didRoll:(DPRoll *)roll error:(NSError *)error
{
    //Roll was valid
    if (roll.flags == DPRollFlagOK) {
        //Stop roll updates just to make sure wrong player doesnt mistakenly roll DICE+.
        [connectedDie stopRollUpdates];
        //Convert roll result (1-6) to binary mask equivalent
        int mask = 1 << (roll.result-1);
        //Blink the top face green showing roll result. DICE+ uses a binary mask for determinning which face, or faces to light.
        [connectedDie startBlinkAnimationWithMask:mask priority:0 r:0 g:255 b:0 onPeriod:100 cyclePeriod:50 blinkCount:5];
        //Move player ship
        [self moveCurrentPlayer:roll.result];

    } else if (roll.flags == DPRollFlagTilt) {
        //DICE+ roll error
        self.status.text = @"Roll Tilted";
        //Blink DICE+ faces red to indicate a roll error occured.
        [connectedDie startBlinkAnimationWithMask:63
                                         priority:1
                                                r:255
                                                g:0
                                                b:0
                                         onPeriod:100
                                      cyclePeriod:200
                                       blinkCount:4];
    } else if (roll.flags == DPRollFlagTooShort) {
        //DICE+ roll error
        self.status.text = @"Roll too short";
        //Blink dice plus faces red to indicate a roll error occured.
        [connectedDie startBlinkAnimationWithMask:63
                                         priority:1
                                                r:255
                                                g:0
                                                b:0
                                         onPeriod:100
                                      cyclePeriod:200
                                       blinkCount:4];
    }
}

#pragma mark - DPDiceManagerDelegate methods
- (void)centralManagerDidUpdateState:(CBCentralManagerState)state
{
    // See CBCentralManagerDelegate documentation for info about CBCentralManager state changes
}

- (void)diceManagerStoppedScan:(DPDiceManager *)manager
{
    //Scanning has stopped, restart scan if no available die was found.
    if (availableDie == nil) {
        [diceManager startScan];
        self.status.text = @"Searching for DICE+...";
    }
}

- (void)diceManager:(DPDiceManager *)manager didDiscoverDie:(DPDie *)die
{
    //A DICE+ die was found, not connected yet.
    availableDie = die;
    availableDie.delegate = (id)self;

    [diceManager stopScan];
    //Attempt to connect to available DICE+ found.
    [diceManager connectDie:availableDie];

    self.status.text = @"Connecting DICE+...";
}

- (void)diceManager:(DPDiceManager *)manager didConnectDie:(DPDie *)die
{
    //Available DICE+ connected and is ready for play.
    availableDie = nil;
    connectedDie = die;
    connectedDie.delegate = (id)self;
    self.status.text = @"Press play to begin.";
}

- (void)diceManager:(DPDiceManager *)manager failedConnectingDie:(DPDie *)die error:(NSError *)error
{
    //DICE+ failed connection attempt.
    availableDie = nil;
    connectedDie = nil;
    self.status.text = @"Connection failed... Searching...";

    [diceManager startScan];
}

- (void)diceManager:(DPDiceManager *)manager didDisconnectDie:(DPDie *)die error:(NSError *)error
{
    //DICE+ disconnected
    availableDie = nil;
    connectedDie = nil;
    self.status.text = @"Die disconnected... Searching...";

    [diceManager startScan];
}

- (void)dieFailedAuthorization:(DPDie *)die error:(NSError *)error
{
    //DICE+ authorization failed.
    self.status.text = @"Failed authorization";
}

The DICE+ is well documented and there are quite a few delegate methods that can be used depending on which sensor you issue a startUpdate too.

We’ll go back to the functions of the game a little later on in the post, for now lets look at whats happening when connecting to the die.

After the app has started scanning for an active die and one has been found, the dice manager delegate , didDiscoverDie, will be called and the scanning is stopped using [diceManager stopScan]. Since we don’t know that we can successfully connect to the die, only that one is available, we store the returned found die as availableDie, then attempt a connection with it. If no available dice were found and the scanner times out (after 12 seconds), diceManagerStoppedScan: will get called. In our example we simply restart the scanning process and scan again.

Upon a successfull connection, dice manager didConnectDie delegate method is called. Since we want to differentiate between an available die and our successfully connected die, connectedDie is assigned and used for the rest of the games life cycle, and availableDie is nilled out. If for some reason there is an issue connecting to the available die, ‘failedConnectingDie:’ is called. If a die is connected and looses that connection for some reason, the diceManager ‘didDisconnectDie:’ is called. In this example a scan is started again to try and regain a connection.

Once we have a connected die, it is easy to start the various sensor updates and listen for their delegate calls. For this game, we will only worry about [connectedDie startRollUpdates], [connectedDie stopRollUpdates], and the corresponding delegate methods to receive the roll response once a valid roll is done.

- (void)die:(DPDie *)die didRoll:(DPRoll *)roll error:(NSError *)error

The value of the roll is returned in roll.result with roll state in roll.flag that gives information about the roll itself. DPRollFlagOK is returned with a valid roll, DPRollFlagTilt is returned if the die has landed on a tilt, and DPRollFlagTooShort if not enough time was taken to make the roll. These flags are part of the anti cheat error checking done within the die.

As we add the functionality of the game, you will also see how easy it is to change and animate the LEDs for each face once a roll is completed, or for any other reason you may need.

For the actual gameplay we will be adding 6 new methods but first we need to create a player object to represent each of our 2 players. Right click on the RaceToSpace folder in the left hand, project navigator pane and select new file. Create a new subclass of NSObject and name it Player.

Add the following to the Player.h,

@interface Player : NSObject

@property(nonatomic, retain) UIImage *shipImage;
@property(nonatomic) NSInteger score;
@property(nonatomic) NSInteger playerNumber;

- (id)initWithImage:(UIImage *)shipImage;

@end

and this to your Player.m,

- (id)initWithImage:(UIImage *)shipImage;
{
    self = [super init];
    if (self) {
        // Initialization code
        self.shipImage = shipImage;
        self.score = 0;
    }
    return self;
}

Now we need to create the 2 players, do this at the beginning of your viewDidLoad, just after the call to super. Each player is created and assigned a player number, a UIImageView is also created to display the players ship, placed at their start positions on the screen and added to the view. By setting the tag of each of these UIImageViews to the players number, we can be sure to move the correct ship for the player. Initialize our player reference NSArray with both of our players..

 
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    //Setup Player 1
    Player *player1 = [[Player alloc] initWithImage:[UIImage imageNamed:@"rocketShip1"]];
    player1.playerNumber = 1;
    UIImageView *player1ship = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 64, 113)];
    player1ship.contentMode = UIViewContentModeCenter;
    player1ship.image = player1.shipImage;
    player1ship.center = CGPointMake(192, 928);
    player1ship.tag = player1.playerNumber;
    [self.view addSubview:player1ship];

    //Setup Player 2
    Player *player2 = [[Player alloc] initWithImage:[UIImage imageNamed:@"rocketShip2"]];
    player2.playerNumber = 2;
    UIImageView *player2ship = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 64, 113)];
    player2ship.contentMode = UIViewContentModeCenter;
    player2ship.image = player2.shipImage;
    player2ship.center = CGPointMake(576, 928);
    player2ship.tag = player2.playerNumber;
    [self.view addSubview:player2ship];

Add some code to our Play button action and add these remaining methods to you ViewController.m and we will take a quick walk thru of the game.

- (IBAction)play:(id)sender
{
    //Rest players score to 0 in case this is a replay.
    self.play.hidden = YES;
    [self setupPlayer];
}

- (void)setupPlayer
{
    if (!self.currentPlayer){
        //Its a new game, make current player, player 1.
        self.currentPlayer = [self.players objectAtIndex:0];
    } else {
            //Switch between players
            if (self.currentPlayer.playerNumber == 1){
                //Make current player, player 2.
                self.currentPlayer = [self.players objectAtIndex:1];
            } else {
                //Make current player, player 1.
                self.currentPlayer = [self.players objectAtIndex:0];
            }
        }
    self.status.text = [NSString stringWithFormat:@"Player %i's turn", self.currentPlayer.playerNumber];

    //Start DICE+ roll updates for current player.
    [connectedDie startRollUpdates];
}

- (void)prepareForNewGame
{
    //Set player scores to 0 and reset ships to start position.
    for (Player *p in self.players){
        p.score = 0;
        UIImageView *playerShip = (UIImageView *)[self.view viewWithTag:p.playerNumber];
        playerShip.center = CGPointMake(playerShip.center.x, 928);
    }

    //Reset some labels
    self.play.hidden = NO;
    self.player1Score.text = @"0 points";
    self.player2Score.text = @"0 points";
    self.status.text = @"Press play to begin.";

    //Animate background back to start position
    [UIView animateWithDuration:.25 animations:^{
        self.spaceBackground.center = CGPointMake(384, 0);
    }];

    //Set current player to nil so new game will start with player 1.
    self.currentPlayer = nil;
}

- (BOOL)currentPlayerIsWinner
{
    //check if current player has matched, or exceeded max points
    if (self.currentPlayer.score >= MaxPoints){
        return YES;
    }
    return NO;
}

- (void)moveCurrentPlayer:(NSInteger)rollValue
{
    //Get UIImageView for players ship and animate p the screen.
    UIImageView *playerShip = (UIImageView *)[self.view viewWithTag:self.currentPlayer.playerNumber];

    //Calculate appropriate distance to travel based on MaxPoints, so winner is always near top of screen.
    int offset = (1024 - rintf(1024/6))/MaxPoints;
    int distance = rollValue * offset;
    self.currentPlayer.score = self.currentPlayer.score + rollValue;

    if ([self currentPlayerIsWinner]) {
        //Current player has won. Do something.
        NSString *winnerText = [NSString stringWithFormat:@"Congratulations player %i, you are the Winner!", self.currentPlayer.playerNumber];
        UIAlertView *winnerNotify = [[UIAlertView alloc] initWithTitle:@"WINNER!!" message:winnerText delegate:self cancelButtonTitle:@"OK" otherButtonTitles: nil];
        [winnerNotify show];
        self.status.text = @"We have a WINNER!";

        //Fly the winning ship the rest of the way off the screen.
        [UIView animateWithDuration:1 animations:^{
            playerShip.center = CGPointMake(playerShip.center.x, -200);
        }];
        return;
    } else {
        [UIView animateWithDuration:1 animations:^{
            playerShip.center = CGPointMake(playerShip.center.x, playerShip.center.y - distance);
        }];
        if (self.currentPlayer.playerNumber == 2){
            self.player2Score.text = [NSString stringWithFormat:@"%i points", self.currentPlayer.score];
            [self slideBackground:distance];
        } else {
            self.player1Score.text = [NSString stringWithFormat:@"%i points", self.currentPlayer.score];
            [self setupPlayer];
        }
    }
}

- (void)slideBackground:(NSInteger)distance
{
    //Check if background is able to scroll any further, if so scroll up distace value.
    if (self.spaceBackground.center.y + distance < 1024){
        [UIView animateWithDuration:3 delay:0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
            self.spaceBackground.center = CGPointMake(384, self.spaceBackground.center.y + distance);
        } completion:^(BOOL finished) {
            //Setup next player when animation is done.
            [self setupPlayer];
        }];
    }
}

When the play button is pressed and the – (IBAction)play:(id)sender callback is called, the play button is hidden and [self setupPlayer] is called. SetupPlayer, checks to see if self.currentPlayer uninitialized, if so then it represents a new game and currentPlayer is assigned as Player1 from index 0 of the Players reference array. We set the text of our connection status label to state that it is player 1’s turn and the DICE+ roll updates are started with [connectedDie startRollUpdates]; The game is now waiting for player 1 to roll. Once a valid roll is made, the die: didRoll: delegate method is called. With a successful roll.flag of DPRollFlagOK a few things happen. Dependent on the value of roll.result, an int called mask is set to a specific value. This mask value is how we tell the DICE+ which face or faces to light up.

A quick explanation of the  mask value. If you think of a 6 bit binary number, adding each decimal value of the bits (or faces) you want lit up, this total number is the mask. For example if I wanted the number 2 face to light,

1    2    3    4    5    6  (face)

1    2    4    8    16  32  (decimal value)

0    1    0    0    0    0  (binary mask)

Number for the mask would be 2.

If you wanted faces 1, 2 and 3 to light up, the mask would be,

1    2    3    4    5    6  (face)

1    2    4    8    16  32  (decimal value)

1    1    1     0    0    0  (binary mask)

Number for mask would be 6.

All faces would be represented by the number 63.

We can pass this mask, as well as color and various other info to the die in a couple of different methods used to blink and fade the lights on and off. In our game, when a roll is invalid (either tilted or too short), an animation is used to blink all the faces red for a short time. Upon a valid roll, the face of the rolled value is blinked green.

After a successful roll, the roll updates of the die are stopped, this may not be necessary but may stop any accidental rolls and turn changes. [self moveCurrentPlayer:roll.result] is then called, passing along the rolled die value. This value is used in moveCurrentPlayer to move the current players ship up the screen (players UIImageView is found in the view by its tag), added to their current score and checks to see if the current player is the winner [self currentPlayerIsWinner] and returns a TRUE/FALSE. If the current player is not the winner, the game continues to the next step. If this is player2, then the background image is slid down the screen an appropriate amount in [self slideBackground:roll.result] using a simple UIView animation. Whether the background needed sliding or not, the next step is [self setupPlayer].

[self setupPlayer] determines that the currentPlayer is valid, checks the player’s number of the current player, and switches current player to the other player, roll updates are started once again and the next player can take their turn. In [self moveCurrentPlayer] once a player reaches, or passes, 25 (as defined at the top of ViewController.m in MaxPoints) that triggers the winning phase. One slight addition to add to our game is to show a UIAlertView when a player wins and inform us when it is dismissed so we can reset the game.

Add to your ViewController.h so we can know when the user dismisses the winning text and delegate call for the alertView,

@interface ViewController : UIViewController <DPDiceManagerDelegate, UIAlertViewDelegate>

and the following in your ViewController.m so we know when it is dismissed.

- (void)alertView:(UIAlertView *)alertView didDismissWithButtonIndex:(NSInteger)buttonIndex
{
    //Once cancel is pressed on the alertview, prepare for new game.
    [self prepareForNewGame];
}

On a winning score the UIAlertView is displayed, status text is updated and the winning ship is flown the rest of the way of the screen. When the player dismisses the UIAlertView popup, [self prepareForNewGame] is called. Within that method, variables are reset, ships are set back to their starting positions and currentPlayer is set to nil. With a press of the Play button once again, the game play can start again.

I realize a lot more could be added, more in-depth animations could be done and special instances such as rolling the same number twice in a row to initiate special rules but since this was more about attaching and using the DICE+, I will leave those upgrades and additions to you. Hope you enjoyed this tutorial, I have enjoyed getting to test out this new product and look forward to what may come of it. Thanks.

Here is the link to the images used in the game, and here is a link to the GitHub repository. In order to ensure the latest SDK, you will need to download the DICE+ SDK (the version of the SDK depends on the firmware loaded on the Die) separately, and drag the DicePlus.framework file into the project.

• 

Recently here at ELC, we’ve been working on an app that requires a lot of server interaction, which has been a learning experience for managing threading, server load and connectivity. In order to keep the app performant and responsive while sending a large number of requests and aggregating a large set of data, our team had to intelligently manage and prioritize network interactions.

This is where NSOperationQueue helps out. This class relies heavily on Grand Central Dispatch (GCD) to execute NSOperations (in this case, HTTP requests and JSON serializations). These operations can be executed in various configurations, including concurrently and asynchronously.

In this tutorial, I’ll show you how to set up a block-based operation queue that takes advantage of NSBlockOperation, a concrete subclass of NSOperation. You can use this server client class to manage all interactions with your external server. To demonstrate this, our sample code will query Twitter for a set of search tags and return the results asynchronously. The sample code is available on GitHub. Let’s get started.

Server Client Setup

First, create a MediaServer class with an operation queue property. This server class is a singleton because we want to route all network requests through a single operation queue.

@interface MediaServer : NSObject
 
@property (strong) NSOperationQueue *operationQueue;
 
+ (id)sharedMediaServer;
 
@end

Our server singleton is instantiated as follows. Note that using dispatch_once takes advantage of GCD and is recommended by Apple for thread safety.

+ (id)sharedMediaServer;
{
    static dispatch_once_t onceToken;
    static id sharedMediaServer = nil;
 
    dispatch_once( &onceToken, ^{
        sharedMediaServer = [[[self class] alloc] init];
    });
 
    return sharedMediaServer;
}

Next, in MediaServer’s init method, initialize the operation queue and set the concurrent operation count. The maxConcurrentOperationCount property can be changed later, too.

- (id)init;
{
    if ( ( self = [super init] ) )
    {        
        _operationQueue = [[NSOperationQueue alloc] init];
        _operationQueue.maxConcurrentOperationCount = 2;
    }
 
    return self;
}

Search Tags Management

In the project files, you’ll notice SearchTagsViewController. I’ve set this up to handle adding, removing and editing Twitter search tags. You’ll find a pretty straightforward implementation using NSUserDefaults to persist your search tags. The main purpose of this view controller is to prepare a series of server requests.

Server Calls Using NSBlockOperation

Now, we’re ready to start using our operation queue. For our example, we’ll be searching for tweets containing various keywords, so we only need one fetch method in our server class.

Note: because blocks are a bit syntactically difficult to read, it can be convenient to typedef assign a block’s input and return parameters. This also makes methods much more readable when passing in blocks. For our example, we are expecting an array of tweet objects, and we’ll check for errors in the HTTP request and JSON serialization. In MediaServer.h, add:

typedef void (^FetchBlock)(NSArray *items, NSError *error);

Now, we’re ready to add our fetch tweets method. This method accepts a search string and a return block (FetchBlock). This method will create an NSBlockOperation instance using blockOperationWithBlock: and dispatch it to the Media Server’s dispatch queue. Within that block, we’ll asynchronously send an NSURLRequest, serialize the response and synchronously return the tweets using our FetchBlock. Let’s take a look at the code.

- (void)fetchTweetsForSearch:(NSString *)searchString block:(FetchBlock)block;
{
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
 
        NSMutableArray *tweetObjects = [[NSMutableArray alloc] init];
        NSError *error = nil;
        NSHTTPURLResponse *response = nil;
 
        NSString *encodedSearchString = [searchString stringWithURLEncoding];
        NSString *URLString = [NSString stringWithFormat:@"http://search.twitter.com/search.json?q=%@&rpp=%i&include_entities=true&result_type=mixed", encodedSearchString, SEARCH_RESULTS_PER_TAG];
        NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:URLString] cachePolicy:NSURLRequestReloadIgnoringLocalCacheData timeoutInterval:DEFAULT_TIMEOUT];
        NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];
 
        NSDictionary *JSON = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
        NSArray *tweets = [JSON objectForKey:@"results"];
 
        // Serialize JSON response into lightweight Tweet objects for convenience.
 
        for ( NSDictionary *tweetDictionary in tweets )
        {
            Tweet *tweet = [[Tweet alloc] initWithJSON:tweetDictionary];
            [tweetObjects addObject:tweet];
        }        
 
        NSLog(@"Search for '%@' returned %i results.", searchString, [tweetObjects count]);
 
        // Return to the main queue once the request has been processed.
 
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
 
            if ( error )
                block( nil, error );
            else
                block( tweetObjects, nil );
        }];
 
    }];
 
    // Optionally, set the operation priority. This is useful when flooding
    // the operation queue with different requests.
 
    [operation setQueuePriority:NSOperationQueuePriorityVeryHigh];
    [self.operationQueue addOperation:operation];
}

Dispatching Tweet Searches

Let’s look at how we’ll use this server method. In TweetsViewController’s viewDidLoad: method, we’ll want to loop through our search tags and fetch each set of tweets. Because each operation is dispatched to our operation queue, we don’t have to worry about swamping the server or causing timeouts due to limited network bandwidth. To do so, in viewDidLoad:, add:

MediaServer *server = [MediaServer sharedMediaServer];
 
    for (NSString *tag in self.tags) 
    {
        [server fetchTweetsForSearch:tag block:^(NSArray *items, NSError *error) {
 
            if ( items && error == nil )
            {
                [self.tweets addObjectsFromArray:items];
 
                NSArray *sortDescriptorsArray = [NSArray arrayWithObject:[NSSortDescriptor sortDescriptorWithKey:@"createdAtDate" ascending:NO]];
                [self.tweets sortUsingDescriptors:sortDescriptorsArray];
 
                [self.tableView reloadData];
                [self.activity stopAnimating];
            }
        }];
    }

Canceling Tweet Searches

In certain cases, you might want to cancel operations in your queue, for example, when the user navigates away from a view displaying content from several server requests. In this example, when the user taps the back ‘Tags’ button, we want to prevent the remaining search requests from going through. This is as easy as:

- (void)viewDidDisappear:(BOOL)animated;
{
    MediaServer *server = [MediaServer sharedMediaServer];
    [[server operationQueue] cancelAllOperations];
}

Note that this doesn’t immediately remove operations from the queue, instead it notifies the queue to abort the operation as soon as possible. If you need more specific control of which operations to keep running, NSOperationQueue also exposes an operations property to manually cancel specific operations.

Concurrency

The only thing fetchTweetsForSearch:block: does is create an operation and submit it to the queue, so it returns almost immediately. The main benefit of this approach is that all of the work within the block operation occurs on a background queue, leaving the main thread free and ensuring that the UI remains responsive. To confirm this is working properly, you can open up the Time Profiler in Instruments (an extremely useful tool for improving UX) and check which queue the block is executed on.

In the profiler, you’ll see that initWithJSON:, JSONObjectWithData:options:error: and sendSynchronousRequest:returningResponse:error: are all executed on a dispatched worker thread, not the main thread. That’s exactly what we want.

Conclusion

There you have it. As a developer, you’ll glean the most benefit from this server paradigm when sending out a large number of URL requests or when your user is on a slow network. If you do encounter situations where your queue is filling up with requests, remember that you can prioritize your operations, e.g.,

[operation setQueuePriority:NSOperationQueuePriorityVeryHigh];

Another benefit of this approach is the ability to return cached data using our FetchBlock, while updating from the server in the background. Look for more on that in a later blog post.

Happy iCoding!

Source Code – GitHub

• 

IOS openGL rotating Earth using NinevehGL from Erick Bennett on Vimeo.

In this tutorial I am going to show you how to easily, and effectively add an openGL ES 2.0 3D view into your project, and display a fully rendered, rotating 3D earth. The model assets are available here, and include the object and texture. These assets are also available in the project ZIP file, available thru the link at the end of this tutorial.

Download and install the NinevehGL framework.

Since we want to add this view into an existing project and understand how the engine functions, lets create a new single-view project to start. Although NinevehGL can just as easily be setup thru interface builder, we will be adding this view programmatically. For this exercise, it does not matter if you select storyboard or XIB for the new project.

To begin with there are a few frameworks we will need to add. Do this by first selecting your projects main file in the project navigator pane. Make sure your projects target is selected, and under Build Phases click ‘Link Binaries with Libraries’. Use the + at the bottom of this display and add the QuartsCore  and OpenGLES frameworks.

Next, using the ‘Add Other’ button, navigate to your downloaded NinevehGL folder and import the NinevehGL.framework.

Now onto the code…….import NinevehGL into your header (.h) file,

#import <NinevehGL/NinevehGL.h>

add the delegate to your @interface, if this is missing your drawview method will never get called.

@interface ViewController : UIViewController <NGLViewDelegate>;

In order to see what is being rendered we will need an ivar for an NGLCamera, and for our single object, an NGLMesh. The complete code for all of this should look as follows.

#import <UIKit/UIKit.h>
#import <NinevehGL/NinevehGL.h> 

@interface ViewController : UIViewController <NGLViewDelegate> 
{ 
    NGLCamera *_camera; 
    NGLMesh *_mesh; 
}

In your source (.m) file you must initialize your NGLView, set its delgate to self, define a dictionary with a few basic settings, and initialize the mesh and camera. I am doing this in my viewDidLoad method but depending on your needs, this could be done elsewhere.

    
- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.

    // Setup our NGLView.
    NGLView *theView = [[NGLView alloc] initWithFrame:CGRectMake(40, 40, 240, 360)];

    // Set its delegate to self so the drawview method is used.
    theView.delegate = self;

    // Add the new view on top of our existing view. 
    [self.view addSubview:theView];

    // The content scale factor is used to increase the resolution to take advantage 

 of retina displays and values range from 1.0 to 2.0. This sets the contentscalefactor 

 to the max screen scale of the device.
    theView.contentScaleFactor = [[UIScreen mainScreen] scale];

    // Setup some initial environment states to be applied to our mesh.
    NSDictionary *settings = [NSDictionary dictionaryWithObjectsAndKeys:
	kNGLMeshCentralizeYes, kNGLMeshKeyCentralize,
	@"0.3", kNGLMeshKeyNormalize, nil];

    // Initialize the mesh which includes the model file to import (.obj or .dae).
    _mesh = [[NGLMesh alloc] initWithFile:@"earth.obj" settings:settings delegate:nil];

    // Initialize the camera used to render the scene.
    _camera = [[NGLCamera alloc] initWithMeshes:_mesh, nil];

    // If a trasparent background of the NGLView is needed
    //theView.backgroundColor = [UIColor clearColor];
    //nglGlobalColorFormat(NGLColorFormatRGBA);
    //nglGlobalFlush();

    // The following command displays a 3d view status monitor that will show your current frame rate and number of polygons being rendered in the view.
    [[NGLDebug debugMonitor] startWithView:(NGLView *)self.view];
}

You will need to add at least one method to your source (.m) file, this is the drawView loop. This drawView loop is used to generate each frame being displayed (up to 60 per second). This drawloop is where you would affect the mesh to animate movement or create the effects your a looking to display. The  [_camera drawCamera] is needed to commit the changes and render the frame. The method usually ends with this command.

-(void)drawView
{
    // Rotate on Y axis
    _mesh.rotateY += .5;

    // Draw to our camera to display on our view
    [_camera drawCamera];
}

In the above example, the _mesh.rotateY += .5 is used to rotate the mesh .5 degrees each time the frame is rendered.

Now build and run the project and you should see a slowly spinning planet Earth. The NGLView was purposely drawn smaller than the background view in order to show how you could overlay this NGLView over any other normal view to add 3D content. If you want the background of the NGLView to be transparent, set the background color of the view to clear and add the following additional commands. There is also a status monitor that can be run to display frame rates and the number of polygons being rendered for optimization.

// If a trasparent background of the NGLView is needed
 theView.backgroundColor = [UIColor clearColor];
 nglGlobalColorFormat(NGLColorFormatRGBA);
 nglGlobalFlush();

// The following command displays a 3d view status monitor that will show your current frame rate and number of polygons being rendered in the view.
 [[NGLDebug debugMonitor] startWithView:(NGLView *)self.view];

There are many commands you can use to affect your object, it’s movement and how it interacts in it’s 3D environment, here are just a few basic ones. Advanced animation, movement techniques, object hit testing, custom shaders, etc. would be worthy of a separate tutorial. Enjoy.

// rotation
 _mesh.rotateX, rotateY, rotateZ

// scaling
 _mesh.scaleX, scaleY, scaleZ 

// placement
 _mesh.x,y,z 

// offset center of objects rotation
 _mesh.pivot = nglVec3Make(x, y, z)

Assets

Project file

• 

Why Would I want To Unzip Files?

That’s a great question. There are a number of reasons why you might want to support zipping and unzipping files inside of your applications. Here are just a few:

Apple’s 50 MB App Store Download Cap

Apple has imposed a 50MB download limit over 3G on applications downloaded to appease carriers and not hog all of their bandwidth. One way to circumvent this is to keep your binaries very small, and download the resources your application needs. The best way to package these resources is of course, a zip file. So the process (as you will see demoed below), is to open your app, check for resource updates, download the zip file, and unzip it. Now you can ship smaller applications, that fetch their resources dynamically.

Dynamic Updates To Content

I touched on this above. When your application needs updated assets, the common practice is to submit an update to the App Store. This could take up to a week for Apple to Review and publish. A faster approach is to zip your assets up and stick them on a server somewhere (even your Dropbox) and have your app download and unzip them. This way, whenever you want to make asset-based changes to your application, you won’t need to submit another copy of it to the store.

Downloading Zip Files From The Web

One huge downfall of Safari and the Mail app is, they are unable to open zipped files. It would be nice to offer some sort of support to view zipped archives on your device. Many of the “download” apps in the store support this, and you can too with some help from ZipArchive.

Setting Up Your Project

Head over to http://code.google.com/p/ziparchive/ and checkout a copy of ZipArchive. Or you can just type this into your terminal.

svn checkout http://ziparchive.googlecode.com/svn/trunk/ziparchive-read-only

Once you have cloned the repository, delete the MakeFile file from the minizip folder. We will let XCode build our files. Now, drag this minizip folder as well as the ZipArchive.h and ZipArchive.mm files into your project, making sure to check “Create groups for any added folders”. Also, be sure your target is checked.

Note: No ARC Support

If you are using an ARC enabled project, you will need to tell the compiler not to use ARC for ZipArchive. To do this, click on the project in the left hand column. Then click on your target in the middle column and select the “Build Phases” tab.

Expand the “Compile Sources” area, locate ZipArchive.mm and double click on it. In the box that pops up, type in -fno-objc-arc and click Done.

Linking libz

The last step is to link your project against libz.1.2.5.dylib. From the Build Phases screen you navigated to above, expand the Link Binary With Libraries section and click the “+” button to add a new library. Search the list for libz.1.2.5.dylib, select it and click Add.

Now, compile your project and it should succeed with no errors. One thing to note is ZipArchive might produce some warnings, they are not a big deal, but if you are a warning Nazi (you should be), dig into the code and see if you can solve them yourself.

Downloading And Unzipping Files

I will now show you how easy it is to download a zip file from the web, unzip its contents, and use them in your project. The method of which we will download the files is very basic and most likely wouldn’t be used in production without further error reporting and checking.

The sample project has a view that looks like this:

It’s basically a UIImageView and a UILabel. Inside of the view controller I have set up IBOutlets for these two items. Make sure and download the sample project to see the implementation details. We will be downloading a zip file from the web that contains an image and a text file which you can see displayed in the screenshot above. Once unzipped, the image will be set as the viewable image in our UIImageView and the textual contents of the .txt file will be displayed inside of the UILabel.

**1. Import the ZipArchive headers **

#import "ZipArchive.h"

2. Download the the zip file

    // 1 
    dispatch_queue_t queue = dispatch_get_global_queue(
                                                       DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, ^{
        NSURL *url = [NSURL URLWithString:@"http://icodeblog.com/wp-content/uploads/2012/08/zipfile.zip"];
        NSError *error = nil;
        // 2
        NSData *data = [NSData dataWithContentsOfURL:url options:0 error:&error];
 
        if(!error)
        {        
            // 3
            NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
            NSString *path = [paths objectAtIndex:0];
            NSString *zipPath = [path stringByAppendingPathComponent:@"zipfile.zip"];
 
            [data writeToFile:zipPath options:0 error:&error];
 
            if(!error)
            {
                // TODO: Unzip
            }
            else
            {
                NSLog(@"Error saving file %@",error);
            }
        }
        else
        {
            NSLog(@"Error downloading zip file: %@", error);
        }
 
    });

This preliminary code downloads a zip file from iCodeBlog and saves it to the caches directory for the application.

1. Creates a dispatch queue in which to run our code on with default priority.
2. Quick and dirty way of fetching data from the web.
3. Resolves the path to the caches directory and writes out the downloaded data to a local zip file

Now that you have it downloading the file to disk, it’s time to unzip that file and make use of it’s contents.

3. Unzipping the downloaded file

The last step here is to unzip the file you just downloaded. To be clear, it was save to the path /Library/Caches/zipfile.zip and once extracted, it’s contents will be inside of the Caches folder as well.

Replace the //TODO: Unzip in the code above, with the following code:

ZipArchive *za = [[ZipArchive alloc] init];
// 1
if ([za UnzipOpenFile: zipPath]) {      
    // 2      
    BOOL ret = [za UnzipFileTo: path overWrite: YES];
    if (NO == ret){} [za UnzipCloseFile];
 
    // 3
    NSString *imageFilePath = [path stringByAppendingPathComponent:@"photo.png"];
    NSString *textFilePath = [path stringByAppendingPathComponent:@"text.txt"];
    NSData *imageData = [NSData dataWithContentsOfFile:imageFilePath options:0 error:nil];
    UIImage *img = [UIImage imageWithData:imageData];
    NSString *textString = [NSString stringWithContentsOfFile:textFilePath 
        encoding:NSASCIIStringEncoding error:nil];
 
    // 4           
    dispatch_async(dispatch_get_main_queue(), ^{
        self.imageView.image = img;
        self.label.text = textString;
    });

Here is an explanation of what’s going on.

1. Opens the file and unzips it in memory
2. Writes the unzipped contents out to a given path (Caches folder)
3. Makes use of the unzipped files
4. Updates the UI (on the main thread of course) with the newly fetched data.

It really is that simple.

Zipping Files

Now you are going to see how to go the other way and zip up some files on disk. Again, this could be particularly handy when you want to allow your users to share groups of files via the web or email.

If you completed the steps above, your caches folder should have some files lying around that we can just zip up again and send off. We are going to zip up the two files you previously unzipped, stuff them into a new zip file, and write that out to the documents directory.

In my sample project, I have created a new button at the top that says “Zip Files” which links to an IBAction called zipFilesButtonPressed: when tapped. That is where I will be doing the zipping:

- (IBAction)zipFilesButtonPressed:(id)sender
{
    // 1
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *docspath = [paths objectAtIndex:0];
 
    // 2
    paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
    NSString *cachePath = [paths objectAtIndex:0];
 
    // 3
    NSString *zipFile = [docspath stringByAppendingPathComponent:@"newzipfile.zip"];       
 
    // 4
    ZipArchive *za = [[ZipArchive alloc] init];
    [za CreateZipFile2:zipFile];
 
    // 5
    NSString *imagePath = [cachePath stringByAppendingPathComponent:@"photo.png"];
    NSString *textPath = [cachePath stringByAppendingPathComponent:@"text.txt"];
 
    // 6
    [za addFileToZip:imagePath newname:@"NewPhotoName.png"];
    [za addFileToZip:textPath newname:@"NewTextName.txt"];
 
    // 7
    BOOL success = [za CloseZipFile2];    
    NSLog(@"Zipped file with result %d",success);
 
}

Here is what’s going on:

1. Resolve the path to the documents directory. We will need this when determining the path to write out our new zip file.
2. Resolve the path to the caches directory. This is used to fetch the files that will be zipped up.
3. Determines the path the zip file we will be writing out.
4. Instantiates the ZipArchive object and tells it to create a new “in-memory” zip file. Note, the file won’t be written out until you call the corresponding CloseZipFile2 method.
5. Resolve the path to the files that will be zipped up.
6. Add the files to the zip archive. You can add as many files as you would like here. You can even add directories (ie you could have added the entire caches directory if you wanted to).
7. Write out the zip file and close it. Just to test, we log the result to ensure that the zipping was successful.

After running through the application, tapping on the “Zip Files” button, look inside of the Application’s Documents folder (located ~/Library/Application Support/iPhone Simulator/[iOS Version]/Applications/[Unique ID]/Documents]. It should contain a single zip file called newzipfile.zip. If you unzip it, you should see the two files that you stuffed in there extracted.

Conclusion

You have now seen how to zip and unzip files on iOS devices using the ZipArchive library. You can download the sample project at the bottom of this post. As always, if you have any questions or comments, feel free to write them in the comments of this post or write them to me on Twitter @brandontreb.

Happy iCoding!

Download The Sample Project

• 

In this blog post I will demonstrate how to mock HTTP requests using an Objective-C runtime dynamic method replacement technique known as method swizzling. I will show how this can be used in tandem with some unit test technologies to help with development of iOS web-service client side code.

In this example, the actual work of the HTTP request is embodied in my AsyncURLConnection class. It uses NSURLConnection to perform an NSURLRequest in an asynchronous manner, using completion handler blocks to return the response to the caller. I could have chosen to mock the native APIs but mocking at the AsyncURLConnection level provides the desired effect more easily.

Method Swizzling Helper Class

This is a generic helper class for method swizzling (swapping). This gets used in tests as seen below. The

swizzleClassMethod:selector:swizzleClass:

method takes a class and a method selector along with a class with an alternative implementation of the method given by the selector. The class swaps the implementation of the existing class method with the corresponding method in the swizzleClass.

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
 
@interface Swizzler : NSObject
 
- (void)swizzleClassMethod:(Class)target_class selector:(SEL)selector swizzleClass:(Class)swizzleClass;
- (void)deswizzle;
 
@end
 
#import "Swizzler.h"
 
@implementation Swizzler
 
Method originalMethod = nil;
Method swizzleMethod = nil;
 
/**
Swaps the implementation of an existing class method with the corresponding method in the swizzleClass.
 */
- (void)swizzleClassMethod:(Class)targetClass selector:(SEL)selector swizzleClass:(Class)swizzleClass
{
	originalMethod = class_getClassMethod(targetClass, selector); // save the oringinal implementation so it can be restored
	swizzleMethod = class_getClassMethod(swizzleClass, selector); // save the replacement method
	method_exchangeImplementations(originalMethod, swizzleMethod); // perform the swap, replacing the original with the swizzle method implementation.
}
 
/**
 Restores the implementation of an existing class method with its original implementation.
 */
- (void)deswizzle
{
	method_exchangeImplementations(swizzleMethod, originalMethod); // perform the swap, replacing the previously swizzled method with the original implementation.
	swizzleMethod = nil;
	originalMethod = nil;
}
 
@end

Class to be mocked

This is the interface of a class that connects and loads a URL. I will be replacing the implementation so its details are left out of here for brevity.

#import <Foundation/Foundation.h>
 
typedef void (^completeBlock_t)(NSData *data);
typedef void (^errorBlock_t)(NSError *error);
 
@interface AsyncURLConnection : NSObject
{
    NSMutableData *data;
    completeBlock_t completeBlock;
    errorBlock_t errorBlock;
}
 
/**
 Asynchronously performs an HTTP GET - invokes one of the blocks depending on the response to the request 
*/
+ (id)request:(NSString *)requestUrl completeBlock:(completeBlock_t)aCompleteBlock errorBlock:(errorBlock_t)anErrorBlock;
 
/**
 Initializes and asynchronously performs an HTTP GET - invokes one of the blocks depending on the response to the request
 */
- (id)initWithRequest:(NSString *)requestUrl completeBlock:(completeBlock_t)aCompleteBlock errorBlock:(errorBlock_t)anErrorBlock;
 
// If both HTTP Basic authentication optional parameters are non-empty strings, request will encode the URL with them.
@property (nonatomic, copy) NSString *authUserName; // HTTP Basic authentication optional parameter
@property (nonatomic, copy) NSString *authPassword; // HTTP Basic authentication optional parameter
 
@property (nonatomic, copy) NSString *accept; // Optional parameter to set the response type accepted (default is @"application/json")
 
@end

Example of Usage in a Test

In this test I am testing that I am correctly processing the JSON data returned from the web service. However, I want to isolate the actual web service from the test. I want a test to validate the creation of the NSDictionary response object from the JSON.
As an aside, by removing the Swizzler code, this test could be run against the actual web service; but that is not the intent here.
Here is what the JSON response looks like –

{
    "coaches" :
	[
     {
     "id" : 1,
     "name" : "Jeff Tucker",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/64337_10150578149548471_1189630488_n.jpg"
     },
     {
     "id" : 2,
     "name" : "Traver H. Boehm",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/traver.jpg"
     },
     {
     "id" :3,
     "name" : "Jeff Tucker",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/64337_10150578149548471_1189630488_n.jpg"
     },
     {
     "id" : 4,
     "name" : "Traver H. Boehm",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/traver.jpg"
     },
     {
     "id" : 5,
     "name" : "Jeff Tucker",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/64337_10150578149548471_1189630488_n.jpg"
     },
     {
     "id" : 6,
     "name" : "Traver H. Boehm",
     "thumbnail_url" : "http://img.breakingmuscle.com/sites/default/files/imagecache/full_portrait/images/author/traver.jpg"
     }
     ],
    "per_page": 6,
    "page": 1,
    "total" : 11,
    "total_pages": 2
}

The method under test here is:-

- (void)loadCollectionFromEndpoint:(NSString *)endpoint successBlock:(JSONLoaderLoadSuccessBlock)successBlock failBlock:(JSONLoaderLoadFailBlock)failBlock

This method calls the AsyncURLConnection class method

+ (id)request:(NSString *)requestUrl completeBlock:(completeBlock_t)completeBlock errorBlock:(errorBlock_t)errorBlock;

I will replace the existing implementation of that method with one that does not actually make an HTTP request, but instead gets JSON from a local file.

The unit test uses OCHamcrest matchers and XCode’s built in OCUnit.

- (void)test_loadPopularCoaches_success
{
    // Test set-up
    Swizzler *swizzler = [Swizzler new];
    // Replace the actual AsyncURLConnection method with our own test one.
    [swizzler swizzleClassMethod:[AsyncURLConnection class] selector:@selector(request:completeBlock:errorBlock:) swizzleClass:[RequestPopularCoachesPassMock class]];
    __block BOOL hasCalledBack = NO;
 
    // Test
    NSString *endpoint = [NSString stringWithFormat:@"%@?per_page=6&page=1&popular=true", kCoachesEndpoint];
    [[JSONLoader sharedJSONLoader] loadCollectionFromEndpoint:endpoint successBlock:^(NSDictionary *collection) {
        NSArray *coaches = [collection valueForKey:@"coaches"];
        assertThat(coaches, hasCountOf(6)); 
        int i = 0;
        for (NSDictionary *coach in coaches) {
            STAssertTrue([coach isKindOfClass:[NSDictionary class]], @"Incorrect class");
            assertThat(coach, equalTo([popularCoaches objectAtIndex:i])); // popularCoaches defined elsewhere with expected data
            ++i;
        }
        assertThat([collection valueForKey:@"per_page"], equalToInt(6));
        assertThat([collection valueForKey:@"page"], equalToInt(1));
        assertThat([collection valueForKey:@"total"], equalToInt(11));
        assertThat([collection valueForKey:@"total_pages"], equalToInt(2));
        hasCalledBack = YES;
    } failBlock:^(NSError *error) {
        NSLog(@"%@", [error localizedDescription]);
        STFail(@"Unexpected error returned");
        hasCalledBack = YES;
    }];
 
    // see http://drewsmitscode.posterous.com/testing-asynchronous-code-in-objective-c
    NSDate *loopUntil = [NSDate dateWithTimeIntervalSinceNow:1];
    while (hasCalledBack == NO) {
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:loopUntil];
    }
    swizzler = nil;
}

You can use any class to provide an implementation of the replacement method. This approach allows you can return various responses from your HTTP request. Here is one that returns the expected payload that is read from a file.

@interface RequestPopularCoachesPassMock : NSObject
 
+ (id)request:(NSString *)requestUrl completeBlock:(completeBlock_t)completeBlock errorBlock:(errorBlock_t)errorBlock;
 
@end
 
@implementation RequestPopularCoachesPassMock
 
// Swizzled method
+ (id)request:(NSString *)requestUrl completeBlock:(completeBlock_t)completeBlock errorBlock:(errorBlock_t)errorBlock
{
    if (completeBlock) {
        NSData *data = [FileReader dataWithContentsOfBundleFile:@"popularCoaches.json"];
        completeBlock(data);        
    }
    return self;
}
 
@end

Conclusion

In this blog post I have demonstrated how to use the Objective-C runtime dynamic method replacement technique known as *method swizzling* to assist with unit testing in a situation where there is a 3rd party web service that I want to mock. This technique can be used during development to assist with integrating of an iOS app with a web service. It helps speed up development and prototyping. It can also be applied during development in the normal running of your app if you want to mock out portions of or all of a web service.

• 

In Part 1 of this series, I will introduce you to the very basics of CoreLocation services and getting the location of the device currently being used.

About CoreLocation

The CoreLocation framework provides your app with the ability to get a device’s current location, provided the user of the device has granted your app access to that information.

Location services are provided in two major ways using this framework:

1. Standard Location Services– This service provides the most accurate location information using a variety of methods including celluar, wifi, and GPS.
   • Most accurate.
   • Consumes the most power and can take a longer time to acquire.
   • Can only be used when your application is in the foreground.
2. Significant Change Location Services– This service uses cellular data to determine a general idea of where the device is located.
   • Fastest and uses the least amount of power to determine the location.
   • Can also be used to notify your app when a significant change in the location has occurred even if your app is not in focus.

Project Files:

You can download the project files at this github repository: http://github.com/shawngrimes/Location-and-Map-Sample

Adding Location Frameworks

The first step to adding location services to your project is to add the CoreLocation framework.

1. Select your target and go to the “Build Phases” tab.
2. Click the “+” button under “Link Binary With Libraries”
3. Select the CoreLocation framework and click “Add”

Location Manager

With location services, you create an instance of CLLocationManager. There is usually one instance of this per app so I feel a good place for this is in the App Delegate and then each view can access the current location from the App Delegate.

To start, open your App Delegate header file:

1. Add #import <CoreLocation/CoreLocation.h> to the top
2. Specify that your app delegate complies with the Core Location Delegate protocol by changing your @interface line with @interface CFAAppDelegate : UIResponder <UIApplicationDelegate, CLLocationManagerDelegate>
3. Specify a CLLocationManager property by adding @property (strong, nonatomic) CLLocationManager *locationManager right before the @end statement.

Your App Delegate header file should now look similar to the following:

#import <UIKit/UIKit.h>
 
//Add Location Framework
#import <CoreLocation/CoreLocation.h>
 
//Specify this app delegate complies with the location manager delegate
@interface CFAAppDelegate : UIResponder <UIApplicationDelegate, CLLocationManagerDelegate>
 
@property (strong, nonatomic) UIWindow *window;
 
//Add a location manager property to this app delegate
@property (strong, nonatomic) CLLocationManager *locationManager;
 
@end

Creating The Location Manager Object

Switch over to the App Delegate implementation file (.m), and we are going to create our location manager object. The first thing we should do, since we created it as a property of our app delegate, is synthesize the property so add @synthesize locationManager=_locationManager; under the line that reads @synthesize window = _window;.

#import "CFAAppDelegate.h"
 
@implementation CFAAppDelegate
 
@synthesize window = _window;
@synthesize locationManager=_locationManager;

Now that our property is synthesized, we can create the object. I usually create it in the method application didFinishLaunchingWithOptions:. A Location Manager object is created similar to any other object but there are three important properties you should set after you have alloc’d/init’d.

1. .purpose – The purpose property is displayed to the user of your app when they are prompted to allow your app to use their location. It gives you a chance to explain what your app is going to do with their location information.
2. .desiredAccuracy – The desired accuracy property allows you to tell the device how accurate you would like the location information to be. This should be set based on your application’s needs. Don’t set this property to kCLLocationAccuracyBest if you only need to know what city they are in. NOTE: This is the “desired” accuracy, it is not guaranteed. The device will determine the best available information and provide it to you but you are not, however, guaranteed any level of accuracy.
3. .distanceFilter – The distance filter property tells the location manager how far a device needs to move (horizontally vs. an altitude change) before triggering a new location event. It is measured in meters. You can set the property to kCLDistanceFilterNone to be notified of all events (this is also the default value).

The completed creation of our location manage looks like this:

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.
    self.window.backgroundColor = [UIColor whiteColor];
    [self.window makeKeyAndVisible];
 
    if(self.locationManager==nil){
        _locationManager=[[CLLocationManager alloc] init];
        //I'm using ARC with this project so no need to release
 
        _locationManager.delegate=self;
        _locationManager.purpose = @"We will try to tell you where you are if you get lost";
        _locationManager.desiredAccuracy=kCLLocationAccuracyBest;
        _locationManager.distanceFilter=500;
        self.locationManager=_locationManager;
    }
 
    return YES;
}

If you run this now, you should not notice any change in the way your application runs, you also won’t start receiving location information just yet. That comes next…

Starting Location Services

Now that we have our location manager configured, we want to start getting the location. To start the standard location service, you should first check to make sure that location services are enabled. This is done with a simple call to [CLLocationManager locationServicesEnabled] so after we set up our location manager above and before the return YES;, add the following code:

    if([CLLocationManager locationServicesEnabled]){
        [self.locationManager startUpdatingLocation];
    }

NOTE: If location services are not enabled and you start updating location services, the user will be prompted to enable location services. This could be annoying to the end user if they have to answer “No” every time your app launches.

If you run your app now, you will notice that the user is prompted to enable location services (and it will include the message from the .prompt property of our location manager object).

Receiving Location Changes

We’ve started location services, but now we need to start receiving updates to location changes. This is all done through the CLLocationManagerDelegate protocol. There are a number of available methods to implement for this delegate but the three most important are probably:

1. – locationManager:didUpdateToLocation:fromLocation:
2. – locationManager:didFailWithError:
3. – locationManager:didChangeAuthorizationStatus:

– locationManager:didUpdateToLocation:fromLocation:

Let’s start with receiving an update in location and how to handle that. In our App Delegate implementation file (.m), add the following method placeholder below the @synthesize … statements and above - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions method:

-(void)locationManager:(CLLocationManager *)manager didUpdateToLocation:(CLLocation *)newLocation fromLocation:(CLLocation *)oldLocation{
 
}

One of the first things I like to do is check the timestamp of the newLocation detected. When you first start updating location services, the location manager will receive the last known location of the device, this could be hours or days old depending on the last time location services were used. In my apps, I like to make sure that I have a recent location. This following code will only use a location that has been found in the last 15.0 seconds:

    NSDate* eventDate = newLocation.timestamp;
    NSTimeInterval howRecent = [eventDate timeIntervalSinceNow];
    if (abs(howRecent) < 15.0)
    {
        //Location timestamp is within the last 15.0 seconds, let's use it!
    }

The next check that I like to perform is to see how accurate the newLocation is. This can be done by looking at the .horizontalAccuracy property. This property tells you how accurate your location information is. As I stated above, you can request to have very accurate locations but you are not guaranteed it. In the illustration below, the newLocation.coordinate is the location the device thinks it is, but in truth the orange circle of the .horizontalAccuracy says that it could be anywhere in that circle.

Your application’s need will determine how accurate of a location you need. Again, if you just need the city the user is in, you won’t need it to be as accurate as if you were trying to find something within walking distance. In the code below, I have set my accuracy threshold to 35.0 meters. This is pretty broad but I have found that it works well indoors as well as out. Insert the following code right after the comment //Location timestamp is within the last 15.0 seconds, let's use it!

        //Location timestamp is within the last 15.0 seconds, let's use it!
        if(newLocation.horizontalAccuracy<35.0){
            //Location seems pretty accurate, let's use it!
            NSLog(@"latitude %+.6f, longitude %+.6f\n",
                  newLocation.coordinate.latitude,
                  newLocation.coordinate.longitude);
            NSLog(@"Horizontal Accuracy:%f", newLocation.horizontalAccuracy);
 
            //Optional: turn off location services once we've gotten a good location
            [manager stopUpdatingLocation];
        }

The code above will print the new location to the console and then turn off location services. This is an optional step but if you don’t need location services anymore, it’s a smart thing to turn them off to conserve your user’s battery.

This is what our complete delegate method looks like:

-(void)locationManager:(CLLocationManager *)manager didUpdateToLocation:(CLLocation *)newLocation fromLocation:(CLLocation *)oldLocation{
    NSDate* eventDate = newLocation.timestamp;
    NSTimeInterval howRecent = [eventDate timeIntervalSinceNow];
    if (abs(howRecent) < 15.0)
    {
        //Location timestamp is within the last 15.0 seconds, let's use it!
        if(newLocation.horizontalAccuracy<35.0){
            //Location seems pretty accurate, let's use it!
            NSLog(@"latitude %+.6f, longitude %+.6f\n",
                  newLocation.coordinate.latitude,
                  newLocation.coordinate.longitude);
            NSLog(@"Horizontal Accuracy:%f", newLocation.horizontalAccuracy);
 
            //Optional: turn off location services once we've gotten a good location
            [manager stopUpdatingLocation];
        }
    }
}

Now we can run the project again. If you didn’t authorize the app to use location services before, go ahead and do that now. We haven’t done anything with the location at this point except print it out to the console. If you don’t know how to see the console, make sure Xcode is the active window (NOT the simulator) and press ⌘⇧C

If you are running the project on the simulator and not a device, you may not see any results in the console window. This is because the simulator does not have location services turned on by default. You can simulate a location by selecting the location services simulation in the console window:

You can also simulate a location in the Simulator by using the Debug menu.

Once a location has been selected, you may need to restart the app to get the new location to show in the console window:

Because we built the location manager into the App Delegate, you can access the device’s current location anywhere in your code by including the AppDelegate header file (.h) in your view controller’s implementation file (.m):

#import "CFAAppDelegate.h"

Then whenever you need to access the location, you can use the following bit of code:

//Make sure location services are enabled before requesting the location
if([CLLocationManager locationServicesEnabled]){
 
    CFAAppDelegate *appDelegate=(CFAAppDelegate *)[UIApplication sharedApplication].delegate;
    CLLocation *currentLocation=appDelegate.locationManager.location;
 
    //Do what you want with the location...
}

About: Shawn Grimes
Shawn is a mobile app developer for ELC Technologies. He is a co-author of the book, iOS 5 Recipes: A Problem-Solution Approach (Recipes Apress). You can follow him on twitter @shawng. Shawn also works with high school students to teach them app development skills through the APPlied Club Program.

UIKit/UIKit.hp

• 

Here is a quick demonstration of the power of snippets

Type:

ttt

It generates:

#pragma mark - UITableView Datasource
 
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return 1;
}
 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return 10;
}
 
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *cellIdentifier = @"Cell";
 
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];
 
    if(cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellIdentifier];
    }
 
    cell.textLabel.text = [NSString stringWithFormat:@"Cell %d", indexPath.row];
 
    return cell;
}
 
#pragma mark - UITableView Delegate methods
 
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
 
}

As you can see, with 3 keystrokes, I now have a fully working table view implementation with sample data.

This article will be another introduction to XCode 4 snippets but focusing on how to set them up as well as share them with your team.

Adding A Snippet Inside Of XCode

In my opinion, this is not very obvious. The snippet library is fairly well hidden. To bring it up, first ensure that the right side bar is visible in XCode by selecting the right most option of the “view” pane in the top right corner of XCode.

Now that the right bar is available, click on the “{}” option of the bottom most pane. This will bring up the snippet library.

Feel free to browse the snippets that XCode ships with, however most of them are not very useful. So, now this is where I feel Apple engineers were a little too clever. It took me a little while to figure out how to actually add a new snippet. You would expect some sort of + button or something. The way you add a new snippet in this case is to write out a chunk of code and drag it into the Code Snippet Library window.

Once you drag the code into the library, it creates a default snippet called “My Code Snippet”. Which again, is just terribly non-obvious. Now, double click on “My Code Snippet”, and then click the “edit” button to modify it.

Let’s talk about each of the important fields:

1. Title – This is just the common name you will use to refer to the snippet. It will display during autocompletion
2. Completion Shortcut – this is the command you will use to invoke the snippet. For example, I have ttt to automatically create all of the UITableView delegate and datasource methods with sample data.
3. Completion Scopes – This is pretty cool. You can have the same shortcut to represent differnet snippets based on the scope of the document. For example, you won’t want to invoke your @property snippets inside of your Class implementation. So, they get ignored…

Adding dynamic fields

If you notice, many of Apple’s auto generated classes or snippets (like UIAlertView), have these “code bubbles” hinting at the type of data you should put into them. They are also nice because they allow you to tab between them enabling you to implement the code quicker. To add your own simply insert this into your code:

<#Text#>

Where “Text” is whatever you want the code bubble to say.

That’s it, when you are finished click done and you should now be able to use your snippets.

Sharing Snippets

While XCode doesn’t have an export button for snippets, they are in a fairly predictable location. They are located at:

~/Library/Developer/Xcode/UserData/CodeSnippets/

That being said, you could manually share them between developers (zip them up and email) OR you could version control this folder with something like git. I really like the latter approach. Any time a developer adds a new snippet to the library, the others just have to pull, restart XCode, and voila the snippet is there.

Conclusion

The only issue now is remembering to actually use your snippets in practice. It takes some getting used to, but I’m sure you will get it. Below, you can download a zip file containing many of the snippets that I use. Simply unzip it into the folder that I mentioned above.

Download My Snippets

Happy iCoding!

Follow me on Twitter

• 

What we are going to explore today is how to remedy that situation.
To download the entire XCode project, you can find it at: http://github.com/elc/ICB_PrettyTableView

We are going to build a simple contact viewer, that will display the phones contacts. For each contact, if they have a first name, last name, email and phone number, they will be displayed within one cell, with different colors. The reason this is useful is because it provides the basics for customizing UITableViewCells that can really start to make your application look nice, and still scroll well.
If you don’t want to have simulated data inside the simulator, check out this post for copying data from your device to the simulator: How to import contacts into the iphone simulator

In this example, we have a standard UITableViewController. We are going to have a couple class variables defined in the header

#import <UIKit/UIKit.h>
#import <AddressBook/AddressBook.h>
 
@interface ICBTableViewController : UITableViewController
{
    ABAddressBookRef _addressBook;
}
 
@property (nonatomic, retain) NSArray *contacts;
 
@end

ABAddressBookRef _addressBook is defined in our header, so that we don’t have to release it until we dealloc. And the contacts is so that we can hold on to the data for our tableView.
In the main table view controller file we are going to override the – (void)viewDidLoad to provide some initial configuration of the tableView, as well as loading or generating our data. (We will generate fake data for devices or the simulator that don’t have address book data)

- (void)viewDidLoad
{
    [super viewDidLoad];
    self.tableView.backgroundColor = UIColor.blackColor;
    self.tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
 
    ABAddressBookRef addressBook = ABAddressBookCreate();
    NSArray *tempArray = (NSArray *)ABAddressBookCopyArrayOfAllPeople(addressBook);
    tempArray = [tempArray sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
        NSString *name1 = (NSString *)ABRecordCopyCompositeName((ABRecordRef)obj1);
        NSString *name2 = (NSString *)ABRecordCopyCompositeName((ABRecordRef)obj2);
        return [name1 compare:name2];
    }];
 
    if ([tempArray count] > 0) {
        self.contacts = tempArray;
    } else {
        NSMutableArray *tempMutableArray = [NSMutableArray arrayWithCapacity:100];
        for (int i = 0; i < 100; ++i) {
            NSMutableDictionary *dict = [NSMutableDictionary dictionary];
            if ((i % 9) != 0) {
                [dict setObject:[NSString stringWithFormat:@"FirstName%d", i] forKey:@"firstName"];
            }
            if ((i % 3) == 0) {
                [dict setObject:[NSString stringWithFormat:@"LastName%d", i] forKey:@"lastName"];
            }
            if ((i % 3) == 0 && (i % 2) == 0) {
                [dict setObject:[NSString stringWithFormat:@"emailTest%d@test%d.com", i, i] forKey:@"email"];
            }
            if ((i % 7) == 0) {
                NSString *string = [NSString stringWithFormat:@"%d", i];
                while ([string length] < 10) {
                    string = [string stringByAppendingFormat:@"%@", string];
                }
                [dict setObject:string forKey:@"phone"];
            }
            [tempMutableArray addObject:dict];
        }
        self.contacts = tempMutableArray;
    }
}

As you can see here we have a couple of self.tableView methods we have called to setup the background color, and also the cell separator style.
If you are running this application on a device, or simulator that has contacts, this method will also make a copy of the address book as the data to display. If there is no data in the address book, we create some fake test data just for displaying.
Also don’t forget to include our – (void)dealloc method for releasing our _addressBook variable.

- (void)dealloc
{
    CFRelease(_addressBook);
    [_contacts release];
    _contacts = nil;
}

We have to supply the tableView with our number of rows

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [self.contacts count];
}

The next portion we have to override is the – (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath so that we can supply the tableView with our cells.

// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{   
 
    static NSString *CellIdentifier = @"ICBTableViewCellIdentifier";
 
    ICBTableViewCell *cell = (ICBTableViewCell*)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[ICBTableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] autorelease];
        cell.textLabel.textColor = UIColor.whiteColor;
    }
    cell.tag = indexPath.row;
 
    NSObject *object = [self.contacts objectAtIndex:indexPath.row];
    if ([object isKindOfClass:NSDictionary.class]) {
        [cell setDictionary:(NSDictionary *)object];
    } else {
        [cell setRecord:(ABRecordRef)object];
    }
 
    return cell;
}

We are checking each object coming out of our array so that we can determine if we need to call the setDictionary, or setRecord method calls.

Now the meat of this tutorial, extending a UITableViewCell.

In our header we are going to define a bunch of strings that we want to display

#import <UIKit/UIKit.h>
#import <AddressBook/AddressBook.h>
 
@interface ICBTableViewCell : UITableViewCell
 
@property (nonatomic, retain) NSString *firstName;
@property (nonatomic, retain) NSString *lastName;
@property (nonatomic, retain) NSString *email;
@property (nonatomic, retain) NSString *phone;
@property (nonatomic, retain) NSString *address;
 
- (void)setRecord:(ABRecordRef)record;
- (void)setDictionary:(NSDictionary *)dict;
 
@end

And then our two set methods:

- (void)setRecord:(ABRecordRef)record
{
    self.firstName = [(NSString *)ABRecordCopyValue(record, kABPersonFirstNameProperty) autorelease];
    self.lastName = [(NSString *)ABRecordCopyValue(record, kABPersonLastNameProperty) autorelease];
    self.email = [self getFirstEmail:record];
    self.phone = [self getFirstPhone:record];
    [self setNeedsDisplay];
}
 
- (void)setDictionary:(NSDictionary *)dict
{
    self.firstName = [dict objectForKey:@"firstName"];
    self.lastName = [dict objectForKey:@"lastName"];
    self.email = [dict objectForKey:@"email"];
    self.phone = [dict objectForKey:@"phone"];
    [self setNeedsDisplay];
}

Some tutorials will have you put this next part into a separate UIView subclass, and add that class as the contentView of this UITableViewCell, but I prefer to override the drawRect of the UITableViewCell, and do all my drawing there.

The first thing I am doing is getting the current graphics context so that we can draw to the screen, clipping to the rect that is passed in drawRect:(CGRect)rect, and then depending on whether this cell is even, I am filling the entire rect with an almost black color, or slightly lighter.

- (void)drawRect:(CGRect)rect
{
    CGContextRef ctx = UIGraphicsGetCurrentContext();
 
    CGContextClipToRect(ctx, rect);
    //If even
    if (((self.tag % 2) == 0)) {
        CGContextSetFillColorWithColor(ctx, [UIColor colorWithWhite:0.1f alpha:1.f].CGColor);
    } else {
        CGContextSetFillColorWithColor(ctx, [UIColor colorWithWhite:0.15f alpha:1.f].CGColor);
    }
 
    CGContextFillRect(ctx, rect);

The next thing I am going to figure out is whether I want this text to be centered in the cell, and I am determining this based off whether there is an email field or not.

    //Vertically center our text, if no email
    BOOL isCentered = (self.email == nil);

And now for the meat of the drawRect method. We calculate the size of firstName, draw it offset from the left by 5, and then draw lastName right after it. We also change the color we are drawing between those two.

    CGRect tempRect;
    CGFloat midY = CGRectGetMidY(rect);
    [[UIColor whiteColor] set];
    UIFont *defaultFont = [UIFont systemFontOfSize:16];
    CGSize size = [self.firstName sizeWithFont:defaultFont];
    if (isCentered == NO) {
        tempRect = CGRectMake(5, 0, size.width, size.height);
    } else {
        tempRect = CGRectMake(5, midY - size.height/2, size.width, size.height);
    }
    [self.firstName drawInRect:tempRect withFont:defaultFont];
 
    [[UIColor lightGrayColor] set];
    size = [self.lastName sizeWithFont:defaultFont];
    if (isCentered == NO) {
        tempRect = CGRectMake(CGRectGetMaxX(tempRect)+5, 0, size.width, size.height);
    } else {
        tempRect = CGRectMake(CGRectGetMaxX(tempRect)+5, midY - size.height/2, size.width, size.height);
    }
    [self.lastName drawInRect:tempRect withFont:defaultFont];

Next we find out if phone actually exists, and if so set the color to red, and draw it to the right of lastName. We also have to make sure we aren’t drawing this outside our boundaries, so we check to see where the end is, and if it is outside, we crop it to 5 pixels from the end.

    if (self.phone != nil) {
        [[UIColor redColor] set];
        size = [self.phone sizeWithFont:defaultFont];
        CGFloat end = CGRectGetMaxX(tempRect) + size.width;
        if (end > rect.size.width) {
            size.width = CGRectGetMaxX(rect) - CGRectGetMaxX(tempRect) - 10; //-10 so that we get 5 from the end of last name, and 5 from the end of rect
        }
        if (isCentered == NO) {
            tempRect = CGRectMake(CGRectGetMaxX(rect) - size.width - 5, 0, size.width, size.height);
        } else {
            tempRect = CGRectMake(CGRectGetMaxX(rect) - size.width - 5, midY - size.height/2, size.width, size.height);
        }
        [self.phone drawInRect:tempRect withFont:defaultFont lineBreakMode:UILineBreakModeTailTruncation];
    }

And finally if our email actually exists draw it on the bottom left.

    if (self.email != nil) {
        [[UIColor blueColor] set];
        size = [self.email sizeWithFont:defaultFont];
        tempRect = CGRectMake(5, midY, size.width, size.height);
        [self.email drawInRect:tempRect withFont:defaultFont];
    }

I hope this helps you in configuring UITableViewCells for your own project, and hopefully will let you start to think about the possibilities.

To download the entire XCode project, you can find it at: http://github.com/elc/ICB_PrettyTableView

• 

Fortunately there’s another option, with a tool called iPhone Backup Extractor. Download it, run it and click Read Backups (note that you’ll need to back up to iTunes, not iCloud). Select your device, and you should see a list of apps included in your backup. Choose the last item on the list, iOS Files, and extract it to your desktop. When it’s done take a look in the folder it created. You should find two files in the folder iOS Files/Library/AddressBook, AddressBook.sqlitedb and AddressBookImages.sqlitedb.

Next, open the simulator’s Application Support folder (in the Finder menu, choose Go -> Go to Folder…, enter ~/Library/Application Support/iPhone Simulator, and choose the SDK you’re working with) and drill down to Library/AddressBook. Quit the simulator if it’s open, delete everything in this directory, then copy the two files noted above from your backup. That’s it! If everything went well the next time you launch the simulator you should see all your contacts.

Pretty easy, really. If address book data is a major feature of your app, you might even want to have a few trusted beta testers send you their backups so you can test with their contacts. My experience is that there are a lot of unusual or invalid contacts floating around on people’s phones, and the more opportunity you have to test the better you’ll do once you release your app.

•