• I want the data to be processed  and shown to the user as quickly as possible.
• If the file is large I don’t want to have to store the entire contents in memory.

Using NSXMLParsers initWithURL: method the xml file is downloaded synchronously with NSURLConnection before parsing. If NSXMLParser was able to begin as soon as stream buffer began to fill, even though the overall parsing time wouldn’t be reduced significantly if the updates are immediately displayed the user perceived time decreases significantly.

Using the excellent objective c expat wrapper library by Robbie Hanson as a base iPhoneExpat uses CFNetwork & CFHTTPMessage to create and feed a http stream gradually into Expat. If the server supports gzip compression zlib is used to decompress the stream on fly.

iPhone Expat offer 3 methods for initialization

- (id)initWithContentsOfURL:(NSURL *)url;
- (id)initWithContentsOfFile:(NSString *)path;
- (id)initWithData:(NSData *)data;

The delegate messages are also a drop in replacement for NSXMLParser

@protocol ExpatXMLParserDelegate 
 
@optional
- (void)parserDidStartDocument:(ExpatXMLParser*)parser;
- (void)parserDidEndDocument:(ExpatXMLParser*)parser;
- (void)parser:(ExpatXMLParser*)parser didStartMappingPrefix:(NSString *)prefix toURI:(NSString *)namespaceURI;
- (void)parser:(ExpatXMLParser*)parser didEndMappingPrefix:(NSString *)prefix;
- (void)parser:(ExpatXMLParser*)parser foundComment:(NSString *)comment;
- (void)parser:(ExpatXMLParser*)parser foundProcessingInstructionWithTarget:(NSString *)target data:(NSString *)data;
- (void)parser:(ExpatXMLParser*)parser parseErrorOccurred:(NSError *)parseError;
- (BOOL)parser:(ExpatXMLParser*)parser shouldProcessAttributesForElement:(NSString *)elementName;
 
@required
- (void)parser:(ExpatXMLParser*)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qualifiedName attributes:(NSDictionary *)attributeDict;
- (void)parser:(ExpatXMLParser*)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName;
- (void)parser:(ExpatXMLParser *)parser foundCharacters:(NSString *)string;
 
@end

However

- (void)parser:(ExpatXMLParser *)parser foundCharacters:(NSString *)string;

Will report the entire contents of a tag so you don’t need an NSMutablestring to buffer fragments in your delegate. e.g.

- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string
{
	[buffer release];
	buffer = string;
	[buffer retain];
}

Should be good in 99% of cases to get the entire contents of a tag

The project can be found here

http://github.com/zootreeves/iPhoneExpat

Alternatively checkout the code using git: http://github.com/zootreeves/iPhoneExpat

Benchmark test output:

I’ve included a test application which sequentially downloads and parses the following feeds:

@"http://ax.itunes.apple.com/WebObjects/MZStoreServices.woa/ws/RSS/topalbums/sf=143441/limit=300/explicit=true/xml",
@"http://ax.itunes.apple.com/WebObjects/MZStoreServices.woa/ws/RSS/topalbums/sf=143441/limit=300/explicit=true/xml",
@"http://feeds.feedburner.com/DilbertDailyStrip",
@"http://designsponge.blogspot.com/atom.xml",
@"http://www.slate.com/rss/",
@"http://rssfeeds.usatoday.com/UsatodaycomBooks-TopStories",
@"http://googleblog.blogspot.com/atom.xml",
@"hhttp://api.flickr.com/services/feeds/groups_pool.gne?id=61057342@N00〈=en-us&format=rss_200",
@"http://phobos.apple.com/WebObjects/MZStore.woa/wpa/MRSS/topsongs/limit=25/rss.xml",
@"http://www.readwriteweb.com/rss.xml",
@"http://rssfeeds.usatoday.com/UsatodaycomNation-TopStories",
@"http://dictionary.reference.com/wordoftheday/wotd.rss",
@"http://www.quotationspage.com/data/qotd.rss",
@"http://sports.espn.go.com/espn/rss/news"

Time to reach the first element Expat: 8.611217 — NSXMLParser: 15.404100
Total time for Expat: 10.902272 — NSXMLParser: 17.108309

Memory is also reduced by a factor of about x4 (see screenshots)

Further Considerations

• It would be great if http requests were persistent, however after setting kCFStreamPropertyHTTPAttemptPersistentConnection to true using httpscoop I will still able to intercept “connection close” messages between requests to the same server. I think I must be doing something wrong here.
• It would be preferable if as many objects as possible were released manually rather than using an autorelease pool. For example the delegate methods that pass an elementName it is common for the client to use this string to determine their current tag, but rare that they actually want to retain it. The code could be altered so these strings are not placed in a pool and are released immediately after the delegate message is sent. Not only can the overhead of collection be avoided but CFStringCreateWithCharactersNoCopy can be used as well.
• With UTF8 creating CFStrings with the [NSString stringwithutf8string:] was no problem. However when I configured Expat to use UTF-16 characters internally I found that CFStringCreateWithCharacters would often return garbage. The problem is I was passing in UINT16_MAX as the buffer length hoping that the CFString would be terminated at null, however it doesn’t work that way and I had to change everything to calculate the buffer size using UniCharStrlen(buffer) before hand.
• FTP (CFFTPStream) and file streams could easily be supported.

For example if were creating a news application, we want to be able to import news in the background and display updates to the user with no interruption of the GUI. The task can be divided into several stages:

1. Download the xml feed with the latest news
2. Parse the feed
3. Insert the articles into core data
4. Notify the UI and refresh the display.

We already have our core data API defined. A simple method to retrieve all the articles and a method to add a new article.
DataSource.h

@interface DataSource : NSObject { }
-(NSArray*)getNewsFor:(Region*)region;
-(void)addArticle:(Article*)article forRegion:(Region*)region;
@end
}

Now suppose we want to the web service to import the latest articles. We might define our implementation something like this:
WebService.h

@interface WebService : NSObject {
	id delegate;
	LocalDataSource * source;
}
 
@property(nonatomic, retain) id delegate;
@property(nonatomic, retain) LocalDataSource * source;
-(void)importNewsForRegion:(Region*)region;
 
@end

Our implementation of importNewsForRegion would look something like this:

WebService.m

-(void)importNewsForRegion:(Region*)region
{
	//Perform in background if called from main
	 if ([NSThread currentThread] == [NSThread mainThread])
	{
		[self performSelectorInBackground:@selector(importNewsForRegion:) withObject:region];
		 return;
	}
 
	//Setup pool
	 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	 NSArray * articles = [XML parseArticleFeed:region.feedURL]; //Not safe 1.
	 for (Article * article in articles)
	{
		[source addArticle:article forRegion:region]; //Not safe 2.
	}
 
	[delegate finishedImport]; //Not safe 3.
	[pool drain];
}

However this because importNewsForRegion is running in a separate thread this is unsafe and will likely cause core data to crash or corrupt our database.

1. The region passed to to importNews has likely come from a core data context which was constructed on the main thread. Even though were not even altering the region directly with core data it’s not safe to even read the feedURL, because every operation can trigger faulting.
2. When we instruct the source to add an article it will use the main threads context, this is fine when we are in the main thread, but in a background thread we need to specify our own context.
3. Not related to core data, but when we notify the delegate it will likely perform UI updates which are not safe to perform in a background thread. we need to ensure the delegate only received notifications on the main thread.

To make our program thread safe we first need to make some small alterations to our API.

DataSource.h

@interface DataSource : NSObject { }
-(NSArray*)getNewsFor:(Region*)region;
-(NSArray*)getNewsFor:(Region*)region context:(NSManagedObjectContext*)context;
 
-(void)addArticle:(Article*)article forRegion:(Region*)region;
-(void)addArticle:(Article*)article forRegion:(Region*)region context:(NSManagedObjectContext*)context;
@end
}

In our data source we specify two more methods which allow us to provide a context for the method to use. All our queries should be updated to only use the provided context. The original methods that don’t specify a context should call the newly implemented method with the default context, e.g.

-(void)addArticle:(Article*)article forRegion:(Region*)region
{
        [self addArticle:article forRegion:region context:mainThreadContext];
}

Only when we are using core data in a background thread do we need to use the newly added methods. So we can now update our WebService.m:

-(void)importNewsForRegion:(Region*)unsafeRegion
{
	//Perform in background if called from main
	 if ([NSThread currentThread] == [NSThread mainThread])
	{
		[self performSelectorInBackground:@selector(importNewsForRegion:) withObject: unsafeRegion];
		 return;
	}
 
	//Setup pool
	 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	//Create a new context just for this thread
	NSManagedObjectContext * managedObjectContext = [[NSManagedObjectContext alloc] init];
	[managedObjectContext setPersistentStoreCoordinator:  [source persistentStoreCoordinator]];
 
        //Create a new region which is safe to use in this thread
	Region * region = (Region*)[managedObjectContext existingObjectWithID:[unsafeRegion objectID] error:nil];
 
	 NSArray * articles = [XML parseArticleFeed:region.feedURL];
	 for (Article * article in articles)
	{
               //Ensure we provide the context for the source to use
		[source addArticle:article forRegion:region context:managedObjectContext];
	}
 
	//Save changes and close the new context
	[managedObjectContext save:&error];
	[managedObjectContext release];
 
	[delegate performSelectorOnMainThread:@selector(finishedImport) withObject:nil waitUntilDone:NO];
	[pool drain];
}

As you can see we crate a new context using out shared persistentStoreCoordinator, we ensure that anytime we touch core data from this thread we are using this context. The also means that we have to create a new region which belongs to this context, and we do this with the existingObjectWithID method and using the [unsafeRegion objectID]. Finally we ensure that the delegate receives the notification on the main thread.

for more information about threading in core data see:

http://developer.apple.com/Mac/library/documentation/Cocoa/Conceptual/CoreData/Articles/cdMultiThreading.html

When the device is connected to a cellular network, iVersion does not load its contents.  After the user enters the URL (http://svn.collab.net/repos/svn/trunk/) and taps “connect,” an error message is received.

Apparently the error message is not clear enough or something, anyway this is not a rant, this is what apple recommends.

Please take a look at the Reachability iPhone program sample which demonstrates the use of the System Configuration Reachability API to detect the absence of WiFi and Wireless Wide Area Network (WWAN) services. Your application can then take appropriate action at the first point where network services are required.

The sample code can be found on Apple developer site, however the two file we are interested in are:

Download the Reachability Code:
Reachability.h

Reachability.m

How to use:
Lets say you have a simple UILabel which you want to update with either “(Offline)” or “(Online)” depending on whether the network is reachable. Your view controller would be defined something like this:

@interface MyStatusView : UIViewController
{
	UILabel * statusLabel;
}
 
@property(nonatomic, assign) IBOutlet UILabel * statusLabel;
 
- (void)reachabilityChanged:(NSNotification *)note;
- (void)updateStatus;
 
@end

Then we add the following code to the view controller .m file:

-(void)viewWillAppear:(BOOL)animated
{
	self.reachability = [Reachability reachabilityWithHostName:@"google.com"];
	[reachability startNotifer];
 
	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(reachabilityChanged:) name:@"kNetworkReachabilityChangedNotification" object:nil];
 
	[self updateStatus];
}
 
-(void)viewWillDisappear:(BOOL)animated
{
	self.reachability = nil;
	[[NSNotificationCenter defaultCenter] removeObserver:self];
}
 
-(void)reachabilityChanged:(NSNotification*)notification
{
	[self updateStatus];
}
 
-(void)updateStatus
{
	NSLog(@"Reachability changed");
 
	if ([reachability currentReachabilityStatus] == NotReachable)
	{
		statusLabel.text = @"(Offline)";
	}
	else
	{
		statusLabel.text = @"(Online)";
	}
}

I think it’s fairly self explanatory. Basically when the view appears the reachability class is created and started using startNotifier. Then we hook in our reachabilityChanged: method into the notification centre, so it is automatically called when the network status changes. reachabilityChanged: calls updateStatus which simply changes our label depending on the connectivity.

First we create a new class which has a view which will be loaded from a nib, a thread condition to lock the calling thread and two NSString fields to store the result and the string of the button which was clicked.

@interface MessagePrompt : NSObject
{
 
UIView * view;
NSCondition * promptCondition;
NSString * clickedButton Text;
NSString * result;
{
@end

Our new prompt method can be called from the thread which needs to be locked, it will subsequently call UIKit on the main thread.

+(id)newPrompt:(MessagePrompt*)prompt
{
 
     if ([NSThread currentThread] == [NSThread mainThread])
    {
          printf("Should not be called by Main thread\n");
          return nil;
    }
 
     prompt.promptCondition = [[[NSCondition alloc] init] autorelease];
 
    [prompt performSelectorOnMainThread:@selector(prompt:) withObject:view waitUntilDone:NO];
    [prompt.promptCondition wait];
 
    return prompt;
}

This method is called by +(id)NewPrompt and displays a prompt in our window. It also adds targets to each UIButton to receive user actions.

-(void)prompt:(UIView*)inView
{
     NSArray * nib = [[NSBundle mainBundle] loadNibNamed:@"MyPromptView" owner:self options:nil];
     inView = [nib objectAtIndex:0];	
 
     NSArray * subviews = [self.view subviews];
     for (UIView * cview in subviews)
    {
          if ([cview isKindOfClass:[UIButton class]])
          {
               UIButton * button = (UIButton*)cview;
                [button addTarget:self action:@selector(clicked:) forControlEvents:UIControlEventTouchDown];
          }
    }
 
    [inView.superview addSubview:view];
}

This is called when a user clicks a button, it finds the value field and retreives and stores the value in self.message. The prompt condition is then signalled which causes the calling thread to continue running.

-(IBAction)clicked:(UIButton*)sender
{
     self.clickedButton = sender.currentTitle;
 
     UITextView * text = [iVersionAppDelegate findSubViewOfKind:self.view class:[UITextView class]];
     if (text)
    {
         self.message = text.text;
    }
 
    [self.view removeFromSuperview];
     self.view = nil;
 
    [promptCondition signal];
}
 
@end

Usage

/* Called when svn requires a log message */
svn_error_t *
iversion_svn_cl__get_log_message(const char **log_msg,
const char **tmp_file,
const apr_array_header_t *commit_items,
void *baton,
apr_pool_t *pool)
{
 
CommitLogMessagePrompt * prompt = [CommitLogMessagePrompt newPrompt];
 
    /* Clicked Continue */
     if ([prompt.clickedButton isEqualToString:@"Continue"])
    {
        *log_msg = [prompt.message UTF8String];
         return SVN_NO_ERROR;
    }
 
     return svn_error_create(SVN_ERR_CANCELLED, NULL, _("Delete Cancelled"));
}

#include "FileSystemMonitor.h"
 
//Setup the monitor
FileSystemMonitor * monitor = [[FileSystemMonitor alloc] init];
monitor.delegate = self;
[monitor monitorPath:@"/"];
 
//...In your delegate class
-(void)nodeWasCreatedAt:(NSString*)path
{
     printf("Created %s\n", [path UTF8String]);
}
 
-(void)nodeWasDeletedAt:(NSString*)path
{
    printf("Deleted %s\n", [path UTF8String]);
}
 
-(void)fileSizeDidchange:(NSString*)path bytes:(size_t)difference
{
     printf("file Added %ul bytes\n", difference);
}

Notes:

• Can monitor for Deleted files, Created Files and File Size Changes
• On an iPhone 3GS it is able to monitor the entire SVN 1.6 source tree and the iVersion source tree (total 11,050 File/Directories) in an execution time of 12s. Due to the low thread priority and the fact that the majority of execution time is IO it does not cause much/any slow down to the UI. However there is still room for improvement.

Download:

FileSystemMonitor.h

FileSystemMonitor.m

FileMonitorDelegateProtocol.h

iVersion uses the open source subversion 1.6 client library, written in plain C, with an Objective C wrapper for simpler interfacing with the Objective C UI. Using an objective C Wrapper the client can easily be abstracted to work with other version control protocols. In the future git, mercurialand bazaar support maybe included.

Features

• Multi-threaded non-locking ui
• OpenSSL support for https:// and svn+ssh:// connections
• svn commands: list, info, cat,
• Browse Directories
• View Commit Logs
• View file Info
• Bookmarks, History & Directory Cache through NSUserDefaults

** Commit Support
Subversion does not allow commiting of a single file without a working copy of the previous directory. A work around for this has been found and commit support should be available in a future version.