Submitted by rdominelli on Tue, 03/09/2010 - 09:30
What Can You Say About Chocolate Covered Manhole Covers was the title of a short story by Larry Niven back in 1966. What can you say about a blog with posts of only 140 characters? Is the question most folks ask when confronted with Twitter for the first time. The short answer is plenty. Twitter is used as an aggregation service, crowd sourcing social network, customer service channel, marketing channel and way for friends and families to keep in touch with each other.
Created in 2006 by Odeo, Twitter is the worlds most popular microblog . Microblog is a term which describes a blogging system where each post is extremely short - in twitters case 140 characters. Twitter spent a year or so as a toy for the Technorati. Slowly the appeal became mainstream and today most companies, news agencies and Hollywood stars have Twitter accounts in some cases with millions of followers. Breaking news will often appear on Twitter long before appearing on network news sources. A fantastic example of this was the protests and riots surrounding the 2009 Iranian elections. Twitter users were clued into this news event a full 12 hours before mainstream media started covering it.
Integrating the Twitter api into your application gives you the ability to search for topics, view what the net is buzzing about, post status updates, achievements, game scores, screen shots and other URL’s programmatically and generally inform your users social network of what he’s up to.
The Twitter API
Twtter’s documentation splits the API between the Search API (read only searching type methods) and the REST API (profiles, posts, friend following information etc). Confusingly both are REST based, and the split comes from the fact that both were developed separately.
REST stands for REpresentational State Transfer. In a nutshell this means the program acts like a web browser when communicating with the service. Parameters are passed using either http headers or in the URL as parameter. This is a straightforward method of interfacing with a service where a client issues a request and receives a numeric status code along with the returned data.
Request Limits
To keep the Twitter service from getting overwhelmed (A frequent problem not too long ago), Twitter imposes a limit of 150 REST requests per hour. The request limit is applied against your account (if the request contains authentication information) or against a given IP address, if the request does not include authentication. At this time these limits only affect the requesting of data, posts/status updates do not count towards this limit, although the API documentation very clearly states that this policy is subject to change at their discretion.
Twitter Application 1 - The Search API
This article will deal with the Search API and cover the basics of performing searches, parsing JSON results, and good practices when writing Network applications. A future article will deal with updating twitter and retrieving account specific information such as friend lists and profile data.
The Twitter Search API allows you to query the public stream of Twitter posts for trending topics as well as pulling trending topics for a given day or week. Since the search API is querying public data in the public stream, your application is not required to authenticate with Twitter when using the Twitter search api. Keep in mind that this means that your applications request will count against your IP’s rate limit.
Our example application will display the top currently trending Twitter topics and allow you to view the posts that match those topics using a simple table view based application.
The search api is fairly simple to invoke and consists of issuing a request using a url.
For example to get the top 10 most popular topics you can use this query
The only format the search api currently supports is JSON. So to see what twitter will return to your application you can enter the following address into your browser:
The data returned in JSON format and is not designed for human eyes. We will examine it closely in a moment, but first lets get the basics of JSON down.
JSON
JSON stands for JavaScript Object Notation. It is a light weight/low overhead format for encapsulating data that is supported in just about every language you could desire. More information about JSON including links to libraries to support different languages can be found here: www.json.org.
Common JSON Data Examples
Associative Arrays
One of the most common JSON representations is an associative array.
Associative arrays are structures which follow the key value style. These are encapsulated in the following format, which looks like
{<value name1>:<value1>,<value name2>:<value2>….}}
For example if your structure had the attributes model, mpg, seats the return might look like this:
{“model”:”Civic”,”mpg”:30,”seats”:4}
Vector Arrays
Vector arrays are returned as a comma delimited list surrounded by brackets
[value1,value2,value3]
For example
[“oranges”,”bannas”,”apples”]
There is no limited to the amount of nesting you can do. For example you can have an array of objects
[
{
“model”:”Prius”,
“mpg”:80,
“seats”: 1.5
},
{
“model”:”Civic”,
“mpg”:30,
“seats”: 4
},
{
“model”:”Ridgeline”,
“mpg”:20,
“seats”: 5
}
]
You can also have structures that contain arrays, or other structures. There is no limit to the level of nesting you can create.
Now that you have all passed JSON 101, lets take a look at the data returned by Twitter for our previous request. You data will be the exact same format as mine, but unless its Groundhog day your trending topics should be very different.
{"as_of":"Sat, 26 Sep 2009 12:27:42 +0000",
"trends":
[
{"name":"#cantlivewithout",
"url":"http://search.twitter.com/search?q=%23cantlivewithout"},
{"name":"ODST",
"url":"http://search.twitter.com/search?q=ODST"},
{"name":"Ondoy",
"url":"http://search.twitter.com/search?q=Ondoy+OR+%23ondoy"},
{"name":"Dick Gordon",
"url":"http://search.twitter.com/search?q=%22Dick+Gordon%22+OR+Gordon"},
{"name":"NDCC",
"url":"http://search.twitter.com/search?q=NDCC"},
{"name":"Lily Allen",
"url":"http://search.twitter.com/search?q=%22Lily+Allen%22+OR+Allen"},
{"name":"Carling Cup",
"url":"http://search.twitter.com/search?q=%22Carling+Cup%22"},
{"name":"Singapore",
"url":"http://search.twitter.com/search?q=Singapore"},
{"name":"Firefox Smacks Down",
"url":"http://search.twitter.com/search?q=%22Firefox+Smacks+Down%22+OR+%22Smacks+Down%22"},
{"name":"Liverpool",
"url":"http://search.twitter.com/search?q=Liverpool"}
]
}
The JSON data returned is an associative array containing the following elements
as_of: Date field in UTC format. This is the date of the query.
trends: This is an array of objects which contain the currently trending topics. Each object has the following fields
name: The actual trending topic name
url: The search URL to bring up the results for that topic.
Now that we understand the data returned by our query we need to consider the best way to represent this data programmatically. To maintain flexibility the simplest way of organizing this data would be to store in in a nested set of NSDictionary Objects like follows
NSDictionary
Key: as_of Value: Sat, 26 Sep 2009 12:27:42 +0000
Key: trends: Value: NSArray of Trend Dictionaries
NSDictionary (trends)
Key: name value: #cantlivewithout
Key: url value: http://search.twitter.com/search?q=%23cantlivewithout
:
:
The first advantage of using dictionaries is it will require little in the way of change if Twitter decides to add fields. The second advantage of parsing the JSON data into dictionaries is it is the default format returned by the TouchJSON library.
TouchJSON
TouchJSON is one of those rare treats in software development - a library that is straightforward and does not need a dedicated wiki to explain its use. The library decodes JSON data into NSArrays or NSDictionary objects as appropriate. It was written by Jonathan Wright and can be downloaded here: http://code.google.com/p/touchcode/downloads/list
To decode JSON data using this class is essentially 3 lines of code
Starting with an NSString which contains your data
NSData *jsonData = [MyJsonString dataUsingEncoding:NSUTF32BigEndianStringEncoding];
NSError *error = nil;
NSDictionary * dict = [[CJSONDeserializer deserializer] deserializeAsDictionary:jsonData error:&error];
Retrieving the Search Results.
The url element returned by the Twitter trends JSON data will return html and is designed for a browser. Copy any of the returned URLs and paste it into an address bar in your browser and you will see you search results. To completely control the user interface, and to avoid messy html parsing we want to make sure our search results come back in JSON format.
To make that happen the URL that the search is executed against needs to be changed.
Should be changed to this
This is as simple as using the NSString method
stringByReplacingOccurrencesOfString
Once we do that we will receive our results as the following JSON structure.
results – An Array of the following objects
profile_image_url – The URL for the users thumbnail
created_At – When this tweet was crteated
from_user – The users Twitter id
to_user_id – The user id the message was sent to (for direct messages only)
text – The text of the tweet
id – The message id
from_user_id – The user id’s numeric representation
iso_language_code – The iso language code for this tweet
source – A string representing the Twitter client used to post this tweet.
Here is a JSON fragment of the results for a search on the string #cantlivewithout
{
"results":[
{"profile_image_url":"http://a3.twimg.com/profile_images/437361203/picsay-1253979119_normal.jpg"
,"created_at":"Sat, 26 Sep 2009 17:32:10 +0000",
"from_user":"#######",
"to_user_id":null,
"text":"#cantlivewithout my shredded wheat!!!!”
"id":4397830470,"from_user_id":30381437,
"iso_language_code":"en",
"source":"<a href="http://twitterride.net/" rel="nofollow">TwitterRide</a>"},
:
:
]
}
As you can see the tweet itself is only a small portion of the meta data returned by your query. We will use the meta data to display the users profile picture, user id and post date for each of the search results.
Twitter Search Example – TwitterTrends
Now we have all of the fundamental pieces to put together an application to display a list of trending Twitter topics, and display all the tweets for a given topic. We are going to approach this project in two phases. A quick and dirty prototype which will prove out our design, then a second pass to put polish on the app and make it ready for the real world.
Here’s what the final result of the prototype will look like.
Creating Twitter trends.
- Start a new iPhone project in Xcode
- Select Navigation based Application. Make sure core data is not checked.
- Give it the name TwitterTrends and save the project
- In the groups and files window right click and choose add new group called TouchJson
- Open the folder you downloaded TouchJson into
- Drag the contents of the source directory into the TouchJson group
- Check off copy files to destination if needed. *
*As a general rule I will copy libraries into the projects that reference them. This is a good habit to get into to prevent a newer version of a library from breaking your code.
Constants
It’s a bad idea to embed network URLs in your code. When maintaining your code down the road, if the network address changes you will stuck slogging through your code looking for static strings you need to update. Yes you can always do search and replace, but a far better approach is to move all of the addresses into a centralized header file and use #define to give the addresses meaningful constant names.
Besides the URL’s we will also put the date formatting strings to centralize them.
Create a new file called TwtterConstants.h and add the following to it.
#define kTwitterTrendsURL @"http://search.twitter.com/trends.json"
#define kTwitterSearchURL @"http://search.twitter.com/search"
#define kTwitterSearchJSONURL @"http://search.twitter.com/search.json"
#define kTwitterHost @"search.twitter.com"
#define kTwitterDateFormat @"EEE, dd MMM yyyy HH:mm:ss ZZZ"
#define kOutputFormat @"MMM-dd-yyyy HH:mm:ss"
Add #import “TwitterConstants.h” to your application delegates implementation file - TwitterTrends.m and to RootViewController.m.
Speaking of date formatting, we receive the dates from Twitter in zulu time and the longest possible format seriously if the dates were any larger they would have their own zip code. So we will need to shift the date to the devices timezone and reformat it so the user doesn’t doze off by the time they finish reading it. Since this code will be done in several places, lets centralize it in the application delegate object that can be accessed by all of our running objects.
In TwitterTrendsAppDelegate.h add these two properties. To ad a property add a member variable to your class between the braces of the @implementation section of your header file.
NSDateFormatter * outputDateFormatter;
NSDateFormatter * inputDateFormatter;
So after adding our date formatters the @implementation section will look like this.
@interface TwitterTrendsAppDelegate : NSObject <UIApplicationDelegate> {
UIWindow *window;
UINavigationController *navigationController;
NSDateFormatter * outputDateFormatter;
NSDateFormatter * inputDateFormatter;
After adding the member variables to your implementation section add the @property lines after the closing brace and before the @end.
@property (nonatomic, retain) NSDateFormatter * outputDateFormatter;
@property (nonatomic, retain) NSDateFormatter * inputDateFormatter;
The entire header file will now look like this.
@interface TwitterTrendsAppDelegate : NSObject <UIApplicationDelegate> {
UIWindow *window;
UINavigationController *navigationController;
NSDateFormatter * outputDateFormatter;
NSDateFormatter * inputDateFormatter;
}
@property (nonatomic, retain) IBOutlet UIWindow *window;
@property (nonatomic, retain) IBOutlet UINavigationController *navigationController;
@property (nonatomic, retain) NSDateFormatter * outputDateFormatter;
@property (nonatomic, retain) NSDateFormatter * inputDateFormatter;
@end
In the implementation file for your application delegate (TwitterTrends.m) add the synthesize lines. The go after the @implementation line.
@synthesize inputDateFormatter;
@synthesize outputDateFormatter;
Initialize these variables in the beginning of the applicationDidFinishLaunching method
- (void)applicationDidFinishLaunching:(UIApplication *)application {
// Create the shared date formatting instances.
inputDateFormatter = [[NSDateFormatter alloc] init];
outputDateFormatter = [[NSDateFormatter alloc] init];
[inputDateFormatter setDateFormat:kTwitterDateFormat];
[outputDateFormatter setDateFormat:kOutputFormat];
In the dealloc call release the date formatters.
- (void)dealloc {
[inputDateFormatter release];
[outputDateFormatter release];
[navigationController release];
Now in any class that will need to convert Twitter date data can use the app delegate properties to do so.
RootViewContoller changes
Open up RootViewController.h and add the following member variable
NSArray *rows;
Add the property declaration under the closing brace
@property (nonatomic,retain) NSArray *rows;
This array will hold our data for our rows.
Open up RootViewContoller.m
Add the import for TouchJson and our TwitterConstants.h file
#import "CJSONDeserializer.h"
#import “TwitterConstants.h”
Synthesize the rows property.
@synthesize rows
Create a method to pull the data from Twitter
-(void) loadTwitterData
{
NSURL *url = [NSURL URLWithString:kTwitterTrendsURL]; // Twitter Current Trending Topics URL
NSError * err = nil;
NSString *twitterreturn = [NSString stringWithContentsOfURL:url encoding:NSISOLatin1StringEncoding error: &err ];
// Pulls the URL
if (err)
{
UIAlertView *alert = [[UIAlertView alloc]
InitWithTitle:@"Error Retrieving Trends"
message:err.localizedDescription
delegate:self
cancelButtonTitle:nil
otherButtonTitles:@"OK", nil];
[alert show];
return;
}
NSData *jsonData = [twitterreturn dataUsingEncoding:NSUTF32BigEndianStringEncoding];
NSDictionary * dict = [[CJSONDeserializer deserializer] deserializeAsDictionary:jsonData error:&err];
if (err)
{
UIAlertView *alert = [[UIAlertView alloc]
initWithTitle:@"Error Parsing Trends"
message:err.localizedDescription
delegate:self cancelButtonTitle:nil otherButtonTitles:@"OK", nil];
[alert show];
}
if (dict)
{
TwitterTrendsAppDelegate * app = (TwitterTrendsAppDelegate * ) [UIApplication sharedApplication].delegate;
NSDateFormatter *idf = app.inputDateFormatter;
NSDateFormatter *odf = app.outputDateFormatter;
NSDate *asOfDate = [idf dateFromString:(NSString *)[dict objectForKey:@"as_of"]];
self.navigationItem.title = [odf stringFromDate:asOfDate ];
rows = [dict objectForKey:@"trends"];
[rows retain];
}
}
This function creates an NSURL object with the address of the Twitter trends api. It then creates an NSString object using that URL as its source.
NSURL *url = [NSURL URLWithString:@"http://search.twitter.com/trends.json"]; // Twitter Current Trending Topics URL
NSError * err;
NSString *twitterreturn = [NSString stringWithContentsOfURL:url encoding:NSISOLatin1StringEncoding error: &err ];
TouchJSON requires an NSData object to deserialize so create the data object using dataUserEncoding.
NSData *jsonData = [twitterreturn dataUsingEncoding:NSUTF32BigEndianStringEncoding
Next deserialize the JSON data into an NSDictionary Object
NSDictionary * dict = [[CJSONDeserializer deserializer] deserializeAsDictionary:jsonData error:&error];
The next part of the function checks to make sure that our dictionary was created.
if (dict)
It then obtains a reference to the Application delegate and our two date formatter properties.
TwitterTrendsAppDelegate * app = (TwitterTrendsAppDelegate * ) [UIApplication sharedApplication].delegate;
NSDateFormatter *idf = app.inputDateFormatter;
NSDateFormatter *odf = app.outputDateFormatter;
It uses the idf date formatter to convert twitters date to an NSDate.
NSDate *asOfDate = [idf dateFromString:(NSString *)[dict objectForKey:@"as_of"]];
Then the odf date formatter to convert to our desired date format and set the navigation bar’s title to that value.
self.navigationItem.title = [odf stringFromDate:asOfDate ];
We do not care about the dictionary object but retain the rows object from our JSON data so it hangs around after the dictionary goes out of scope.
rows = [dict objectForKey:@"trends"];
[rows retain];
}
Next we will create a refresh function. This function reloads the Twitter data and then informs the tableview to reload its data.
-(void) refresh
{
[self loadTwitterData];
[self.tableView reloadData];
}
In the ViewDidLoad function, create the refresh button using the prebuilt button that Apple has thoughtfully provided and add it to the navigation bar. Then invoke our loadTwitterData function to fill our table view.
- (void)viewDidLoad {
[super viewDidLoad];
// Create a refresh button
UIBarButtonItem *refreshButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemRefresh target:self action:@selector(refresh)];
self.navigationItem.leftBarButtonItem = refreshButton;
[refreshButton release];
[self loadTwitterData];
}
The rest of the changes are straight forward TableViewController delegate methods.
Change numberOfRowsInSection to return the correct value
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
return [rows count];
}
In cellForRowAtIndexPath build the cell based on the dictionary object that the row contains. Also put the Disclosure Indicator to show that this row will lead to another view.
- (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] autorelease];
}
// Configure the cell.
NSDictionary *dict = (NSDictionary*)[rows objectAtIndex:indexPath.row];
cell.textLabel.text = [dict objectForKey:@"name"];
cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;
return cell;
}
Lastly in the dealloc function release rows, since we bumped the reference count when we last loaded it.
- (void)dealloc {
[rows release]
[super dealloc];
}
If you compile and execute now your application will popup and list the list of currently trending Twitter topics.
Clicking on each row will not do anything right now. For that we need to create a new view controller and implement the didSelectRowAtIndexPath function.
Lets add the functionality to display the results of all the tweets for a given topic.
Add a new ViewControllerSubclass to your project
Select the classes group in xcode. Choose File-> New File
Choose Cocoa Touch Class
Then Select UIViewController Subclass
In the dialog box which appears make sure that the UITableViewController subclass box and the With XIB for user interface are also checked.
Name your new class TopicViewController and open the header file.
Add the following member variables and property declaration
NSString *topic;
NSString * url;
NSArray * rows;
:
:
@property (nonatomic, retain) NSString * topic;
@property (nonatomic, retain) NSString * url;
@property (nonatomic, retain) NSSArray * rows;
These will store the topic (for the navigation bar title) and the url for the search.
Open up TopicViewController.m and add the #import “TwitterConstants.h”
Then add the @sythesize lines for our new properties.
@synthesize topic;
@synthesize url;
@synthesize rows;
Now we will create this views loadTwitterData. This function will
1. Take the url and replace the general Twitter search address with the json address, perform the query then save the results for display in a tableview.
-(void) loadTwitterData
{
NSString * jsonURL = [url stringByReplacingOccurrencesOfString:kTwitterSearchURL withString:kTwitterSearchJSONURL];
NSURL *searchurl = [NSURL URLWithString:jsonURL]; // Twitter search results as json URL
NSError * err = nil;
NSString *twitterreturn = [NSString stringWithContentsOfURL:searchurl encoding:NSISOLatin1StringEncoding error: &err];
if (err)
{
UIAlertView *alert = [[UIAlertView alloc]
initWithTitle:
@"Error Retrieving Search Results"
message:err.localizedDescription
delegate:self cancelButtonTitle:nil otherButtonTitles:@"OK", nil];
[alert show];
return;
}
NSData *jsonData = [twitterreturn dataUsingEncoding:NSUTF32BigEndianStringEncoding];
NSError *error = nil;
if (err)
{
UIAlertView *alert = [[UIAlertView alloc]
initWithTitle:@"Error Parsing Search Results"
message:err.localizedDescription
delegate:self cancelButtonTitle:nil otherButtonTitles:@"OK", nil];
[alert show];
return;
}
NSDictionary * dict = [[CJSONDeserializer deserializer] deserializeAsDictionary:jsonData error:&error];
if (err)
{
UIAlertView *alert = [[UIAlertView alloc]
initWithTitle:@"Error Parsing Search Results"
message:err.localizedDescription
delegate:self cancelButtonTitle:nil otherButtonTitles:@"OK", nil];
[alert show];
}
if (dict)
{
rows = [dict objectForKey:@"results"];
[rows retain];
}
NSLog(@"Array: %@",rows);
}
The next function we need is a function which returns a UIImage for a given image url. This will be used to create the profile images that will appear in each row of the Tableview. Unfortunately there is no ImageWithContentsofURL initialization in UIImage in the iPhone SDK. So we will roll our own.
- (UIImage*) loadImage:(NSURL*)url
{
NSData* imageData = [[NSData alloc]initWithContentsOfURLurl];
UIImage* image = [[UIImage alloc] initWithData:imageData];
[imageData release];
[image autorelease];
return image;
}
The load image function accepts a URL, loads a data object with the contents of that URL then creates and returns a UIImage to the caller. For simplicities sake, the initial version of this function is synchronous. We will take a look later in this chapter on how to improve this so the loading of the profile image is asynchronous.
The next change is in viewDidLoad. Here we will call the loadTwitterData function and also set the title of the navigation bar to be our search term.
- (void)viewDidLoad {
[super viewDidLoad];
self.navigationItem.title = topic;
[self loadTwitterData];
}
Change the numberOfRowsInSection to return the count of objects in the rows array
// Customize the number of rows in the table view.
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
return [rows count];
}
Now create the cellForRowAtIndexPath function
// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
static NSString *CellIdentifier = @"Cell";
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease];
}
// Set up the cell...
// A row object is a dictionary with the following keys
//profile_image_url
//created_at
//from_user
//to_user_id
//text
NSDictionary * dict = [rows objectAtIndex:indexPath.row];
cell.textLabel.text = (NSString*) [dict objectForKey:@"text"];
cell.detailTextLabel.text = [NSString stringWithFormat:@"%@:%@",(NSString*) [dict objectForKey:@"from_user"], (NSString*) [dict objectForKey:@"created_at"]];
UIImage *profileimage = [self loadImage:(NSString*) [dict objectForKey:@"profile_image_url"]];
cell.imageView.image = profileimage;
return cell;
}
We want the cell to display the users profile picture, the Tweet as the main text and the detail text line to have the from user and date of the tweet.
The template lines for dequeueing the cell are fine for our purposes. However the Cell creation line should be changed so that our cell style includes subtitles.
So look for this line
cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] autorelease];
And change it to this.
cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease];
Now look for the line // Set up the cell... this is where we pull values from the NSDictionary which each row holds.
Get the object for this index path and convert it to an NSDictionary
NSDictionary * dict = [rows objectAtIndex:indexPath.row];
Set the cellTextLabel to the text of the tweet.
cell.textLabel.text = (NSString*) [dict objectForKey:@"text"];
Create a string containing the user name and date of the tweet and set the detailTextLabel to this string
cell.detailTextLabel.text = [NSString stringWithFormat:@"%@:%@",(NSString*) [dict objectForKey:@"from_user"], (NSString*) [dict objectForKey:@"created_at"]];
Pull the image for the profile and assign it to the cell’s imageview. Because we are pulling each image in from the net synchronously this activity is a big performance hit. Comment out these two lines if you can’t live with it and we will fix this in the next section.
UIImage *profileimage = [self loadImage:(NSString*) [dict objectForKey:@"profile_image_url"]];
cell.imageView.image = profileimage;
The last change to this file is to add rows to the dealloc function to make sure nothing leaks.
- (void)dealloc {
[rows release];
[super dealloc];
}
Compile and run the program and you now have a fairly snazzy looking Twitter trends viewer. Its not perfect, for one thing we are loading the images synchronously, some of the text of the tweets is being truncated, and the user has no visual cue that activity is going on while network access is being performed. We will tackle these in the next article.