Each week you will be given a simple task to complete and the results is a series of photos submitted by the participants from around the world. The project will go on for one year (hence the 52 in 52 moments)

The official launch for 52 Moments is Jan 13, 2012. See you there.

Let's take a quick look at what TestFlight is all about and what they offer.  For a complete overview of the latest and greatest of the service, you should of course sign up and visit the site directly. If you are already using TestFlight for your beta testing, you can also skip this and go straight to the next section.

1) Sign in after registration

2) Check the email on any of your test devices and login:

3) Tap Register Device to send your UDID over to TestFlight.

4) TestFlight sends back the provisioning profile over the air. What are you waiting for, tap Install!

5) Your device is now registered with your TestFlight's database.

6) Now that you have registered some devices for testing, let's submit a build to TestFlight.

7) We created the adhoc build in Xcode, saved the ipa file in Organizer, went to the folder where the ipa file is stored and dropped it here. Notice that it's quite a bit of work -- we will discuss how to automate this step without relying on Xcode later in this article, giving you a more pleasant test flight. :)

8) When your ipa file is done uploading, this is what you will see, and it's where most of the power of TestFlight lies. In particular, pay attention to the left pane: History shows you the upload history of each build of the app, along with feedback sent by testers (from within the app), crash reports, test session info (such as what your testers have tested and how long), etc.
(Names and photos have been blurred to protect the innocence)

9) Crashes has got to be the #1 concern when it comees to testing. Be sure to upload your dSYM file so TestFlight can make sense of the crash reports coming from your build.

10) This is an example crash report received from a test run of an app we worked on. Sexy, no?

At this point, assuming we have convinced you enough to start trying out TestFlight, here comes one last goodies. (Names and photos have been blurred to protect the innocence)  

Step (7) and (9) requires that you mess around with doing the build and uploading your ipa file and dSYM file to TestFlight. Wouldn't it be nice if this can somehow be taken care of as well? Well, you have chosen the right profession. All you need is create a shell script to automate this task and to save you time, we have created a script to do precisely that. If you are a gluten for punishment, you can skip the following and continue to use the good old Xcode way.

Quick HOWTO:
1) Save the script above to build.sh
2) chmod +x build-ipa.sh
3) ./build-ipa.sh

Let's take a look at the script to automate the building and submission of our app to TestFlight:

#!/bin/sh
ProjectPath="~/Projects/Test/"
Target="TestApp"
AdHocPath="build/AdHoc-iphoneos/"
AdHocConfigurationName="AdHoc"
DeveloperName="developer name"
ProvisionFile="8490865F-4F60-41BA-98EA-EA2E7B470CF2.mobileprovision"
ipaName="TestApp"
api_token="your test flight api key"
team_token="your test flight team token"
notes="Beta build #1"

// Step (1)
xcodebuild -target "$Target" -configuration ${AdHocConfigurationName}

// Step (2)
xcrun -sdk iphoneos PackageApplication -v "${AdHocPath}${Target}.app" -o ${ProjectPath}${ipaName}.ipa --sign "${DeveloperName}" --embed ${ProvisionFile}

// Step (3)
pushd .
cd ${AdHocPath}
zip -r ${ipaName}.app.dSYM.zip ${Target}.app.dSYM/

// Step (4)
popd
curl -v http://testflightapp.com/api/builds.json \
  -F file=@${ipaName}.ipa \
  -F api_token="${api_token}" \
  -F team_token="${team_token}" \
  -F notes="${notes}"\
  -F notify=True \
  -F replace=False \
  -F dsym=@${AdHocPath}${ipaName}.app.dSYM.zip 

// Step (5)
rm ${AdHocPath}${ipaName}.app.dSYM.zip

Explanations:

Step (1) Here we use the xcodebuild command to build the project of our choice. Configure the target name and the configuration profile in the shell variables above it. In our case we are doing an adhoc build for our TestApp.
Step (2) We then use xcrun to create the ipa file. The command also takes care of embedding the provisioning profile into the ipa.
PackageApplication is a perl file locate at /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/PackageApplication
The rest should be self-explanatory.

NOTE: In case you wonder, ipa stands for iPhone Application. It's technically a folder and in Unix a folder is essentially a file.

Step (3) After the ipa file is generated, the script proceeds to zip up the dSYM folder. This way when TestFlight receives a crash report from your beta builds, it will be able to make sense of things in the event that you have configured the build setting for the build process to strip the debug symbols out of the build (e.g. to reduce file size).

NOTE: We use the Unix command "pushd ." to save where we are at before traversing into the build folder so we can return later with "popd".

Step (4) We are now at ready to send the build off to TestFlight. Retract back to the project folder and use curl command to do the delivery. The parameters should be self explanatory so we won't get into them.

Step (5) Finally we remove the dSYM zip file to keep things clean. You may choose to skip this step if you wish to keep it around for later use.

With the build uploaded to TestFlight, you can now notify your beta users to start testing it away! Perhaps the next logical step for TestFlight is to automate the finding of beta testers for developers (sorry, we couldn't automate this part with shell script).

"Thanks for flying with TestFlight and we hope you will fly with us again."

Disclaimer: This article is the result of our subject evaluation with TestFlight. We are in no way affiliated with TestFlight and have received no bonus miles in promoting their service.

1) Modified Navigation

Hold down Option key and click a file in the Project Navigator pane.  The file opens up in the assitant editor window.

Hold down Command key and double click a file in the Project Navigator pane.  The file opens up in a new window.

Hold down Shift + Option key and click a file in the Project Navigator pane.  A coverflow view shows up and you can now choose where the file should appear.

2) Show/hide Navigator

Command + 0 to show/hide the navigator.  More space for your code!

To navigate around your code, use Open Quickly and Jump bar (discussed below).

3) Quick Help

Quick help does more than just showing you the documentation for Apple's API.  It helps you out with the Build Settings as well.  Thanks for the quick help!

4) Jump bar

Jump bar is a great way to quickly navigate around your code without using the project navigator pane.  Think of it as a mini version of project navigator.

Simply click and hold down your mouse in different section of the bar to access folders or files in that scope.

Command + click the jump bar to show the entries sorted alphabetically.  Option click on a file to open it in the assistant editor view (just like it would in Project navigator).

With the jump bar popup list open, type any word to quickly find what you are looking for.  Isn't that cool?

Want to get to other files related to the current one? Click on the left most icon on the jump bar and you see this:

5) Code Snippets

Code Snippet Library is a great way to speed up your coding.  The greatest benefit comes from being able to define your own custom snippets by simply dragging your code snippet into the library.  If you want your own text bubble, simply put it in between #text shows up in bubble#

In this series, we will dissect Cocos2D a little bit at a time, pick up valuable coding techniques and examine design patterns and decisions utilized by Cocos2D along the way.

We will start off by looking at the entry point, the heart of Cocos2D - the CCDirector class.  CCDirector is a singleton class that manages and coordinates the overall operation of your game.  Another common name for this in a game framework is a Game Manager.  Most of the time there is only one game manager managing an entire game, that's why CCDirector is a singleton class.

Let's look at some code snippets in CCDirector and see what we can learn from it:

static CCDirector *_sharedDirector = nil;

+ (CCDirector *)sharedDirector
{
	if (!_sharedDirector) {

		//
		// Default Director is TimerDirector
		// 
		if( [ [CCDirector class] isEqual:[self class]] )
			_sharedDirector = [[CC_DIRECTOR_DEFAULT alloc] init];
		else
			_sharedDirector = [[self alloc] init];
	}
		
	return _sharedDirector;
}

+(id)alloc
{
	NSAssert(_sharedDirector == nil, @"Attempted to allocate a second instance of a singleton.");
	return [super alloc];
}

The above code snippet implements a singleton. The static keyword appearing in the class scope has different semantic than had it appear in a method/function scope. In class scope, the static keyword means your variable is internally linked only and therefore not visible outside of this class. In method/function scope, a static variable persists its value across multiple calls to the method, which makes it behaves like a member variable but visible to your method only.

The alloc method makes it so if you attempt to instantiate CCDirector directly (via the regular two-staged creation of alloc-init), your code will fail the assertion.

The code snippet above is typically how you would implement singleton for your class.

Notice the class check inside the init method, which isn't always present in typical singleton implementation. What does this do?
[ [CCDirector class] isEqual:[self class]]

This tests to see if the instantiation is on the abstract base class or from one of its derived concrete classes. If it is from the base class, instantiate the default derived class via the macro CC_DIRECTOR_DEFAULT. Currently there are four types of CCDirector-derived classes for iOS (implemented in CCDirectorIOS.m class) and one type for Mac (CCDirectorMac.m class).
For CCDirectorIOS, they are briefly: CCDirectoryTypeNSTimer, CCDirectorTypeMainLoop, CCDirectorTypeThreadMainLoop, and CCDirectorTypeDisplayLink. We will look at these in more details in a later series.

Since we mention CCDirectorIOS, we will digress a little and look at one code snippet in CCDirectorIOS class:

@interface CCDirector ()
-(void) setNextScene;
-(void) showFPS;
-(void) calculateDeltaTime;
@end

This is a category method for CCDirector. Why does it appear inside CCDirectorIOS? Actually with this technique, you are able to implement CCDirector's private method setNextScene from within CCDirectorIOS that you wouldn't otherwise able to. This is the same technique developers use to override Apple's private API's implementation. The downside to using category method technique to extend/change the behavior of a base class's method is that you can't call the base class's method like you can via inheritance using the super keyword.

That's all for this series. In the next series, we will look at CCDirector in more details and learn a few tricks along the way.