Using a singleton and archiving it

Question

I have a class where I want to keep persistent settings throughout my app. This class is defined as:

@interface Archive : NSCoder <NSCoding> {
    NSString *fromAddress;
    NSString *toAddress;
... more ...
}

@property(nonatomic,retain) NSString *fromAddress;
@property(nonatomic,retain) NSString *toAddress;

+ (Archive *)sharedArchive;

-(void)encodeWithCoder:(NSCoder *)aCoder;
-(id)initWithCoder:(NSCoder *)aDecoder;

And implemented as:

@synthesize fromAddress, toAddress;

+ (Archive *)sharedArchive
{
    if (sharedArchive == nil) {
        NSMutableData *data = [[NSMutableData alloc] initWithContentsOfFile:@"mydata"];
        NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
        sharedArchive = [unarchiver decodeObjectForKey:@"myapp"];
        [unarchiver finishDecoding];
    }
    return sharedArchive;
}

+ (id)allocWithZone:(NSZone *)zone
{
    sharedArchive = [super allocWithZone:NULL];
    return sharedArchive;
}

- (id)copyWithZone:(NSZone *)zone
{
    return self;
}

- (id)retain
{
    return self;
}

- (NSUInteger)retainCount
{
    return NSUIntegerMax; 
}

- (void)release
{
    //do nothing
}

- (id)autorelease
{
    return self;
}

-(void)encodeWithCoder:(NSCoder *)aCoder {
    [aCoder encodeObject:self.fromAddress forKey:@"fromAddress"];
    [aCoder encodeObject:self.toAddress forKey:@"toAddress"];
}

-(id)initWithCoder:(NSCoder *)aDecoder {
    self = [self initWithCoder:aDecoder];
    fromAddress = [[aDecoder decodeObjectForKey:@"fromAddress"] retain];
    toAddress = [[aDecoder decodeObjectForKey:@"toAddress"] retain];
    return self;
}

The application delegate applicationWillTerminate method:

- (void)applicationWillTerminate:(UIApplication *)application {
    /*
     Called when the application is about to terminate.
     See also applicationDidEnterBackground:.
     */
    NSMutableData *data = [[NSMutableData alloc] init];
    NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
    [archiver encodeObject:[Archive sharedArchive] forKey:@"myapp"];
    [archiver finishEncoding];
    [data writeToFile:@"myapp" atomically:YES];
}

I am new on this concept of archive/unarchive. The problem is that I am not being able to read back from the data file. I get the following error:

-[NSKeyedUnarchiver initForReadingWithData:]: data is NULL

Could anyone explain what I am doing wrong? Or perhaps a better way to save/restore persistent data. I've looked into the NSUserDefaults class, but I don't think that fits in my case... I am not trying to save user preferences.

Answer 1

You only want to save those two strings? Use NSUserDefaults.

if you don't want to use NSUserDefaults you should provide real paths instead of @"myapp" to writeToFile and readFromFile.

NSString *libraryPath = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) lastObject];
NSString *path = [libraryPath stringByAppendingPathComponent:@"myApp"];
[data writeToFile:path atomically:YES];

and you should also release NSMutableData *data and NSKeyedUnarchiver *unarchiver

btw, [writeToFile:atomically:] returns a BOOL that tells you if the write was successful.

btw2, - (void)applicationWillTerminate:(UIApplication *)application won't get called often on iOS4 with enabled multitasking. You should put your save function into applicationDidEnterBackground: too.

Answer 2

@fluchtpunkt got it right; "You only want to save those two strings? Use NSUserDefaults."

Or, more specifically, if:

have a class where I want to keep persistent settings throughout my app.

Unless you need to persist some significant quantity of data -- large BLOBs or the like -- you should use NSUserDefaults.

Relying on archiving and unarchiving at app termination / app launch is rife with potential issues. Apps don't always get terminated cleanly and unarchiving a bunch of stuff on launch that is used "throughout the app" (i.e. not used for app startup) is just going to make your app launch times slower.

If you do have some large amount of state that needs to be persisted between launches, then archiving / unarchiving can certainly work. However, you should not couple the archival to termination; do you really want the user to lose data when the app is force quit, jettisoned, or the device is hard rebooted (which many users have an unnatural fetish for doing)?