Kristian Seno Games

Simple Core Data Tutorial

2011-07-18T23:55:00.000-07:00

This is our long overdue Core Data Tutorial. We are going to create an app similar to our SQLite3 tutorial. Where we store the NBA player's name and nickname (well in SQLite3 tutorial it was name and team) in a Core Data storage.

Quick guide about Core Data- it provides an abstraction from our persistent store, which for most of the time is still going to be SQLite3. But instead of manually writing SQL statements and accessing SQLite3's C API, we are going to do our saving and fetching all in objective C.

In Core Data, a table is an entity description and a table field is an attribute of that entity. In runtime an entity becomes an NSManagedObject or a subclass of it. It sounds complicated I know, but its not as hard as you think.

We also need an NSManagedObjectContext which we get from our app delegate. We get this free when we check the use core data storage checkbox when we create a new project. Now the managed object context is a scratch pad that monitors changes to our object and it is the one in charge of executing saves and retrievals. For instance, it makes sure that we don't have an object that is only partially saved.

So lets get started!

This is how our final app will look like:

The first view lets you create a player name and player nickname. After you press save it pushes to a table view that lists all the players that were saved in our core data.

So open xcode > create new project >window-based application with core data sa storage checked > name it players_SG.

First lets create our data model in Core Data. Right under your resources folder, you will see players_SG.xcdatamodeld. Click that and you will see players_SG.xcdatamodel. This is what we need. Double click to open it in our model editor.

Create an entity by clicking the plus (+) button near area (1). Then change the name (3) to Player. We'd like to capitalize the first letter of the entity name and small caps for our attribute name later. Notice that the class is NSManagedObject, that is because at run time, our data becomes an NSManagedObject. If you wish we can also subclass NSManagedObject. But we won't be doing that in this simple tutorial.

Then create an attribute by clicking plus (+) at area (2) select add attribute. At area (3):

Make the attribute Name: name.

Leave the optional checked. This means that the value of name can be nil. Transient means attributes are used to store non standard objects for which there is no pre-defined type. Now, change the type to String. At runtime this becomes NSString. Well, obviously right. I told you its not that difficult. You can also specify min max length, reg ex and default value. But we don't want to limit our user from creating the name of a certain player so lets keep it a simple string.

Next make another attribute named: nickname. Also optional and String. Now save our data.

Lets move to code. Go to resources folder, right click add> new file> UIViewController subclass, with nib. Save as addViewController.

Edit addPlayerViewController.h.

We add two outlets for our nib. And a method to save our data to core data.

Now at the implementation file. Synthesize our outlets.

After @implementation addPlayerViewController

type:

synthesize nameTextField, nicknameTextField;

at the dealloc

type:

[nameTextField release];

[nicknameTextField release];

Press command-B to build the project without running it. We need it to connect our outlets to our UI in Interface Builder.

Double click addPlayerViewController.xib. Edit it at IB to look like this.

Connect your textfields to the approprite outlets. Control-click from file's owner to the top textfield, select name. Do the same for the second textfield, select nickname this time. Select the top textfield and press command 1 to toggle the attributes inspector. At placeholder: type name. So the label "name" appears as a light gray label inside our textfield. It saves us having to drag a label on top of our textfield to mark it as the "name" textfield. Plus, I think its better UI. Now, do the same for our next textfield, this time change the placeholder text to "nickname".

Control -s to save the nib, now go back to xcode.

In our viewDidLoad, we just create a save button in our navigation controller on the upper right corner of the screen. This button calls the method savePlayer when pushed. So we implemented in our -(void)savePlayer.

First we create na instance of ListViewController. Which is the table view for the players. Sorry for including this here, we will create it a little later don't worry.

For our core data to work, we first need to get our managed object context from our appdelegate's property.

Then we create an NSManagedObjectContext using the NSEntityDescription insertNewObjectForEntityForName. We name it Player because as you remember in our data modeler, our entity's name is Player. Next we populate our entity by calling setValue: forKey: in our NSManagedObject. In a way this is quite similar to NSDictionary right? Here we just set the value of our name attribute to whatever the user types in the nameTextField. And our player's nickname to whatever the user types in our nickname textfield. Easy right?

Now to save it we need to declare an NSError object just in case we need it when the save is unsuccessful. As you remember, I said it is the NSManagedObjectContext's job to save. So the call [context save:&error]; saves our data to our model. We can also create an if statement to log errors in case this fails.

The next line just pushes the table view with all the saved records. So lets do that now...

Go to classes folder, right click select add new file>UIViewController> check subclass of UITableView Controller, no nib for this. Name it ListOfPlayersViewController.

Edit the interface file:

First thing we do is to make our class conform to the NSFetchedResultsControllerDelegate. This makes it easier for us to display our managed objects from core data to a table view. It also gives us a lot of functionality for free like sections, and gives us the ability to edit and delete entries in core data by deleting rows in our table view. Cool huh?

In our instance variable, we declare an NSFetchedResultsController object and our NSManagedObjectContext. Then we make our NSFetchedResultsController as a property so that we can have getters and setters for it.

Now head on to our impelementation file.

In our viewDidLoad, we just created an edit button on the right side of our navigation controller. Also typed in our title.

Now the next method is the getter method for our fetchedResultsController, as I said we need this so our table view can conviniently display our core data entries.

First we check if we already created our instance of fetchedResultsController. We lazily instantiate if not.

To create our fetchedRequestController we first need to get to our context, again its from our app delegate. Then we create an NSFetchRequest. This is like a SQL statement for requesting objects from our tables. We create a fetch request by passing it an NSEntityDescription, like what table do we want our DB to query, if this were SQL. It also lets us narrow a search by giving us a chance to pass it an NSPredicate. Though we won't do that here, because we want all our data presented. Also, it gives us a fetch batch size, in case you have gazillions of data in your persistence store, your iphone won't fetch all of them at the same time, only the batch size.

Next we pass an array of sort descriptor. Its an array because it will sort first by using the first sort descriptor and moves on the next. Kinda like sorting the lastnames first before sorting the firstname.

Then after we have our fetch request object. We can create an NSFetchedResultsController and then pass our fetch request object to it. The section name key path is just which attribute or relationship is used to make the sections in our table view.

Then we declare the self as the NSFetchedResultsController delegate. That means we have to implement its methods.

Then we let it performFetch. Which is the actual command to fetch our records from core data.

These methods are responsible for coordinating the core data entries with the table view entries. So if you for example delete a cell from table view, it also deletes the same one from core data.

For more details on this methods, head on over to apple's documentations, where I literally copy pasted these methods. :)

Lets go hook our table view methods to our NSFetchedResultsController:

Again I grabbed this from apple's documentation. It just makes sure to display the correct number of sections, correct number of rows in the section, correct title of the section's header,and the correct cell to display in a given row. It also has the method for editing the table view, in this case the deletion of a cell.

Pay attention to cellForRowAtIndexPath: method. Here, we get our NSManagedObject Player from our NSFetchedResultsController. Then we extract our name and nickname from the player using the valueForKey: method. Then we display it to our table view.

Now, our table view is synced with our core data, using the NSFetchedResultsController. It also gives us free functionality like, deleting rows and displaying sections in our table view. Not too bad eh?

Build and run! Enjoy!

Simple SQLite Tutorial

2011-07-03T03:01:00.000-07:00

We are going to create a simple app that gets data from an SQLite database. We will be using SQLite's C API to do this. As I said, this tutorial will keep things simple. Our app will just be displaying data, it won't be inserting data in the database, at least not yet in this tutorial.

So let's get started.

SQLite is a lightweight database that is embedded in the iPhone. And, it is already present in our macs, and we can easily use it through the terminal. All we need is a few SQL know how.

Open terminal.

Type this command: sqlite3 players.sql

This runs sqlite3 and creates a database named players.sql.

Now lets create a table named player that has 3 columns, id, name and team. Id is an integer that uniquely identifies the player entry, this is our primary key. The name would be the name of an NBA player and the Team would be the team name he plays for.

Type: CREATE TABLE player (id INTEGER PRIMARY KEY, name VARCHAR, team VARCHAR);

Note: Don't forget the semicolon. SQL statements should have them at the end.
This creates our player table with the corresponding 3 columns I mentioned.

So, its time to put entries into our database table.

Type: INSERT INTO player (name, team) VALUES ('Lebron James', 'Miami Heat');
This adds an entry with name of 'Lebron James' and team 'Miami Heat'.

Add more entries to our table:

What we are doing here is just adding more rows to our table, go ahead and add some more if you like.

After this open xcdoe > start new project > window based application. Name it players.

First thing we do when we use SQLite3 in our project is to add both our database in our resources folder and add the SQLite framework.

Copy players.sql from the folder you saved it into. I happened to save mine at the Desktop, as seen from the picture above. Copy it into your resources folder, check "Copy items into destination's folder". (I added my database this way, but I actually , as did a lot of other people in some coding forums, had problems, because the database that was added was empty. I will discuss the remedy to this later).

After copying our database file lets add our sqlite3 framework. Go to our frameworks folder, right click >add > existing frameworks...>libsqlite3.0.dylib.

Now lets go to our code. Edit playersViewController.h:

Here, we import sqlite3.h. Declare an sqlite3 object that will be our database handle. We also declare 2 other ivars: an NSMutableDictionary, which we will use to hold a row of players data. The keys of the dictionary would be name and team, and the values would be the player's name and his team. This dictionary would then be stored in an array. Such that every object in the array would correspond to one row in the database. We would need these ivars to populate our table view later on.

And oh, dont forget to make playersViewController a subclass of UITableViewController.

Also, declare a conveniece method - (void)loadDatabase;

Now lets go to our playersViewController.m:

Here we implement the first part of our convenience method. First we get the path to the players.sql we added earlier to our file. We do this by using the NSSearchPathForDirectories function. The first argument means we are looking for our Documents folder. Here are the other Directories in there:

Now, the function would return to us an Array, but it only has one object in it. So we grab that object using objectAtIndex:0, which returns us an NSString. Then we append the path component players.sql so we have the full directory path to players.sql.

Then we use the next lines of code to see whether our players.sql is exactly in our directory by using

[fileManager fileExistsAtPath:databaseDirectory]. We log our result in the console, with the exact directory of the database. We do this so we can remedy the problem with potentially adding an empty database file. In my experience my players.sql was added to the directory address but it was empty, it didnt have the player table nor the columns and the data I inserted into it. So as a remedy, using finder, navigate to the directory path logged in the console and copy paste our players.sql into that folder. This guarantees that we added a players.sql that is not empty.

Now, lets continue to our loadDatabase method:

First we open our database, using sqlite3_open(). First argument is the databaseDirectory we created earlier, we convert it to a C string using UTF8String. Second argument is our database handle. The if just checks whether or not we opened the database successfully. If we failed we just close our database (standard procedure accdg. to SQLite docs) and log our error message.

After successfully opening the database, we declare our SQL statement, which will retreive all entries from our table. Next we declare sqlite3_stmt object which is an SQLite3 binary compiled statement.

Next we compile our SQL statement into a byte-code program (our sqlite3_stmt) using sqlite3_prepare_v2.

The first argument is a database connection obtained from a prior successful call to sqlite3_open(). The second argument is the statement to be compiled, encoded as UTF-8. The third argument is the maximum length of sql statement in bytes, when we pass a number less than zero, then sql is read up to the first zero terminator. Next argument is our statement handle, our sqlite3_stmt object. Last argument is the pointer to unused portion of Sql, but since it is read up to the first zero terminator, we will pass in NULL.

After a prepared statement has been prepared using either sqlite3_prepare_v2, the sqlite3_step() function must be called one or more times to evaluate the statement. If the function returns SQLITE_ROW means that there is another row of data ready.

We then get that row of data, by using the sqlite3_column_text(), where we pass our compiled statement and the column number we want to access. First column is 0 second is 1, much like an array. Our name column is the second column in our table so we use 1. Similarly, team is the third, so in the next line we use 2.

This function returns a C string, so we turn it to NSString using stringWithUTF8String method. Then we store the playerName and playerTeam strings in our dictPlayers dictionary, which holds the data for an entire row. We then add an entire row's data to our arrayPlayers. Which holds all the rows of data from the database. Easy right? We then release the dictPlayers, so that when the while loop starts again for the next row, we will start with a blank dictPlayers dictionary.

We then finalize our statement after stepping thru all our rows to release the resources we used in compiling it.

Now, we have effectively retreived our data from an SQLite database and turned them into objective c objects (our NSMutableArray of NSMutableDictionaries of NSStrings).

Lastly, lets do some basic table view stuff, so our data shows up in a table view.

First we implement the tableView:numberOfRowsInSection: method and give it the number of objects in our arrayPlayers. Then we implement tableView:cellForRowAtIndexPath:, where we get a particular player's data from our arrayPlayer. We then put it in aPlayer. Then we extract the object for key @"name" and @"team", which we set as our cell's textLabel and detailTextLabel respectively. That should take care of our table view.

Now, its time to add our table view to our view. Go to playersAppDelegate.m:

Thats all there is to it. Build and Run. You should see the name and the team of our players in the table view! Yey!

For questions and suggestions hit the comments. Thanks!

Adding Icons to our movies and flickr App

2011-06-24T01:30:00.000-07:00

If you followed our movies app and flickr app tutorials, and feel that there is something lacking. There is, we dont have an icon. So lets add them.

Download the files here.
movies icons
flickrer icons (the flickr app)
zneaker icons (the simple tab bar app)

There are two png files. One for retina display, and one for non hd. Just add the unzipped pngs to the resources folder and check "copy items into destination group's folder". Notice that the names are icon.png and icon@2x.png. Well, if you want to send your app to the app store someday, you would want to stick to this naming convention. The icon.png is non-hd and the @2x is the retina display version. Well, once you've copied it your done! Enjoy our new icons.

Creating a REST Web Service App with Rotten Tomatoes API and SBJson Framework

2011-06-21T08:14:00.000-07:00

We will create an app that will display a list of upcoming movies and their review scores in a table view. We will get our data from Rotten Tomatoes my favorite movie review site. But to be able to access their web service, we would need our own API key. We can get one by registering here: http://developer.rottentomatoes.com/.

The Rotten Tomatoes API uses a RESTful service and it returns a JSON response. So to parse our response we would need to use the SBJson framework.

Now, lets get started. Create a view based application in xcode. Name it "movies".

Edit moviesViewController.h:

Notice that we modified it to be a subclass of UITableViewController.

Edit moviesViewController.m:

Here, we create our URL string to communicate with the rotten tomatoes API. Just replace the blackened out portion with your own API key. This string is turned into an NSURL object by calling the URLWithString method. Then, we create JsonString to receive our response, by calling the initWithContentsOfURL. You may uncomment the NSLog to view the structure of the JSON string returned to us by the web service.

Next we copy our SBJson files into our classes folder. Then import "JSON.h" in our moviesViewController.m, so we can create our SBJsonParser *parser object. Then we call its objectWithString: method, where we pass JsonString (our response string). This returns an NSDictionary object which we pass to our ivar dictionaryJson. We then release our parser because we don't need it anymore. Simple isn't it?

After that we grab an array of movies from our dictionaryJson. This is now the list of upcoming movies we will be displaying in our table view.

So lets implement our table view delegate methods.

In numberOfRowsInSection, we just return the number of objects stored in the movies array. Then in cellForRowAtIndexPath, we get a particular movie from our movies array, then we get its title. Then we get its rating, which returns a critics score and an audience score. We grab the critics score in particular. We then display the movie title in the table view cell's textLabel property, and the critic's score in the cell's detailTextLabel property. Easy right?

Don't forget in our dealloc add:

[movies release];

Then we go to our moviesAppDelegate.m:

Here we just create our moviesViewController. Give it a title. Then make it the root view controller of a UINavigationController. We then release our instance of moviesViewController after passing it to the navigation controller. Then we add the navigation controller's view to our window.

Make sure #import "moviesViewController.h" is present at the top of our moviesAppDelegate.m.

Build and Run! Now we can plan our next movie using this simple app! Enjoy!

A Simple Tab Bar Application Tutorial

2011-06-21T05:52:00.000-07:00

We are going to create a simple tab bar application, using the tab bar application template in xcode. Most of our UI will be done in interface builder, and we are only going to write a few lines of code.

This is how the final app is going to look like.

So, lets get started.

1. Open Xcode. Create a new project.
2. Select iOS application, Tab Bar Application.

3. Name it MyTabBar.

4.Note that under the classes folder, you have these files automatically created for you.

5. Double click on MainWindow.xib to look at it in Interface Builder.

6. Click the first tab of the Tab Bar Controller.

7. Go to the identity inspector. (after selecting the first tab,press command 1)Notice that the value of the class field is FirstViewController. This means that it is connected to the FirstViewController in our project file.

8. Also notice that there is no SecondViewController in our project file, and that the second tab is not connected to any class in its identity inspector. We will have to create a new one ourselves later.

9. But for now, let us create the UI for our FirstViewController. Go back to XCode and double click FirstView.xib to open in interface builder.

10. Edit it. Add a label, an image view and a text view. Arrange them like so. The label’s text is “Air Jordan 3”. Click the file’s owner icon. At the identity inspector (command 4), make sure that the class is set to FirstViewController.

Also, to make the text view scrollable, make sure that in the attributes inspector (just press command 1 to bring up the attributes inspector) , the editable check box is unchecked. Also check the scrolling enabled. Also, most importantly, scroll way down and check the user interaction enabled. (this took me quite a while to figure out).

11. Save it. Go back to XCode.

12. Edit FirstViewController.h

13.Edit FirstViewController.m

Add this line after the @implementation FirstViewController:

@synthesize aj3ImageView, aj3History;

Add these lines in the - (void)dealloc method: (just memory management stuff)
[aj3History release];
[aj3ImageView release];

14. Now lets add a new file to connect to our second tab. Right click the classes folder > add > new file... UIViewController subclass. Make sure to check the “With Xib for user interface” check box, leave the other 2 unchecked. Name it “SecondViewController”

15. Right click SecondView.xib under the resources folder and delete it. Make sure to select “also move to trash”. We are not going to need it since we will now be using the “SecondViewController.xib” that came with the new file we just created. (although we could use it, I find that using the new xib that came with our new file easier).

16. Now open MainWindow.xib. Select View Controller (second) under Tab Bar Controller. Go to Identity Inspector (command 4), under class, select the drop down text field, then select SecondViewController. This will now connect the SecondViewController class and xib to the tab bar controller. Then go to the attributes inspector (command 1), then for NIB name select SecondViewController. Save it.

17. Now, edit SecondViewController.h:

18. Edit SecondViewController.m

Add this line after the @implementation SecondViewController:

@synthesize aj5ImageView, aj5History;

Again, add these lines in the - (void)dealloc method:

[aj5History release];
[aj5ImageView release];

19. Press command B to build the project, so we can connect our outlets in Interface Builder.

20. Open SecondViewController.xib. Add a label, a text view, and an image view just like the FirstView.xib. Dont worry if it does not have the black tab bar at the bottom. It will show on the final build. Click the file’s owner, under the identity inspector, make sure the class is SecondViewController. This is just similar to what we did in the FirstView.xib.

21. Now control-click drag from the file’s owner to the image view and select aj5ImageView. Likewise, control-click drag from file’s owner to the text view and select aj5History. Save it. (If the outlets don’t show, it could mean the file’s owner’s class was not set to its appropriate view controller, or you didn’t build the project yet).

22. Now open FirstView.xib. Control-click drag from the file’s owner to the image view and select aj3ImageView. Also control-click drag from file’s owner to the text view and select aj3History. Save it.

23. Now download the zip file of the 2 image and 2 text files that we need. Since I like sneakers, I chose air jordan pics and description. You can choose some other stuff you like, no biggie. Also download the 2 tab images I got from glypfish.com.

tabBarTutorial.zip

24. Now add these files to the resources folder in XCode. Just drag them over. Make sure to check “Copy items into destination group’s folder”, or things will go bad.

25. Now change FirstViewController.m. In the viewDidLoad, add these:

This just sets the aj3ImageView to the image file we want to show up. Then we get the path to the text file that contains the description, then we get the string it contains and we set the aj3History text view outlet to that string.

26.Similarly we edit our SecondViewController.m

27. Now let’s build and run!

28. Ok it works! But the tabs still does not have the images, it just has the title.

29. Easiest thing ever, open MainWindow.xib, click the first tab wait a sec then click it again, this selects the tab bar item. Go to the attributes inspector (command 1), make sure it reads “Tab Bar Items Attributes”. In Image drop down text, select “21-skull.png”. Also change the title to “AJ 3”.

30. Then do the same thing for the next tab bar item. Set its image to “34-coffee.png”, and title to “AJ 5”. Now we’re good to go! Build and run!

Creating a Flickr App Using NSXMLParser, UITableView and SOAP Tutorial

2011-06-18T20:32:00.000-07:00

We will create an app that will search photos from flickr, put them in a table view, then display that photo in a webview. We will use SOAP to send our request to flickr. We will receive a corresponding SOAP response, which we will parse with NSXMLParser. There won't be a lot of explanations about the flickr API or about SOAP, I will just be running you through the creation process of this app.

Create a view based application. Name it WebServices. We don't need a nib file for our table view, so dont add one. (I started with the table view, the middle picture, and I didn't create a nib). We would, however need to add two more view controllers later which would need nibs.

Edit WebServicesViewController.h

Dont worry about the "DetailViewController.h" in the import section, we will add that later...

All we did was to create our model. Anyway lets edit the WebServicesViewController.m

Near the import section add these:

The define statements just creates a macro to show the network activity indicator everytime we send and receive data from the flickr web service. Then we synthesize our model.

Also add these:

First, get an api key from flickr. You can get one here:http://www.flickr.com/services/api/

When you get your own api key, subsitute it to the blackened out part of the code. We then create our SOAP request in the soapMsg string. Then we create our NSMutableURLRequest. We plug in our url. We also plug in our HTTP header values, set our method to POST, and set our body to soapMsg, which we turn into an NSData by sending it the message "dataUsingEncoding:" .

Then we create a NSURLConnection using the NSMutableURLRequest we just created.

When we connect to the web service of flickr, a bunch of NSURLConnection methods will be called, so lets implement them.

The "connection: didReceiveResponse:" method gets called as soon as we receive the response from the service. We create an NSData to receive the data we will get from connection: didReceiveData:. We release our NSData object and our connection if we fail in connection: didFailWithError:.

In connectionDidFinishLoading we get our completed NSData *webData and convert it to NSString to clean up the syntax.
This is how the xml file looks before we clean it up.

This is the "after" picture.

Now lets parse the XML. Lets implement the NSXMLParser methods.

We just parse out the title, server, farm, secret, photo id. These are stored as attributes, so we "get" them from the attributes dictionary that was passed to us, from the method: parser: didStartElement: namespaceURI qualifiedName: attributes:. We don't do anything in parser foundCharacters, because there is nothing between the photo tags, everything is stored as attributes. Then at parser didEndElement we reload our tableView, which we are about to implement next.

Here we just set our numberOfRowsInSection to the number of entries in the photoTitle array. We also set the cell's textLabel and detailTextLabel to the title and the Id respectively. In didSelectRowAtIndexPath we just pass the contents in one of our model (our arrays) to our detailViewController's properties, which we will be creating next.

But before we do that, make sure our model is released in dealloc.

Ok, now let's create our detailViewController. Go to classes folder, right click, select add new file, UIViewController subclass, don't check "with xib for user interface".
In DetailViewController.h, add these:

In DetailViewController.m, add these:

Here we synthesize our model. In loadView, we create a web view that spans the entire screen. We also create method that creates a url string, passing in the parameters of our photo to flickr's server. Then in viewWillAppear we call load our url request that we created in the pictureAddress method.

We will then have the activity indicator activate while we are loading our photo from flickr. We do this by implementing a couple of methods.

ShowNetworkActivityIndicator() and HideNetworkActivityIndicator() are just macros we define as:

Then some house keeping at dealloc:

That takes care of our DetailViewController, now lets create the SearchViewController, the first view of the app.
Right click the classes folder and add a UIViewController with "Xib for user interface".
Then add these in the SearchViewController.h:

Press command b to biuld. Open the SearchViewController.xib, add a UITextField, UIImageView and a UIButton. Arrange them like this:

imageView image
Download the imageView's image from the link above. Drag and drop the image file into your resources folder in xcode. Make sure to check "copy items into destination folder" checkbox. In interface builder, click the image view, press command 1 to bring up the attributes inspector. In image, select "my_flickr_app.png".

Control drag from the file's owner to the text field, and select searchField. Control drag from the button to the file's owner and select searchBtnClicked:. Save and quit.

Here we just synthesize our outlet. We also implement our IBAction. We also implement our search method. We just create an instance of WebServicesViewController pass the contents of out searchField's text to the photoSearch property of our WebServicesViewController (the photoSearch property is just inserted into the SOAP xml string request we created in the first part of this tutorial). We then push the instance of WebServicesViewController to our navigation controller's view.

In viewDidLoad, we just declare our class as the delegate of the searchField. This is done so we can implement the textFieldShouldReturn method, where we want the keyboard to disappear after we press the return button. We also want it to call the startSearch method. Then we clean up our outlet in dealloc.

Ok, now lets go to our WebServicesAppDelegate:

Import all the necessary header files. And in application didFinishLaunchingWithOptions, create an instance of SearchViewController. Make it the root view controller of our navigation controller. Give it a title. Then release the svc (after passing it to the navigation controller we dont need it anymore so we release it). Then make sure to add the nvc's view to our window's subview. So that's it! Build and run and enjoy being able to search for photos in flickr using it's SOAP API. :) For questions, hit the comments.

New App soon to be on the App Store

2011-04-11T18:17:00.000-07:00

Toy Car Crossing App

Toy Car Crossing is a free game which will soon be available for download in the App Store. Test your driving skills by driving an animated toy car through a busy street intersection, where other toy cars cross! Move the car using the accelerator pedal and stop it with the brake pedal. Use the shifter to move either forward or backward. Don’t forget to cross before the time expires. The game features five levels of challenging fun.

Supports retina display.