The following code gets you the timezone offset in hours:

NSDateFormatter* dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"Z"]; // error in documentation - the zone in hours should be 'z' not 'Z'
timezoneoffset = (int) [[dateFormatter stringFromDate:[NSDate date]] intValue]/100;
DLog(@"format %@", [dateFormatter stringFromDate:[NSDate date]]);
[dateFormatter release];

(Note the division by 100 is because the timezone is reported in military time so for 30 min offset the final timezone would be read as x.30 which is not really correct – but for getting a ballpark figure it would suffice).

Since the code is not behaving according to documentation it is not a good idea to use this to get the timezone because the code will break if the code ever starts behaving according to documentation.

Instead it turns out that there is a very nice NSTimeZone object which will give you the timezone offset from GMT in seconds:

int timezoneoffset = ([[NSTimeZone systemTimeZone] secondsFromGMT] / 3600);

Then all you have to do to get the hour difference is divide by 3600 (seconds per hour). If you cared about the half hour offsets you would make this a float – but this is plenty for getting a ballpark figure.

By implementing the playback of the sound as an alert sound the sound will be played even on the 1st gen iPod Touch which does not have a speaker.  Alert sounds can also be set to finish playback after the app finishes – which is an important feature for this use.  I was able to find how to set this property on Nagano’s blog.  Not sure what most of the page says but the language of Objective C is universal. Remember to add the audiotoolbox to your project.

#include <AudioToolbox/AudioToolbox.h>

I then load the sound in the viewDidLoad init function for the view controller where I want to play the sound – this way you are not trying to load the sound as the app is quitting.  The soundFileObject isa global for this VC.

// SOUNDS
 NSString *path = [[NSBundle mainBundle] pathForResource:@"Indigo" ofType:@"aiff"];
 NSURL *fileURL = [NSURL fileURLWithPath:path];

 OSStatus err;
 err = AudioServicesCreateSystemSoundID((CFURLRef)fileURL, &soundFileObject);
 if(err) {
   DLog(@"AudioServicesCreateSystemSoundID err = %d",err);
   exit(1);
 }

 UInt32 flag = 1;
 err = AudioServicesSetProperty(kAudioServicesPropertyCompletePlaybackIfAppDies,
     sizeof(UInt32),
     &soundFileObject,
     sizeof(UInt32),
     &flag);
 if(err){
   DLog(@"AudioServicesSetProperty err = %d",err);
 }

Then under viewWillDisappear I have the following:

 if (runActivity.isStarted) {
   // play alert sound if exiting while running
   AudioServicesPlayAlertSound (self.soundFileObject);
 }

This way the sound will play if the view is unloading while the user is expecting the app to be collecting data.

WebKitErrorDomain error 101

Once I identified that the issue was that some users had a space in their username it is a very easy fix.  Just use the stringByAddingPercentEscapesUsingEncoding function to have the string properly encoded:

[username stringByAddingPercentEscapesUsingEncoding: NSASCIIStringEncoding];

So if you come along a WebKitErrorDomain 101 error – take a look at the URL you are trying to submit and see if all the parts of it are properly encoded.

The application exist in two states:

1) Record distance using GPS

2) Record distance using pedometer

Switching from pedometer to GPS is instant – once GPS signal is adequate distance is now recorded using GPS.

Switching from GPS to pedometer will occur if an adequate GPS signal has not been received over a period of 20 seconds.  At this point the pedometer will take over calculating the distance and since it had not been recording distance for the previous 20 seconds the pedometer will calculate the distance that was traveled over those 20 seconds by rolling up the number of steps that were taken since the last good GPS signal was received.

I already have a JavaScript and a PHP version of the functions that both encode and decode GPS data as a Google polyline – so it was just a matter of converting the functions to Objective-C / Cocoa.

The way that the encoder works is first it multiples the coordinate by 10e5, takes the floor value and compares it to the coordinate to the 10e5 value of the previous coordinate and encodes the difference between the two points.  The following are functions used to perform the basic math.

This function is used to multiply the coordinate by 10e5:

- (int) floor1e5: (double) coordinate {
 return (int) floor(coordinate * 1e5);
}

This function is used to encode a signed number:

- (NSString *) encodeSignedNumber: (int) num {
int sgn_num = num << 1;
 if (num < 0) {
 sgn_num = ~(sgn_num);
 }
 return [self encodeNumber: sgn_num];
}

And this function is used to encode an unsigned int:

- (NSString *) encodeNumber: (int) num {
 int nextValue;
 NSMutableString *encodeString = [[NSMutableString alloc] initWithCapacity:5];
 [encodeString autorelease];

 while (num >= 0x20) {
 nextValue = (0x20 | (num & 0x1f)) + 63;
 [encodeString appendFormat:@"%c", ((char) (nextValue))];
 num >>= 5;
 }

 num += 63;
 [encodeString appendFormat:@"%c", ((char) (num))];

 return encodeString;
}

The following function is used to encode an array of CoreLocation objects (CLLocation *).  This array is called locations in the following code.  The  first thing the function does is to make sure that there are points in our locations assay.  Next I setup a mutable string which is going to contain the encoded polyline string as well as a temporary CoreLocation object (tmploc).  Since we have not started going through the locations we set the previous latitude and longitude to 0 each (plat and plng).  Then I go through the locations array and put them into the temploc.  For each location the previous latitude and longitude is subtracted from the current after the 1e5 conversion.  The encoded latitude and longitude are then added to the encoded polyline string which is returned at the end of the function.

- (NSString *) googlePolyline {
 int i, late5, lnge5, dlat, dlng, plat, plng;

 if ([locations count] == 0) {
 return @"";
 }

 NSMutableString *encodedPoints = [[NSMutableString alloc] initWithCapacity:100];
 [encodedPoints autorelease];
 CLLocation *tmploc;

 plat = 0;
 plng = 0;

 for (i = 0; i < [locations count]; i++) {
 tmploc = [locations objectAtIndex:i];

 late5 = [self floor1e5: tmploc.coordinate.latitude];
 lnge5 = [self floor1e5: tmploc.coordinate.longitude];

 dlat = late5 - plat;
 dlng = lnge5 - plng;

 plat = late5;
 plng = lnge5;

 [encodedPoints appendFormat:@"%@%@", [self encodeSignedNumber:dlat], [self encodeSignedNumber:dlng]];

 }
 return [[[NSString alloc] initWithFormat: @"%@", encodedPoints] autorelease];
}

The googlePolyline function can be used to convert an array of location objects to a simple string which can then applied directly to a google map.

For other ports of the google polyline encoder see:

http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/