What is Oauth?

Twitter has a brief explanation of the difference between Basic Authentication and OAuth. They use the example of a letter and how it is addressed as their metaphor, and I think this gets the idea across clearly. You can see their entire explanation along with pros and cons here.

TL;DR With Basic Auth you would make every request and would include a username and password with each. This method is very insecure because it allows applications to actively hold user’s credentials and does not have any accountability for which application is performing what action on who’s account. If you imagine your Twitter account as a room, this is like having access to the room be granted based on a single key that many people have copies of. OAuth makes access to your room be granted by a key pad. And everyone that has access to the room has a different code they input into the keypad. You can see who came in and when and revoke anyone’s code at any time.

Twitter is evolving and now requiring that applications register. As a result, user’s gain more control over what services have access to their account. Additionally, Twitter can be more effective at targeting malicious applications, and developers can get more accurate feedback on the frequency of their app’s use throughout Twitter. With all this said, OAuth is tough to implement from scratch. So today we are going to go through the installation and use of a collection of classes that takes care of the dirty work for us, and let developers update the Twitter functionality of their application easily.

Required Classes

Today we are going to be building off a collection of classes that were created by several different people. The main portion of the class is the MGTwitterEngine which was created by Matt Legend Gemmell who’s website can be found here. From here, Ben Gottlieb took the classes and added his own drop in view controller to them. With all this together we have a simple view controller that will perform login and OAuth, and from there an engine that will perform any type of Twitter request we are looking to do. You can get a zip file of the root folder that contains all of these files here.

Installation

We are going to start out with a blank, view based iPhone project called iCodeOAuth. Once the project has come up, take the folder you downloaded called “Twitter+OAuth” and drag it into the “Other Sources” folder within Xcode. Make sure you check the box to copy the sources into the project folder. If we do a build now, you will get a ton of errors. That is because these classes require that libXML be a target of the project build as well. This can be accomplished by clicking the arrow next to Targets in the left column of the Xcode project. Here there will be an application called iCodeOAuth. If we right click on this and select Get Info we will see the info about our target. From here we click the build tab and search for the field “Header Search Paths”. You need to add the following into the Header Search Paths:

$(SDKROOT)/usr/include/libxml2

EDIT: I forgot to include here that you must also include a special XML library for the build to be successful. The Framework is called libxml2.dylib. You can find it at

/Macintosh HD/Developer/Platforms/iPhoneOS.platform/Developer/SDK/iPhoneOS4.1SDK/usr/lib

If you build again, you should see no errors and we can move forward with using this awesome set of classes.

Getting your Creds from Twitter

Now that we have these classes properly installed, it is time to take care of some registration requirements for OAuth. In order to use OAuth you must identify your app to Twitter. Once you do so, Twitter will provide you with an OAuthConsumerKey and an OAuthConsumerSecretKey. These are going to need to be provided to the classes we have just added into our project in order to talk with Twitter’s OAuth system. To register your application and get these creds go to http://dev.twitter.com/apps/new. I have created a application called the iCodeBlog OAuth Demo, whose credentials are included in the sample app which I have provided. For your own personal app you will need to go create your own Twitter Application and get your own keys.

Using SA_OAuthTwitter Engine

Ben Gottlieb used a great design pattern to create a very easy to use access point for the more complex MGTwitterEngine which lies underneath. In order to use these classes we will go into out view controller and add the following code to the header:

#import "SA_OAuthTwitterEngine.h"
#import "SA_OAuthTwitterController.h"
 
@interface iCodeOauthViewController : UIViewController  {
 
	IBOutlet UITableView *tableView;
	IBOutlet UITextField *textfield;
 
	SA_OAuthTwitterEngine *_engine;
	NSMutableArray *tweets;
}
 
@property (nonatomic, retain) IBOutlet UITableView *tableView;
@property (nonatomic, retain) IBOutlet UITextField *textfield;
 
-(IBAction)updateStream:(id)sender;
-(IBAction)tweet:(id)sender;
 
@end

And add the following into the Main

- (void)viewDidAppear:(BOOL)animated {
 
	if(_engine) return;
 
	_engine = [[SA_OAuthTwitterEngine alloc] initOAuthWithDelegate:self];
	_engine.consumerKey = @"PzkZj9g57ah2bcB58mD4Q";
	_engine.consumerSecret = @"OvogWpara8xybjMUDGcLklOeZSF12xnYHLE37rel2g";
 
	UIViewController *controller = [SA_OAuthTwitterController controllerToEnterCredentialsWithTwitterEngine: _engine delegate: self];
 
	if (controller)
		[self presentModalViewController: controller animated: YES];
	else {
		tweets = [[NSMutableArray alloc] init];
		[self updateStream:nil];
	}
}

This will instantiate our engine with the appropriate consumer and consumer secret keys. With this done we will create a controller. If you run the app now you will see a modal web view come up and lead to a sign in page for Twitter. This is a web view, but the great classes written by Ben are set up to programmatically handle the progression of these web views as the user signs in.

Scrolling to the bottom of this page there will be a username and password field to fill out. Don’t put in your Twitter credentials yet. We need to fill out a few delegate methods to handle the callback from SA_OAuthTwitterEngine.

Handling Login Callbacks

Insert the following into your main class.

 
-(IBAction)updateStream:(id)sender {
 
}
 
-(IBAction)tweet:(id)sender {
 
}
 
#pragma mark SA_OAuthTwitterEngineDelegate
 
- (void) storeCachedTwitterOAuthData: (NSString *) data forUsername: (NSString *) username {
 
	NSUserDefaults	*defaults = [NSUserDefaults standardUserDefaults];
 
	[defaults setObject: data forKey: @"authData"];
	[defaults synchronize];
}
 
- (NSString *) cachedTwitterOAuthDataForUsername: (NSString *) username {
 
	return [[NSUserDefaults standardUserDefaults] objectForKey: @"authData"];
}
 
#pragma mark SA_OAuthTwitterController Delegate
 
- (void) OAuthTwitterController: (SA_OAuthTwitterController *) controller authenticatedWithUsername: (NSString *) username {
 
	NSLog(@"Authenticated with user %@", username);
 
	tweets = [[NSMutableArray alloc] init];
	[self updateStream:nil];
}
 
- (void) OAuthTwitterControllerFailed: (SA_OAuthTwitterController *) controller {
 
	NSLog(@"Authentication Failure");
}
 
- (void) OAuthTwitterControllerCanceled: (SA_OAuthTwitterController *) controller {
 
	NSLog(@"Authentication Canceled");
}

We just implemented the SA_OAuthTwitterControllerDelegate and the SA_OAuthTwitterEngineDelegate. The SA_OAuthTwitterEngineDelegate methods take care of storing the OAuth data string in a plist so that when the app is launched again the user will not have to sign in. SA_OAuthTwitterControllerDelegate methods are callbacks depending on what happens upon sign in. In this case when sign in is successful another method in our class called updateTweets will fire. For now we have those methods defined but we don’t have them filled in. We will get to that in a few steps. If you run the application and login using some Twitter credentials, you should see a successful authentication message appear in your debug screen. With this done, let’s add some interface elements to our view controller XIB so that we can start interacting with Twitter. Our final product is going to look like this:

Building the Interface

To Build the interface open up the XIB for your view controller. We are going to be putting in 2 buttons, a UITextField and a UITableView. Lay the elements out like so.

Make sure to connect the delegate and data source of the table view to the file owner. Also connect the “Tweet This” button to the tweet method and the Update Tweets method to the updateStream method. Finally, make sure the IBOutlets for the UITextField and the UITableView are set. With these in place we can fill in the final methods to take advantage of our Twitter engine.

Filling in our IBActions

Put the following code in for the IBActions which we defied before.

#pragma mark IBActions
 
-(IBAction)updateStream:(id)sender {
 
	[_engine getFollowedTimelineSinceID:1 startingAtPage:1 count:100];
}
 
-(IBAction)tweet:(id)sender {
 
	[textfield resignFirstResponder];
	[_engine sendUpdate:[textfield text]];
	[self updateStream:nil];
}

The update stream method will ask our engine to get the Twitter timeline of the people you follow. It will retrieve the first page of the first 100 tweets. There is a delegate method that fires off on this request completing that we will fill out in a moment. The tweet method dismisses the keyboard and then uses our engine to send an update. Once the update is send we update the tweet view below.

Making a really simple Tweet Object

To help us with displaying tweets we are going to make a very quick Tweet object. This will be a simple NSObject subclass. Use this code for the header:

@interface Tweet : NSObject {
 
	NSDictionary *contents;
}
 
-(NSString*)tweet;
-(NSString*)author;
 
@end

And this code for the main

@implementation Tweet
 
-(id)initWithTweetDictionary:(NSDictionary*)_contents {
 
	if(self = [super init]) {
 
		contents = _contents;
		[contents retain];
	}
 
	return self;
}
 
-(NSString*)tweet {
 
	return [contents objectForKey:@"text"];
}
 
-(NSString*)author {
 
	return [[contents objectForKey:@"user"] objectForKey:@"screen_name"];
}
@end

Finally make sure to import the class within the main of your view controller class. These will simply give easy methods to get the info we want out of each tweet dictionary that the MGTwitterEngine will return to us.

Filling in our MGTwitterEngineDelegate Methods

The MGTwitterEngine is doing most of the heavy lifting here when it comes to interacting with Twitter. The methods we are using to get tweets and to send tweets are all defined within the MGTwitterEngine. There is also a defined MGTwtterEngineDelegate which defines the callback methods that fire upon these requests finishing. For the sake of completeness, I have filled out all the methods, although only a few of them will be called in the case of our application working properly. Insert the following code into your main.

#pragma mark MGTwitterEngineDelegate Methods
 
- (void)requestSucceeded:(NSString *)connectionIdentifier {
 
	NSLog(@"Request Suceeded: %@", connectionIdentifier);
}
 
- (void)statusesReceived:(NSArray *)statuses forRequest:(NSString *)connectionIdentifier {
 
	tweets = [[NSMutableArray alloc] init];
 
	for(NSDictionary *d in statuses) {
 
		NSLog(@"See dictionary: %@", d);
 
		Tweet *tweet = [[Tweet alloc] initWithTweetDictionary:d];
		[tweets addObject:tweet];
		[tweet release];
	}
 
	[self.tableView reloadData];
}
 
- (void)receivedObject:(NSDictionary *)dictionary forRequest:(NSString *)connectionIdentifier {
 
	NSLog(@"Recieved Object: %@", dictionary);
}
 
- (void)directMessagesReceived:(NSArray *)messages forRequest:(NSString *)connectionIdentifier {
 
	NSLog(@"Direct Messages Received: %@", messages);
}
 
- (void)userInfoReceived:(NSArray *)userInfo forRequest:(NSString *)connectionIdentifier {
 
	NSLog(@"User Info Received: %@", userInfo);
}
 
- (void)miscInfoReceived:(NSArray *)miscInfo forRequest:(NSString *)connectionIdentifier {
 
	NSLog(@"Misc Info Received: %@", miscInfo);
}

These methods are all very straightforward in their naming. The only one we fill out significantly is the statusesReceived:forRequest method. Here is where tweets will be returned to us, each as a separate dictionary when we request the timeline for a user. We will clear the tweets array that we have defined for our class and create a Tweet object for each of the dictionaries we have representing a tweet. From there we will ask our table view to reload. The only task we have left to perform is to fill in our table view data source methods to show all the tweets.

Table View Data Source and Delegate Methods

Now we have everything in place. We just need to create a UITableViewCell for every tweet we have. We will also do some tweaking of the size of each cell and the number of lines of each UITextField within each table view cell. These methods are very common so I wont go into much detail on them. Here are the necessary Data Source and Delegate Methods.

#pragma mark UITableViewDataSource Methods
 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
 
	return [tweets count];
}
 
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
 
	NSString *identifier = @"cell";
	UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:identifier];
 
	if(!cell) {
 
		cell = [[UITableViewCell alloc] initWithStyle:UITableViewStyleGrouped reuseIdentifier:identifier];
		//[cell setBackgroundColor:[UIColor clearColor]];
	}
 
	[cell.textLabel setNumberOfLines:7];
	[cell.textLabel setText:[(Tweet*)[tweets objectAtIndex:indexPath.row] tweet]];
 
	return cell;
}
 
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
 
	return 150;
}

With this in place you will have an OAuth twitter client that is capable of doing any type of interaction with Twitter. You can find the source for the project here. Please post any questions you have and happy coding!

Follow me on Twitter at @cruffenach

1. Create an NSURLConnection to request an XML response from the Stream.
2. Create a parameter string for the HTTP Body.
3. Respond to the authentication challenge with user credentials.
4. Append the data as it comes in and when a complete element is received parse the Tweets.

So lets dive in.

Creating the Class

The first thing that we need to do is establish a connection with the Twitter stream. I will not be creating a Twitter client class that can be plugged into any application you choose. You will be able to find the class as a download at the end of the post. We will call the class TwitterStreamClient. Lets first define the header file of the class.

#import
#import "TouchXML.h"
#import "Tweet.h"
 
@interface TwitterClient : NSObject {
 
	NSString *searchString;
	NSString *locationString;
	NSMutableString *holderString;
	id mapController;
	NSURLConnection *connection;
	NSMutableURLRequest *request;
}
 
@property (nonatomic, assign) id mapController;
 
-(void)startStreamingTweets;
-(void)makeMyRequest;
-(void)searchByLocation;
-(void)searchByTerm;
-(void)searchByUser;
-(void)parseXMLString:(NSString*)xmlString;
-(NSString*)locationStringForLongitude:(double)_long Latitude:(double)_lat;
 
@end

You will need to have TouchXML installed for this class to work. You can find installation instructions here. Let move onto the .m file of the TwitterStreamClient. First thing to do is create the initializer. Ours will look like this:

-init {
	if([self = [super init]) {
		holderString = [[NSMutableString alloc] init];
	}
 
	return self;
}

This holder string is what we are going to use to synchronize our incoming NSData from the service. We will see the reason for this in the next step.

Connect to Service

The Twitter stream provides many different parameters for users to pass into their request. You can see the full list here, but we will be focusing on user specific stream, keyword specific stream and location specific stream. We are going to be hardcoding what these will be searching for but in use you can pass in whatever values you like. We will create an NSMutableURLRequest and fill in its HTTP body with the appropriate request. First we will make a method to create the stream request.

-(void)makeMyRequest {
 
	request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:@"http://stream.twitter.com/1/statuses/filter.xml"]];
	[request setHTTPMethod:@"POST"];
}

With this done we will create three different methods that can be called. One that bases its search on keywords, another based on users and a final one based on location.

Request by keyword

-(void)searchByTerm {
 
	searchString = @"track=Love,Hate,Want,Need";
 
	NSString *httpBody = searchString;
	[request setHTTPBody:[httpBody dataUsingEncoding:NSUTF8StringEncoding]];
	connection = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES];
	[request release];
}

Request by User ID

-(void)searchByUser {
 
	searchString = @"follow=14402149,29089557,807095,19058681";
 
	NSString *httpBody = searchString;
	[request setHTTPBody:[httpBody dataUsingEncoding:NSUTF8StringEncoding]];
	connection = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES];
	[request release];
}

The final method will create a location string. The twitter stream requires passing in 4 coordinates, 2 coordinate pairs. This will define the southwest most point and northeast most point. The square that the coordinates define has a maximum of 1 degree length for any side of the defined box. My helper method takes in a longitude and latitude as a center points and creates as large an area as possible around it and returns the 4 coordinates as a string. Paste in the following code to search with center points on Tempe, AZ and New York, NY.

-(NSString*)locationStringForLongitude:(double)_long Latitude:(double)_lat {
 
	NSString *returnString = [NSString stringWithFormat:@"%f,%f,%f,%f",(_long-.5),(_lat-.5),(_long+.5),(_lat+.5)];
 
	return returnString;
}
 
-(void)searchByLocation {
 
	searchString = [NSString stringWithFormat:@"locations=%@,%@",
					  [self locationStringForLongitude:-111.932898 Latitude:33.419265],
					  [self locationStringForLongitude:-74.0 Latitude:40.7]];
 
	NSString *httpBody = searchString;
	[request setHTTPBody:[httpBody dataUsingEncoding:NSUTF8StringEncoding]];
	connection = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES];
	[request release];
}

Answering Authentication

The NSURLConnection will connect to the Twitter stream and then Twitter will ask for a username and password for the request. With the NSURLConnection’s delegate set to self we will implement the following method to answer the TwitterRequest.

- (void)connection:(NSURLConnection *)connection didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
 
	NSURLCredential *cred = [[NSURLCredential alloc] initWithUser:@"USERNAME" password:@"PASSWORD" persistence:NSURLCredentialPersistencePermanent];
	[[challenge sender] useCredential:cred forAuthenticationChallenge:challenge];
	NSLog(@"Received Challenge");
	[cred release];
}

This should satisfy the authentication challenge and the stream should start sending you data.

Receiving Data

Now the stream will start sending you data, it will coming into another NSURLConnection delegate method. The stream will send NSData into this method. The NSData can be parsed into a string and if you print it you will see output like this:

2010-05-21 14:05:17.491 TweetMapper[72280:207] Recieved Data from Stream:
 2010-05-21 14:05:17.919 TweetMapper[72280:207] Recieved Data from Stream:
  Fri May 21 21:05:17 +0000 2010
  14452520592
  Need some followers yo I jus got this twitter its pretty str8
  <a href="http://mobile.twitter.com" rel="nofollow">Twitter for Android</a>
false
 
  false
 
    144901351
    David Powell
    Ballaholic3223
 
    I'm a chill dude that love to play ball, hang out,  and uhhhh chillax...holla at me and we can be cool
http://a1.twimg.com/profile_images/907668616/VDG61D80_normal
 
false
    1
9ae4e8
000000
0000ff
e0ff92
87bc44
    0
    Mon May 17 16:17:15 +0000 2010
    0

2010-05-21 14:05:23.073 TweetMapper[72280:207] Recieved Data from Stream: e_background_color>
666666
2FC2EF
252429
181A1E
    5
    Fri Aug 01 08:10:36 +0000 2008
    0
    -28800
    Pacific Time (US & Canada)
http://s.twimg.com/a/1274144130/images/themes/theme9/bg.gif
false
 
    false
    false
 
    44
    en
    false

A response from the Twitter stream comes in as XML. An entire XML element that represents a single is a element. The status element seen here took two different calls to the didRecieveData method. Because of this we need to build in logic to recognize when a complete Tweet XML object is received and pass that onto our parsing method. This is what we use the NSMutableSting holderString for. You can see the completed method below.

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
 
	NSString *dataString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
 
	[holderString appendString:dataString];
	[dataString release];
 
	if([holderString rangeOfString:@""].location != NSNotFound && [holderString rangeOfString:@""].location != NSNotFound) {
 
		if([holderString rangeOfString:@""].location < [holderString rangeOfString:@""].location) {
			NSRange start = [holderString rangeOfString:@""];
			NSRange end = [holderString rangeOfString:@""];
 
			NSRange range;
			range.location = start.location;
			range.length = (end.location+end.length)-start.location;
 
			NSString *xmlString = [holderString substringWithRange:range];
 
			[self parseXMLString:xmlString];
 
			[holderString deleteCharactersInRange:range];
		}
	}
}

Here we receive data and append it to our holder string. We then check that both an opening and closing element tag is seen. If both tags are seen and the opening tag occurs before the closing tag, we create a substring in that range, pass the completed element to a method called parseXMLString and delete the characters from the holder string.

Parsing Data

Now that we have completed elements being grabbed out of the data we receive we need to parse out what we find as important. For the sake of extensibility I created a helper object called Tweet. A Tweet takes in tweet text, an author name, the authors Twitter URL, a timestamp, an image URL and a coordinate. This is the header for the class

#import
#import
 
@interface Tweet : NSObject {
 
	NSString *tweet;
	NSString *author;
	NSURL *authorURL;
	NSString *timeStamp;
	NSURL *authorImageURL;
	CLLocationCoordinate2D coord;
}
@property (nonatomic, retain) NSString *tweet;
@property (nonatomic, retain) NSURL *authorImageURL;
@property (nonatomic, retain) NSString *author;
@property (nonatomic, retain) NSURL *authorURL;
@property (nonatomic, retain) NSString *timeStamp;
@property (nonatomic, assign) CLLocationCoordinate2D coord;
 
-(UIImage*)authorPhoto;
-(NSURL*)tweetLink;
 
@end

I implement the class like this. I include a method called TweetLink which will return an NSURL of any url within the tweet text.

#import "Tweet.h"
 
@implementation Tweet
 
@synthesize tweet;
@synthesize authorImageURL;
@synthesize author;
@synthesize authorURL;
@synthesize timeStamp;
@synthesize coord;
 
-init {
 
	if([super init]) {
 
	}
 
	return self;
}
 
-(NSURL*)tweetLink {
	NSRange httpRange = [[self tweet] rangeOfString:@"http://"];
 
	if(httpRange.location == NSNotFound) {
		return nil;
	}
 
	else {
		httpRange.length = [[self tweet] length] - httpRange.location;
		NSString *customString = [[self tweet] substringWithRange:httpRange];
		httpRange = [customString rangeOfString:@" "];
 
		if(httpRange.location == NSNotFound) {
 
			httpRange.location = 0;
			httpRange.length = [customString length];
		}
 
		else {
			httpRange.length = httpRange.location;
			httpRange.location = 0;
		}
 
		NSLog(@"URL I am returning: %@", [customString substringWithRange:httpRange]);
 
		return [NSURL URLWithString:[customString substringWithRange:httpRange]];
	}
}
 
-(UIImage*)authorPhoto {
 
	return [[UIImage alloc] initWithData:[NSData dataWithContentsOfURL:authorURL]];
}
 
-(NSString*)description {
 
	return [NSString stringWithFormat:@"Tweet:%@\nAuthor:%@\nAuthor URL:%@\nPublished:%@\nLongitude:%f\nLatitude:%f\nAuthor Image URL:%@", tweet, author, authorURL, timeStamp,coord.longitude,coord.latitude, authorImageURL];
}
@end

I will use this class to create a single object holding all of the data I parse out of the XML elements I am looking at. All that is left to do is finish my parse method to get create these Tweet objects. This is my parse method that takes advantage of Touch XML and its awesome XML parsing methods.

-(void)parseXMLString:(NSString*)xmlString {
 
	CXMLDocument *document = [[CXMLDocument alloc] initWithXMLString:xmlString options:0 error:nil];
 
	if([[[[document rootElement] elementsForName:@"geo"] objectAtIndex:0] childCount] > 0) {
 
		Tweet *tweet = [[Tweet alloc] init];
 
		[tweet setTweet:[[[[document rootElement] elementsForName:@"text"] objectAtIndex:0] stringValue]];
		[tweet setAuthor:[NSString stringWithFormat:@"@%@", [[[[[[document rootElement] elementsForName:@"user"] objectAtIndex:0] elementsForName:@"screen_name"] objectAtIndex:0] stringValue]]];
		[tweet setAuthorURL:[NSURL URLWithString:[[[[[[document rootElement] elementsForName:@"user"] objectAtIndex:0] elementsForName:@"url"] objectAtIndex:0] stringValue]]];
		[tweet setAuthorImageURL:[NSURL URLWithString:[[[[[[document rootElement] elementsForName:@"user"] objectAtIndex:0] elementsForName:@"profile_image_url"] objectAtIndex:0] stringValue]]];
 
		NSString *coordinateString = [[[[[[document rootElement] elementsForName:@"geo"] objectAtIndex:0] elementsForName:@"point"] objectAtIndex:0] stringValue];
		NSRange range = [coordinateString rangeOfString:@" "];
		NSRange lon;
		lon.location = 0;
		lon.length = range.location;
		NSRange lat;
		lat.location = range.location+range.length;
		lat.length = [coordinateString length] - lat.location;
 
		double longit = [[coordinateString substringWithRange:lon] doubleValue];
		double latit = [[coordinateString substringWithRange:lat] doubleValue];
 
		CLLocationCoordinate2D coord;
		coord.longitude = latit;
		coord.latitude = longit;
 
		[tweet setCoord:coord];
 
		//PASS TWEET ONTO WHATEVER CLASS WILL USE IT
 
		[tweet release];
	}
}

Usage

Make sure that you install Touch XML and import the MapKit framework when using this class. Customize the terms, users and coordinates for the stream method to fit what you need it for. All that will be required to use the class is the following to create and begin parsing:

TwitterClient *client = [[TwitterClient alloc] init];
[client makeMyRequest];
 
[client searchByTerm];
 
OR
 
[client searchByLocation];
 
OR
 
[client searchByUser];

Fillin the very end of the parsing method to send the tweets off to whatever part of the application you want to use them in. I hope this introduction will help you guys add live twitter streams into your apps. Happy coding!

Source Downloads

TwitterStream

Stay tuned for the next game programming tutorial. Should be up soon…

Happy iCoding.

For those of you Twitter Fans out there, you can now subscribe to iCodeBlog.com via twitter. Every time a new post is added or updated, my blog will automatically post a tweet to twitter. I subscribe to a few blogs via twitter and feel this is a valuable tool for sharing content.

So if you prefer twitter to RSS, subscribe now!