My project template for iOS working on Xcode 4 has been updated. I use a storyboard file (iOS 5 and later) rather than xib. Since all the source code including the content of the storyboard is not hard-coded in the template, You can easily modify their contents without having a catastrophe (adding/removing files needs some efforts though). If you are not familiar with storybords, the following guide will be helpful:

• View Controller Programming Guide for iOS – iOS Developer Library

You can find the complete template at my repository:

• borealkiss/Minimal-Template – GitHub

In order to make an application universal one has to detect the device’s idiom (iPhone/iPad) at run time. This is easily done with the following conditional:

if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){
	//iPad specific codes.
}
else{
	//iPhone specific codes.
}

You might have used this conditional, for example, when you want to control a view’s rotation or a modal view’s behavior depending on the current device’s idiom. The above conditional is simple and easy to implement when the application is simple. However once the application has lots of behaviors varying on the device’s idiom here and there, your source codes will get messy and hard to read and/or maintain, due to the duplication of this snippet spreading over your project.

Fortunately this will be easily resolved by using the well known State pattern. As the name suggests, State pattern deals with the internal state of its participating context and does some work without unnecessarily exposing other states that the context could have. As describing such patterns only in words is always hard to figure out, I’ll give you an example to walk through with.

Example

Consider the following situation. You want to control a view’s rotation depending on the device’s idiom:

• On iPhone, the application allows one of portrait modes (Home button at the bottom).
• On iPad, the application allows both portrait and landscape modes.

The implementation for this in a straightforward way looks like this:

-(BOOL)shouldAutorotateToInterfaceOrientation:
					(UIInterfaceOrientation)interfaceOrientation{
 
	if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){
		//iPad.
		return YES;
	}
	else{
		//iPhone.
		if (orientation == UIInterfaceOrientationPortrait){
			return YES;
		}
		return NO;
	}
}

In this example, I’ll add some tweaks for the above snippet to look cleaner. That is:

1. Wrap the codes inside the conditional into a block object.
2. Register them in a dictionary object.
3. Retrieve the block object from the dictionary when needed.
4. Invoke the block.

1-2. Create blocks and register them in dictionaries

The key trick here is wrapping into blocks will done for iPhone and iPad separately:

//For iPhone.
BOOL (^blockiPhone)(UIInterfaceOrientation orientation) = 
						^(UIInterfaceOrientation orientation){
	if (orientation == UIInterfaceOrientationPortrait){
		return YES;
	}
	return NO;
};
 
[_dictionaryForiPhone setObject:[[blockiPhone copy] autorelease] 
						forKey:@"viewRotation"];

//For iPad.
BOOL (^blockiPad)(UIInterfaceOrientation orientation) = 
						^(UIInterfaceOrientation orientation){
	return YES;
};
 
[_dictionaryForiPad setObject:[[blockiPad copy] autorelease] 
						forKey:"viewRotation"];

Here the dictionary objects as a registry assume to be instance variables in the class.

NSMutableDictionary *_dictionaryForiPhone;
NSMutableDictionary *_dictionaryForiPad;

Note that although the value of the key string here is arbitrary, you would better give a meaningful name for its later usage. Also note that since block objects are yet in the stack, they must be copied to the heap before adding to the collections.

3. Retrieve blocks

Then I provide a method retrieving a appropriate block object corresponding to the device’s idiom:

//Incomplete.
-(id)blockForKey:(NSString *)key{
	if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){
		return [_dictionaryForiPad objectForKey:key];
	}
	else{
		return [_dictionaryForiPhone objectForKey:key];
	}
}

This is redundant since the conditional inside the method gets evaluated each time the method gets called. So add I additional tweaks. These look like this;

//Complete
-(id)blockForKey:(NSString *)key{
	if (!_idiomDetected){
		if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){
			_dictionaryForCurrentIdiom = _dictionaryForiPad;
		}
		else{
			_dictionaryForCurrentIdiom = _dictionaryForiPhone;
		}
		_idiomDetected = YES;
	}
 
	return [_dictionaryForCurrentIdiom objectForKey:key];
}

Here two new instance variables are introduced:

BOOL _idiomDetected;
NSDictionary *_dictionaryForCurrentIdiom;

The boolean value is used for testing whether the application already detected the device’s idiom or not. If detected the application skips the conditional. If not, the application tries to detect the current device’s idiom and assign the reference to the appropriate block dictionary to _dictionaryForCurrentIdiom. Doing this, block objects will be retrieved only from this referencing dictionary, hiding the fact that there are actually two different collections of blocks (iPhone/iPad), thanks to State pattern.

4. Invoke blocks

Finally the above method will get called in the right place:

-(BOOL)shouldAutorotateToInterfaceOrientation:
					(UIInterfaceOrientation)interfaceOrientation{
	BOOL (^block)(UIInterfaceOrientation) = [self blockForKey:@"viewRotation"];
	return block(interfaceOrientation);
}

Note that in order to invoke a block correctly one must know the type of the block properly (Since you are the adder of blocks, you must know well their types, right?).

Now my codes are free from conditional, looking very tidy. Although the example here is trivial, this pattern will give you its real strength when the application has more and more device specific behavior (controlling modal views, if iPhone 4S, if iPad 2, and so on).

BKUIIdiomController

If you want to try this but save your time, here is my idiom controller class. The class only has two APIs:

-(void)setBlockForiPhone:(id)blockForiPhone 
				blockForiPad:(id)blockForiPad forKey:(NSString *)key;
-(id)blockForKey:(NSString *)key;

The first method for registering blocks (one for iPhone, the other for iPad) associated with a given key string. The second is for retrieving an appropriate block for the current device’s idiom. You could easily understand how to use this if you read this article. The demo project with full source codes are below:

• borealkiss/BKUIIdiomController – GitHub

Why subclassing? Because I’m bored by preparing a bare-bone singleton from scratch.

+[NSObject initialize] is invoked only once in a thread-safe manner before a class object receives any message (for more detail see NSObject Class Reference). Therefore this method could be a good place for a singleton instance to be created.

Here is my singleton class. I won’t show the complete implementation here. To be robust you should control methods concerning allocation such as alloc, init, copy, etc. However these are not of importance here. To check these visit the following site:

• https://github.com/borealkiss/BKSingleton

//BKSingleton.h
 
#import <Foundation/Foundation.h>
 
@interface BKSingleton : NSObject{
 
}
 
/**
 * Returns a singleton instance.
 */
+(id)sharedInstance;
 
@end

//BKSingleton.m
 
#import "BKSingleton.h"
 
static NSMutableDictionary *_dictionary = nil;
 
@implementation BKSingleton
 
+(id)sharedInstance{
	NSString *className = NSStringFromClass(self);
	return [_dictionary objectForKey:className];
}
 
+(void)initialize{
	if (!_dictionary){
		_dictionary = [[NSMutableDictionary dictionary] retain];
	}
 
	NSString *className = NSStringFromClass(self);
 
	if (![_dictionary objectForKey:className]){
		[_dictionary setObject:[[[self alloc] init] autorelease] forKey:className];
	}
}
 
@end

When a subclass of this class is first received a message, the initialize method of this class is invoked (i.e., +[BKSingleton initialize]) unless this is overridden in the subclass.

The first trick here is that there is no hard-coded class names inside the initialize method (e.g., something like [MyClass alloc]). Thanks to this even the subclass is received its superclass’s initialize method, it is always instantiated by the correct class.

The second trick is that the instance of a subclass is stored in a static class dictionary associated with its class name if there is not such an object with the same key found in the dictionary. Doing this ensures that the dictionary holds a unique instance for each subclass.

Let’s see an example. There are two subclasses inherited from BKSingleton. They have nothing newly implemented.

//Singleton1
 
#import "BKSingleton.h"
 
@interface Singleton1 : BKSingleton{
 
}
 
@end
 
@implementation Singleton1
 
@end

//Singleton2
 
#import "BKSingleton.h"
 
@interface Singleton2 : BKSingleton{
 
}
 
@end
 
@implementation Singleton2
 
@end

Then run the following code.

//main.m
 
#import <Foundation/Foundation.h>
#import "BKSingleton.h"
#import "Singleton1.h"
#import "Singleton2.h"
 
int main(int argc, char *argv[]) {
	NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	NSLog(@"BKSingleton: %@", [BKSingleton sharedInstance]);
	NSLog(@"Singleton1: %@", [Singleton1 sharedInstance]);
	NSLog(@"Singleton2: %@", [Singleton2 sharedInstance]);
 
	//Once again
	NSLog(@"BKSingleton: %@", [BKSingleton sharedInstance]);
	NSLog(@"Singleton1: %@", [Singleton1 sharedInstance]);
	NSLog(@"Singleton2: %@", [Singleton2 sharedInstance]);
 
	[pool release];
	return 0;
}

The output is the following, ensuring they are al unique, i.e., singletons.

Test[1153:207] BKSingleton: <BKSingleton: 0xe0a880>
Test[1153:207] Singleton1: <Singleton1: 0xe08d20>
Test[1153:207] Singleton2: <Singleton2: 0xe0b620>
Test[1153:207] BKSingleton: <BKSingleton: 0xe0a880>
Test[1153:207] Singleton1: <Singleton1: 0xe08d20>
Test[1153:207] Singleton2: <Singleton2: 0xe0b620>

Related links

• design patterns – What does your Objective-C singleton look like? – Stack Overflow
• Eschatology : Singletons in Cocoa/Objective-C

WinGen is a utility plugin for Goole Chrome. It offers the following functions for easier web browsing specifically concerning hyperlinks:

Function 1

WinGen navigates a hyperlink in a new window without using the context menu (i.e., control + click). As a Mac user, when you want to open a new window for links on a web page, you need to click the control key to popup the context menu to choose “open in new window”. This requires to use your both hands. With WinGen simply clicking the link and hold for a while navigates that page in a new window. Your another hand will be now free. Keep a cup of coffee.

Function 2

WinGen could disable forced new window specified by target=”_blank” attribution. Have you been bothered by lots of auto new window creation within one web site? With WinGen clicking such links won’t popup new windows.

Function 3

As a optional function, WinGen could disable hyperlinks themselves. Have you needed to copy some parts of the text within a hyperlink? I’m sure copying all the text from the hyperklink is easy but trying partial copying always navigates you into a different page for that link. With WinGen when you control+click on a link, WinGen gives you enable/disable hyperlink options (I’m sorry this requires the context menu. You need the both hands).

Let me show an example. I want to copy the word “spectator” from the link “What a spectator threw at Tiger Woods” (from today’s yahoo news).

First of all I turn on this function from the WinGen option page (the function is off by default).

Control+clicking on the link popups the WinGen menu. Then I select “disable hyperlink”.

Now the link is just a text so I can copy the word “spectator”. I could also restore the link by “enable hyperlink” after that.

Related links

• WinGen Homepage
• WinGen on Chrome Web Store
• borealkiss/WinGen – GitHub (for developers)

My newest iPhone app Moiré is ready. The app dynamically generates Moiré pattern, an interference pattern created by multiple regular patterns overlaid on each other. The app offers the following features:

• Simple interface. You can control the app without instructions.
• 36 basic patterns. The number of generated Moiré is infinity.
• Wallpaper creation. You can use resultant images as a wallpaper of your device.

Here are some example images. You can see more on Moiré Homepage.

The app is greatly inspired by the book Moiré Index by Carsten Nicolai. Since the book doesn’t offer dynamic contents, I would like to do so.

Now on App Store

Moiré is now on App Store for $1.99.

One of my iPhone apps Nespresso Stock Checker has been updated to version 3.2 including the following new features.

What’s new in Version 3.2

• Compatible with Onirio Limited Edition 2011 released on April.

  

• Show route on Maps. This function enables you to show a route from your location to a boutique using Maps app (external).

  

Now on App Store

Nespresso Stock Checker is now on App Store for $1.99.

[Note on 09.04.2011: This article will not be helpful unless you really need universal static libraries for distribution purposes etc. Instead, using workspace is a better way for daily development.]

Introduction

Creating static libraries universal for iPhone device and simulator is a little bit tricky. On Xcode 3.x, the major way takes something like the following steps:

• Create a build for the device (the armv6 and armv7 architecture).
• Create a build for the simulator (the i386 architecture).
• Merge the above builds to create a universal build using lipo.

Since Xcode, 4 a new command called archiving (Product > Archive) is introduced as a way to distribute applications and/or static libraries. At glance this is suitable to creating a universal libraries but is not. One can not select this option for the simulator environment (you will notice it is always grayed out). As such we still have to rely on the traditional way to create universal libraries (¹).

In this article I will show you how to create such a fat static library on Xcode 4. Because the place for product builds of each project are completely changed from those of Xcode 3.x, we have to make a slight effort tailoring it to the Xcode 4.

How to do

In the following example I will use my project called BKMovableVC. On your workspace you can use whatever name you want, of course.

Step 1

Create a new Cocoa Touch Static Library target (File > New > New Target > Framework & Library) for the simulator environment. Naming is arbitrary as long as you can recognize (I named here BKMovableVC-iphonesimulator). Add related source files to the Compile Source pane and headers to Copy Header pane. For headers you can choose three possible places to put in, Public , Private, and Project (default is Project). For example if you choose Public, all headers will be automatically copied to the build directory, which is easy for me to continue following works.

[Note on 04.05.2011: There is a bug on Xcode 4; when all panes (Public, Private, and Project) in the Copy Header pane are closed or never opened before, pushing the add button causes a crash. Open one of them before adding files.]

From the Edit Scheme pane (Product > Edit Scheme), change its build configuration to Release. This enables you to create a Release build product once the build operation is done. This build operation supposes to be done on the simulator architecture (i386).

Step 2

Create a new static library target for the iPhone device environment. Naming is arbitrary but must be different from that of the simulator (I named here BKMovableVC-iphoneos). Add related source files and headers and change its build configuration to Release. Every step is just the same as that of the simulator except for the build architecture; this build operation supposes to be done on the device architecture (armv6 and armv7).

Now we have two targets, one for the device and the other for the simulator. When you build a product, the product will be placed under the following directory:

~/Library/Developer/Xcode/DerivedData/

This place is shared by build products of all projects created on Xcode 4, which is quite different from the legacy place found on Xcode 3.x (each project has its own build directory). For example, if the name of the project is BKMovableVC, the Release build product for the simulator will be placed at

~/Library/Developer/Xcode/DerivedData/BKMovableVC-xxxxxxx/
	Build/Products/Release-iphonesimulator/
	libBKMovableVC-iphonesimulator.a

and that for the device will be found at

~/Library/Developer/Xcode/DerivedData/BKMovableVC-xxxxxxx/
	Build/Products/Release-iphoneos/
	libBKMovableVC-iphoneos.a

where BKMovableVC-xxxxxxx is a unique directory name automatically assigned by Xcode 4.

Step 3

Let’s merge them using the lipo command. Create a new Aggregate target (File > New > New Target > Other). I named it here BKMovableVC-ios4.3-0.9. On the Build Pheses pane select Add Run Script from the Add Build Phase button on the bottom-left corner.

Now we are about to run some scripts on the Run Script pane but here is a problem. How do we direct lipo to work with builds that are placed under the directory whose name is automatically assigned by Xcode 4 (e.g., BKMovableVC-xxxxxxx for the above case)? Fortunately it is easily solved by the Xcode 4 environment variable called ${BUILT_PRODUCTS_DIR}. This variable represents the path to the directory for a current build product. For example, when we create a Release build product for the simulator explained above, ${BUILT_PRODUCTS_DIR} corresponds to the following path:

~/Library/Developer/Xcode/DerivedData/BKMovableVC-xxxxxxx/
	Build/Products/Release-iphonesimulator/

Let’s continue. Write the following script on the Run Script pane. This lets lipo create a merged build product called libBKMovableVC-ios4.3-0.9.a (you can give it whatever name you want). If there is already the product with the same name lipo deletes it before the merge operation as shown in the first line.

rm -rf ${BUILT_PRODUCTS_DIR}/libBKMovableVC-ios4.3-0.9.a
 
lipo -create "${BUILT_PRODUCTS_DIR}/../${BUILD_STYLE}-iphonesimulator/libBKMovableVC-iphonesimulator.a" \
"${BUILT_PRODUCTS_DIR}/libBKMovableVC-iphoneos.a" -output \
"${BUILT_PRODUCTS_DIR}/libBKMovableVC-ios4.3-0.9.a"

Here is one trick. In this script the path representation to previously created build products such as libBKMovableVC-iphonesimulator.a looks odd because of “/../”. This is because the environment variable ${BUILT_PRODUCTS_DIR} depends on a current build phase (iPhone device, simulator, Debug, Release). For example, if this script runs for the Release build of iPhone device, the variable ${BUILT_PRODUCTS_DIR} will represent

~/Library/Developer/Xcode/DerivedData/BKMovableVC-xxxxxxx/
	Build/Products/Release-iphoneos/

However the build product for the simulator, libBKMovableVC-iphonesimulator.a, is not placed under this path, because it was created through a different build phase.

Implementation

Let’s do all the flows in order. Do the following:

1. Build the target BKMovableVC-iphonesimulator on the simulator. The build phase must be Release.
2. Build the target BKMovableVC-iphoneos on the device. The build phase must be Release.
3. Build the target BKMovableVC-ios4.3-0.9. on the device. The build phase must be Release.

Then you will have a static library universal for the device and simulator in the following directory:

~/Library/Developer/Xcode/DerivedData/BKMovableVC-xxxxxxx/
	Build/Products/Release-iphoneos/
	BKMovableVC-ios4.3-0.9.a

You will also have header files depending upon your configuration (see the text above).

Footnotes

1. Of course there could be a way to create a universal library on one scheme by tuning build settings but I have not found it by myself nor on the web. [↩]

Introduction

Many people have their own project- and/or file-templates for practical or aesthetic reasons. For example I don’t like the naming convention provided by Apple such as XXXX-Info.plist, XXXX-Prefix.pch, and XXXXAppDelegate for the project XXXX. On Xcode 3.x. it was relatively easy to modify them. Since Xcode 4, however, Apple introduced a new template format that is no longer compatible with those of Xcode. 3.x. This has often become topics among Apple’s developer forums, since there is no official information provided. You can see how it changes from the Xcode 4 built-in templates. They are under

/Developer/Library/Xcode/Templates/

for Mac OS X stuffs and

/Developer/Platforms/iPhoneOS.platform/Developer/Library/Xcode/Templates/

for iOS. If you add your own templates, the place you should use is under the following path:

~/Library/Developer/Xcode/Templates/

The problem is that it is quite hard to create a custom template. For example, to copy and paste the built-in template to your place will not show up the template on Xcode 4 until you manually change its identifier in TemplateInfo.plist.

TemplateInfo.plist

TemplateInfo.plist is basically a setup file for a Xcode 4 project. When creating a project, Xcode 4 first reads this file to prepare all environment for you to get started. Each TemplateInfo.plist has own identifier for Xcode 4 to distinguish from others (and that’s why copy-and-pasting built-in template described above does not work as a user template). If you need your own templates, you should give them your own identifiers. For example, the Xcode 4 built-in template for window based iPhone application has the following identifier:

com.apple.dt.unit.windowBasedApplication

TemplateInfo.plist has something inheritance nature like classes of programming languages (and the identifier corresponds to the name of class). Xcode 4 reads a given TemplateInfo.plist and aggregates data from its ancestral files. For example, the following figure shows pedigree charts for the built-in window based iPhone application template.

You can see that the TemplateInfo.plist for the window based iPhone application template is the sixth generation from the top-most base file (com.apple.dt.unit.base). This demonstrates that when you want to customize a given TemplateInfo.plist and the place you want to change within comes from the ancestral files, you have to manipulate multiple files, i.e., it could be error prone. Since TemplateInfo.plist is just an XML file, there is no compile errors. Moreover the inheritance nature of XML files has no readability at all. In fact it seems Apple creates them not by coding but by automatic generation tools.

A minimal project template

This was originally just for me but since it founds to be useful I will share this with someone who wants to have own templates on Xcode 4. This contains several templates within but only shows up one window based application template on Xcode 4 (the identifier is com.borealkiss.windowBasedApplication), because the others are not a concrete template (there are abstract templates not to be actually implemented). The following figure shows the contents (gray and orange ones are included):

This template enables you to manipulate in the old way as of Xcode 3.x, i.e., editing actual files and adding onto templates. Basically you only have to manipulate the TemplateInfo.plist of com.borealkiss.windowBasedApplication. You can add whatever files you want as long as you do the following edits. For example, if you want add a given file called SomeClass.m, you add the following two parts into the TemplateInfo.plist of com.borealkiss.windowBasedApplication:

These are the definition part of the file:

<key>Definitions</key>
<dict>
	<key>SomeClass.m</key>
	<dict>
		<key>Path</key>
		<string>SomeClass.m</string>
	</dict>
</dict>

and its actual implementation:

<key>Nodes</key>
<array>
	<string>SomeClass.m</string>
</array>

If you want to add the file but not for the target of Copy Bundle Resources (like Info.plist, Prefix.pch, and header files), change the definition as follows:

<key>Definitions</key>
<dict>
	<key>SomeClass.m</key>
	<dict>
		<key>Path</key>
		<string>SomeClass.m</string>
		<key>TargetIndices</key>
		<array/>
	</dict>
</dict>

You can add it inside a given folder. For example if you want to add the file inside a directory called MyClasses, change the definition as follows (note that the key name should be consistent with the actual file path, otherwise the file location in the project will be different from that seen in the Finder’s view):

<key>Definitions</key>
<dict>
	<key>MyClasses/SomeClass.m</key>
	<dict>
		<key>Group</key>
		<string>MyClasses</string>
		<key>Path</key>
		<string>MyClasses/SomeClass.m</string>
	</dict>
</dict>

<key>Nodes</key>
<array>
	<string>MyClasses/SomeClass.m</string>
</array>

[Update on 06.04.2011]

Some reader gave me a tip how to add files in a subgroup (i.e., the group inside a group). As an example consider the following situation; you are adding the SomeClass.m file that is in the location below and wanting to add it in the same directory.

Classes/SomeClass/SomeClass.m

In this case you can do this by changing a definition part:

<key>Definitions</key>
<dict>
	<key>Classes/SomeClass/SomeClass.m</key>
	<dict>
		<key>Group</key>
		<array>
			<string>Classes</string>
			<string>SomeClass</string>
		</array>
		<key>Path</key>
		<string>Classes/SomeClass/SomeClass.m</string>
	</dict>
</dict>

and its nodes part:

<key>Nodes</key>
<array>
	<string>Classes/SomeClass/SomeClass.m</string>
</array>

I also added these examples on my templates (link listed at the bottom).

Caution before editing

Keep in mind that TemplateInfo.plist is a setup file for Xcode 4 and any invalid manipulation would cause unexpected actions. For example, the following figure shows a normal behaviour of Xcode 4 during a new project creation, showing a product name and company identifier input (other options such as unit testing are disabled). And pushing the next button asks you which directory to create the project (as expected).

The following wizard pane is abnormal one after some ill manipulation. No product name input is found. Fortunately you cannot go further by pushing the next button.

However the worst case happens when you could go further. Even if you meet the situation, do NOT push the next button; Xcode 4 creates a project inside the directory you intend to place the project. For example the directory you are placing your project folder is Desktop, Desktop will become the project folder and other irrelevant files will be gone. I had two times desktop-sweeping during the try-and-error manipulation. Be careful.

Downloads

• https://github.com/borealkiss/Minimal-Template

License

This template is provided under the terms of the MIT license for the reason above, i.e., feel free to use it but at your own risk.

Imagine there is an image that contains dots randomly distributing. When the image rotates around a given point in the image by small angle and the rotated image is superimposed on the original one, this makes a Moiré pattern that is perceptible to human eyes.

In the video, random 1000 dots and their rotated ones (rotated around the center of the screen) are simultaneously drawn in each frame. You can see some circular and/or spiral patterns in the dots storm.

This is one of the reasons why mathematics is so beautiful. The equations from Butterfly curve (transcendental). The drawing was performed on the iPhone simulator because I am an iPhone app developer.