The command is:

defaults write com.apple.Finder AppleShowAllFiles YES


The Finder needs to be restarted for this change to take effect. Luckily there is a Terminal command for this too:


killall Finder


Once you are done playing around with hidden files, you can stop showing them by replacing YES with NO in the original terminal command.


defaults write com.apple.Finder AppleShowAllFiles NO


It is as simple as that, but make sure your don’t break anything.

When I first thought about this problem, I was thinking along the lines of build a custom log function lets say MagicLog() and this calls a function that saves the string to a file. The problem with this is that I would have to go through all of my code and add MagicLog() to everywhere that I have NSLog(), that seemed a bit to verbose for my liking.

After searching on the internet I found out that (rather obvious) NSLog runs over standard error. This means that you are able to simply redirect standard error to a file using the ANSI function freopen().


FILE *freopen(const char *restrict filename, const char *restrict mode, FILE *restrict stream);


http://www.opengroup.org/onlinepubs/000095399/functions/freopen.html

Before we can save NSLog() to a file, we first have to find a place to save it. The best place to do this is the application’s documents folder. To get this you can use the following code snippet:


NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask, YES);
NSString *documentsDirectory = [paths objectAtIndex:0];


Once we have the documents folder, we need to give a name to the file. To make it easy for me I just name it “the date”.log :


NSString *fileName =[NSString stringWithFormat:@"%@.log",[NSDate date]];


To make this into a valid path, use the NSString method stringByAppendingPathComponent


NSString *logFilePath = [documentsDirectory stringByAppendingPathComponent:fileName];

The last step is to redirect stderr to this file


freopen([logFilePath cStringUsingEncoding:NSASCIIStringEncoding],"a+",stderr);


To keep my code maintainable I keep all of this as a function, and I call it in my AppDelegate if I want to turn this functionality on.


- (void)redirectNSLogToDocumentFolder{
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask, YES);

Getting the file.

Now that you have logged all the information you need, you will want to get this off of the device. Thankfully this is easy as well. Simply open the organiser in Xcode and select the device that is currently connected to your Mac.

A the bottom of the main pain there is an application section. Open the detail disclosure on the application you want to get the data from, and hit the little download button to the right of the Application Data package. You will be prompted to save this folder to your mac.

Warning:
Writing to the file system on the iPhone is slow, so this will effect the performance of your application. Therefore DO NOT ship an application with this in, or give it to people that can’t stand poor performance.

At first glance it would seem that the Cocoa Frameworks do this for you, and you would be right …. well kind of.

The issue is that by default most of these methods leave characters such as & = ? within a URL, as they are strictly speaking valid. The problem is that these characters have special meanings in a GET request, and will more than likely make your request in valid.

Luckily there is a function in Core Foundation that helps:

CFStringRef CFURLCreateStringByAddingPercentEscapes (
CFAllocatorRef allocator,
CFStringRef originalString,
CFStringRef charactersToLeaveUnescaped,
CFStringRef legalURLCharactersToBeEscaped,
CFStringEncoding encoding
);


What makes this function useful, is the legalURLCharactersToBeEscaped parameter. This will escape legal characters such as & ? = if they are supplied. This allows you to escape parameters using the following code.

CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, (CFStringRef)parameter, NULL, CFSTR(":/?#[]@!$&’()*+,;="), kCFStringEncodingUTF8)


An example of when to use this, is Twitters Update status API. You can find that here http://apiwiki.twitter.com/Twitter-REST-API-Method%3A-statuses%C2%A0update

To update your status to the following:

This is my status

You would need to post up the following URL:

http://twitter.com/statuses/update.xml?status=This%20is%20my%20status

As this is such a common problem of mine, I have created a category on NSURL. This allows you to pass in a base URL and a parameters dictionary.

}

Using a parameters dictionary keeps the code nice and clean, but beware, to use the category method above you still have to make sure that your keys, and the base URL are correctly encoded (no spaces or invalid characters !!!!!).

As we now have a category method to do all the hard work for us, to create the Twitter URL you just need to do the following:

NSString *baseString=@"http://twitter.com/statuses/update.xml";
NSDictionary *dictionary=[NSDictionary dictionaryWithObjectsAndKeys:@"This is my status",@"status",nil];
NSURL *url=[NSURL URLWithBaseString:baseString parameters:dictionary];


And thats it. Obviously this category can be used for things other than twitter ….. if you really want to.

Although this information is very hard to find in the documentation, but is actually very easy to. The method you need to find is:


- (BOOL)applicationShouldHandleReopen:(NSApplication *)theApplication hasVisibleWindows:(BOOL)flag;


This is an optional delegate method that your AppDelegate can choose to implement, and is called when the user presses your application’s dock icon. The bool flags indicates whether the application has any visible windows. To reopen your application’s main window, you need to have a pointer to it (In the example below assume that it is defined as NSWindow *window; in the header file). If you do have a pointer to then you simple need to implement the code below.

if(flag==NO){
[window makeKeyAndOrderFront:self];
}
return YES;
}

It is as simple as that.

All animations triggered by the UIView class happen within a animation block.

To start an animation block you use the UIView Class method:

+ (void)beginAnimations:(NSString *)animationID context:(void *)context;


The animation ID is used in delegate call backs for such things as the beginning and end of animation blocks. The context is an additional piece of information that can be passed through.

As both of these parameters are optional, you comenly see:

[UIView beginAnimations:@"" context:NULL];


To commit these animations, and therefore end the animation block, you need to use the UIView class method:

+ (void)commitAnimations


So what types of animations can you do ? well quite a few.

You can animate views by:

• Changing their alpha
• Changing there size
• Changing there location

In a single animation block you can animate multiple views, and you are also able to nest animation blocks.

So lets do a common example. When a UITableViewCell is being edited you often want to make a UILabel’s (label) alpha change to 0 so it is hidden:

For those new to C programming:

(editing ? 0.0 : 1.0)


Is equivlant to:

if(editing)
{
0.0;
}else{
1.0;
}


So for the second example we also have a UILabel (label), that we want to grow when the animation code is run. We also want this animation to last 2 seconds, so the user can admire our work. In addition to this, we want the animation to “ease in”. This is known as the animation curve. The animation curves that are available are

• ease in (slow then fast)
• ease out (fast then slow)
• ease in and out (slow, fast, slow)
• linear (constant speed)

We would do this animation using the following animation block:

This is just a brief overview of the animations you can do using the UIView class, but it should be enough to get you started. The UIView methods also include delegate call backs for when an animation starts and end. For more information see Apple’s Documentation.

If the UIView class does not have what you need, you will probably need to use the Core Animation framework. While using this framework is not trivial, it is not as hard as using OpenGL (which is used commonly for 3D games), and you can build some fantastic animations using it.

To change the name of an iPhone application is very easy. Simply open the Xcode project, and then scroll down to the “Targets” section, which the the “Groups & Files” part of Xcode. Select the application’s target and “Get info” on it using cmd-i or ctrl clicking it, and select “Get Info” from the menu.

In the build section of the get info window, you need to change the “Product Name” value to whatever you want your application to be called. When you change this value make sure that the configuration pop up menu (at the top of the window) is set to “All Configurations”, so it takes effect in all of your builds.

For the change of name to take effect, simply clean your targets and rebuild your application.

NSUserDefaults are stored on the file system as .plist, which is simply an XML document. The way you access NSUserDefaults programatically is very much like accessing an NSMutableDictionary, that is by using keys.

Setting User Defaults

NSUserDefaults can be a bool, float, integer or an object. So if you wanted to set the autosave option (which is a BOOL) for your application to be YES, you would write:

[[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"AutoSave"];


Moreover if you wanted to set the person’s name to ObjColumnist you would write:

[[NSUserDefaults standardUserDefaults] setObject:@"ObjColumnist" forKey:@"PersonName"];


Reading User Defaults

Reading the user defaults is just as easy as setting them. If we wanted to retrieve the 2 values we stored above, you would simply write:

NSString *name = [ [NSUserDefaults standardUserDefaults] stringForKey:@"PersonName"];
BOOL autoSave = [ [NSUserDefaults standardUserDefaults] boolForKey:@"AutoSave"];


You should also notice that there is a convenience method for retrieving a string for a key, even though we set it as an object.

It is also important to be aware that if you attempt to retrieve a numeric value such as an integer, integerForKey: for a non existent key, you will get the value 0. This is obviously an issue if 0 would trigger a certain preference in you application.

Setting the default user defaults

So you can now set and read the user defaults, but how do you assign their default values ?

The answer is registerDefaults:

This method is usually called in the initialize (class) method of a given application’s AppController. The parameter for this method is an NSDictionary. The code below sets the default preference for the AutoSave option to YES, and the person’s name to @”unknown”.

One thing that Cocoa does for you automatically without needing any extra code, is that it only saves to the .plist the values that are different to the defaults values, that were registered using registerDefaults: . This means that if the user does not change any of their default preference settings, there will no be a preference file created.

Note: The code above just stores the preference for the AutoSave option, you still have to create the code to manage the saving of data yourself.

In software engineering, the delegation pattern is a technique where an object outwardly expresses certain behaviour but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins composition (also referred to as aggregation), mixins and aspects.

http://en.wikipedia.org/wiki/Delegation_pattern

The most common use of helper objects in iPhone development is when using UITableViews. When you instantiate a UITableViewController this class is automatically assigned to be the delegate and dataSource of the table view it holds.


self.tableView.delegate=self;
self.tableView.dataSource=self;


The UITableView then calls the appropriate delegate method when it needs information, such as:


- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath


This ask the delegate, what is the height for the row at a given index path, so in your UITableViewController (the delegate) you would write the following, if you wanted the row to be 44 pixels high (the default).


- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{

return 44;
}


Writing your own delegate.

Most delegates are declared as a protocol, so the compiler knows that the delegate implements the required methods.

Example:

You have created a subclass of UITextView (e.g. OBCTextView), that you use in your application to enter both Tweets and SMS. You want to use the same class for both, BUT tweets have a character limit of 140 and SMS have a character limit of 160 (we will pretend that we are still in the 90s).

So we need to create a delegate that asks for the character limit.

- (NSInteger) charachterLimitForTextView: (OBCTextView *)textView;


As mentioned before this should be declared as a protocol

@protocol OBCTextViewDelegate

@end


The OBCTextView would call this method like so:

In our SMS view controller we would declare that we implement the delegate protocol.

@end


And then in the implementation file you would implement the following method

This method is required for OBCTextView to work so we should also add the key word @required to the protocol


@protocol OBCTextViewDelegate

@end


Optional methods

In your delegate, you may also want to implement optional methods. So for this example we will ask for the text color. You can specify that a method is optional using @optional.

@protocol OBCTextViewDelegate

@required
- (NSInteger)charachterLimitForTextView:(OBCTextView *)textView;

@optional
- (UIColor *)textViewColorForTextView:(OBCTextView *)textView;

@end

As it is optional the delegate class (helper object), does not have to implement it. If it does not implement it, and we attempt to call it, the application will crash. So how do we know if we should call the method or not ? The answer is respondsToSelector.

respondsToSelector allows you to ask an object at run time, if it implements a given selector. So for our example:

if your class wants to return a textview color, then you simply implement the method.

So that finishes off this post on helper objects, and how you can create your own. As always this example was a simple one to make it easy to follow. You could probably implement the above using setter methods.

1. Adding a number to an array

NSArray (NSMutableArray etc) does not allow you to add primitive types to it. This is because an NSArray is simple a set of pointers to the Objects you add to it. This means if you want to add a number to the array, you first have to wrap it in a NSNumber.


NSArray *numbers=[NSArray arrayWithObject:[NSNumber numberWithInteger:2]];


2. Number type conversion

NSNumber allows you to easily convert the type of a number e.g. from an int to a float


NSNumber *number=[NSNumber numberWithInteger:2];

float floatValue = [number floatValue];


3. Perform selector calls

Once you have used Objective-C for a while you may come across performSelector. This allows you to carry out advanced techniques like performing a selector after a given delay.

[magicObject performSelector:@selector(performMagicWithNumber:) withObject:[NSNumber numberWithInteger:2] afterDelay:1.0];

This the equivilant of doing the following without a delay:

[magicObject performMagicWithNumber: [NSNumber numberWithInteger:2] ];

4. Persisting Objects (CoreData)

Archiving Objects is a lot easier than archiving primitive types, as NSNumber inherits from NSObject you can use various archiving and de-archiving methods on them. CoreData actually requires you to use NSNumber for persistent storage. One thing that may not be obvious at first glance, is that CoreData (and Objective-C) considers BOOL as a NSNumber.

Summary:

You may write the best selling application on the Appstore and never use NSNumber, but if you need to persist your objects or you need access to the various performSelector calls, NSNumber is obviously the way to go.


AudioServicesPlaySystemSound(kSystemSoundID_Vibrate);