A quick way to force the iPhone doing sound or music stuff is to use the audio system services. To use them in your xcode project simply add the AudioToolbox Framework to your application and import the header files:

 #import <AudioToolbox/AudioToolbox.h>

to load and play the sound :

NSString* path = [[NSBundle mainBundle] pathForResource:@"soundName" ofType:@"caf"];
NSURL * afUrl = [NSURL fileURLWithPath:path];
UInt32 soundID;
AudioServicesCreateSystemSoundID((CFURLRef)afUrl,&soundID);
AudioServicesPlaySystemSound (soundID);

Allthough this is good enough to make some UI beeps and blobs you probably want control on preloading files and play them synchronously to an action. On the other hand you want to keep your code as portable as possible? So this seems really like you want to know more about openAL, so lets go through a super quick introduction to it.

There are five consistently appearing terms openAL you may want to know more about :

• LISTENER
• SOURCE
• BUFFER
• DEVICE
• CONTEXT or SESSION

The LISTENER is you. Any sound the listener can ‘hear’ comes out the speakers. OpenAL allows you to specify to place the listener in relation to sources.

The SOURCE is something analogous to the speaker. It generates sound which the listener can ‘hear’. Like the listener, you can move the sources around.

The BUFFER contains the raw audio data of the sound that will be played.

The DEVICE is the actual hardware playing the sound.

The CONTEXT or SESSION is something like a room containing all the sources and the listener. Metaphorically speaking the sources are musicians the listener is a microphone and the CONTEXT is something like air the sound is going through. You will setup positions for listener and sources here and you can specify a category for them:

• kAudioSessionCategory_UserInterfaceSoundEffects:Use this category for sound effects such as touch feedback, explosions, etc.
• kAudioSessionCategory_AmbientSound : Use this category for backgound sounds such as rain, car engine noise, etc. Mixes with other music.
• kAudioSessionCategory_SoloAmbientSound : Use this category for backgound sounds. Other music will stop playing.
• kAudioSessionCategory_MediaPlayback : Use this category for music tracks.
• kAudioSessionCategory_LiveAudio : Use this category for interactive music such as playing an instrument on the screen.
• kAudioSessionCategory_RecordAudio : Use this category when recording audio.
• kAudioSessionCategory_PlayAndRecord : Use this category when recording and playing back audio.

To get this all work you need five tasks to be done:

1. get the device
2. make a context with the device
3. put some data into a buffer
4. attach the buffer to a source
5. play the source

Audioformats I successfully tested on iPhones OS 2.2.1 and above:

• .CAF (16-Bit PCM) Not Compressed
• .AIF (IMA4 16-Bit PCM) Compressed

.CAF
To convert a audiofile to this format simply open a terminal on your mac and type:

usr/bin/afconvert -f caff -d LEI16@44100 inputSoundFile.aiff outputSoundFile.caf

.AIF
To convert an audiofile to this format use export on quicktime pro.

Since this was a quick walkthrough I guess you want to hear more about this stuff and you want to see actual code. Next post will give you all this – be prepared!

In objective-c you can manually write your getter and setter methods or let the compiler do the work. An attribute with getters and / or setters is called “property”.

Manual property creation

1
2
3
4
5
6
7
8
9
10
11

/////////////////////////////////
// File : example1.h
 
@interface myClass
{
    float value;
}
-(float) value;
-(void) setValue:(float)_value;
 
@end;

1
2
3
4
5
6
7
8
9
10
11

/////////////////////////////////
// File : example1.m
 
@implementation myClass
-(float) value {
    return value;
}
-(void) setValue:(float)_value {
    value = _value;
}
@end

Half automatic property creation

If you want the compiler to add automatically the getter and setter method in your header file you can declare a property as shown below. Still you can write the content of your getter and setter manually.

1
2
3
4
5
6
7
8
9
10

/////////////////////////////////
// File : example2.h
 
@interface myClass
{
    float value;
}
@property float value;
 
@end;

1
2
3
4
5
6
7
8
9
10
11

/////////////////////////////////
// File : example2.m
 
@implementation myClass
-(float) value {
    return value;
}
-(void) setValue:(float)_value {
    value = _value;
}
@end

Full automatic property creation

If you just want a public attribute and don’ want to do some stuff when setting or getting is called you can completely automate the getter and setter – you can synthesize them. The compiler will make the smallest and fastest code to assign or retrieve the attribute. So in this example, it will just assign the value with one call and return it with one call – so at the end it shouldn’t be different to the example above.

1
2
3
4
5
6
7
8
9

/////////////////////////////////
// File : example3.h
@interface myClass
{
    float value;
}
@property float value;
 
@end;

1
2
3
4
5
6

/////////////////////////////////
// File : example3.m
 
@implementation myClass
@synthesize value;
@end

Property Declaration Attributes

There are so called declaration attributes to define how an external object accesses your property and what should happen with the retain count automatically.

Accessor Method Names

To specify an accessor name you can use :

• getter = <getterName> – property is readable through the given getterName
• setter = <setterName> – property is writeable through the giben setterName

Writeability

To specify read and/or write accessors you can use :

• readwrite (default) — property is writeable and readable
• readonly — property is readonly

Setter Semantics

These attributes specify the semantics of a set accessor

• assign (default) — Specifies that the setter uses simple assignment.
• retain — Specifies that retain should be invoked on the object upon assignment. The previous value is sent a release message. This attribute is valid only for Objective-C object types. (You cannot specify retain for Core Foundation objects)
• copy — Specifies that a copy of the object should be used for assignment. The previous value is sent a release message. The copy is made by invoking the copy method. This attribute is valid only for object types, which must implement the NSCopying protocol.

Atomicity (Multithread behaviour)

This attribute specifies that accessor methods are not atomic (Default is atomic).

• nonatomic — Specifies the accessors are not atomic

If your accessors are atomic – which is if you not specify them as nonatomic – a synthesized getter will look like :

1
2
3
4

[_internal lock]; // lock using an object-level lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;

If you specify nonatomic, then a synthesized accessor for an object property simply returns the value directly.

Interfacebuilder

If you want to specify that a property is an Interface Builder outlet, you can use IBOutlet keyword:

1

@property (nonatomic, retain) IBOutlet NSButton *myButton;

Synthesize

You can specify a variable to be used for a property:

1

@synthesize firstName, lastName, age = yearsOld;

Dynamic

You use the @dynamic keyword to tell the compiler that you will fulfill the API contract implied by a property either by providing method implementations directly or at runtime using other mechanisms such as dynamic loading of code or dynamic method resolution.

1
2
3
4
5
6
7
8
9

/////////////////////////////////
// File : dynamic_example.h
 
@interface MyClass : NSObject
{
    NSString *value;
}
@property(copy, readwrite) NSString *value;
@end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/////////////////////////////////
// File : dynamic_example.m
 
// assume using garbage collection
@implementation MyClass
@dynamic value;
 
- (NSString *)value {
    return value;
}
 
- (void)setValue:(NSString *)newValue {
    if (newValue != value) {
        value = [newValue copy];
    }
}
@end

Property access

When you access a property via synthesized dot notation or directly you have to notice the diffrence. If you access a property directly you will not use the accessor methods.

1
2
3
4
5
6
7
8
9
10
11

/////////////////////////////////
// File : accessor.h
 
@interface MyClass : NSObject {
    id value;
}
 
@property (nonatomic, retain) id value;
 
-(void) myMethod;
@end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

/////////////////////////////////
// File : accessor.m
 
#import "accessor.h"
@implementation MyClass
 
@synthesize value;
 
/* synthesize will do something like this :
-(id) value {
    return value;
}
 
-(void) setValue:(id) _value {
    [value autorelease];
    [_value retain];
    value = _value;
}
*/
 
-(void) myMethod {
    NSString * strValue = @"Hello Value";
 
    // this would call the accessor 'setValue:( id );'
    // which will cause a retain on 'strValue' and a release
    // of what ever was there before.
    self.value = strValue;
 
    // the following call will just do that value now points to 'strValue', 
    // but it does not call any accessor, so there will be no retain or release
    // message sent.
    value = strValue; 
 
    id obj = nil; // just a holder for our object
 
    // the following line will call the accessor '( id ) value;' which will in
    // - in this case - do nothing special because the accessor just
    // returns the object.
    obj = self.value; 
 
    // the following line will just do that obj has the same pointer as value
    // but will not call any accessor.
    obj = value;
}
@end

Currently we are at a top position at the “New and Noteworthy” category at the German App Store. So far we got splendid average ratings:

• Germany: 4,5
• USA: 4,0
• France: 4,5
• United Kingdom: 4,5

We want to thank all the people how played the game and shared their opinion with us. Thank you very much for the support!

For marketing and publishing we teamed up with the worlds leading mobile games developer and publisher Fishlabs Entertainment – to push our game to the next level.

Get ready for a whole new action packed arcade game: Defend the Earth against hordes of aliens and mighty boss ships. To face the large variety of hostiles, you are armed with a powerful arsenal of blast bombs, all-devouring black hole bombs and lightning bombs. Skillfully placed, their explosions combine to gigantic chain reactions blowing up everything in reach. Stunning high detail graphics, a scenic orchestral score, innovative multi-touch mechanics and heart-stopping game play deliver a whole-new spin on the space-action genre – for veterans and rookies alike. Join the location based OpenFeint leader boards and share your score via Facebook and Twitter.

Download Earth Defender now to your iPhone™ , iPod touch™ and iPad™

There are two possibillities how to handle object instances. The first way is to manually allocate and release objects. The other -more tempting- way is to let the system release it for you, but then sometimes your application will hang or temporarly stick in memory.

The creators of Objective C may thought : “Why not combine both techniques to get benefits of both of it?”. Well, sometimes I think they may have missed the goal. If you are not following strictly the rules objects are deallocated when you don’t want it, and sometimes they will be deallocated twice, which both results in an application crash. Or never the less they won’t be deallocated ever, so it results in memory leaks (which could end the application on iPhones with : result 101)

But how does an auto-release function (generally spoken)? All objects derived from a general object will have the ability to count the references. If you create an object the reference will be 1. If you assign this object to another variable the reference counter will be increased by one. If you reset this variable to any other object (also NULL, nil, or what ever) the reference counter will be decreased by one. If all references are lost (reference counter is zero) the object is not referenced anymore and will be released by the system (e.g. garbage collector).

In objective-c this is done by the NSObject class. But with a tiny but huge difference – if you assign an object to a variable the retain counter will only be increased / decreased if you use a so called retain-property. I will discuss this later.

Therefore our focus is about these methods of NSObject:

Example 1

Objects you allocate with alloc should be released with release and then grounded to nil.

1
2
3
4
5
6
7
8
9
10

- (void)myMethod
{
    MyClass * myObject;
    myObject= [MyClass alloc];
 
    // Do stuff
 
    [myObject release];
    myObject = nil;
}

If you don’t want to release your objects manually you could make the use of an autorelease pool. If you send the autorelease message to an object it will be sent and added to the autorelease pool. At the end of an event loop, this autorelease pools is released by the application object and then all of the objects contained within it are released, too. At the beginning of the next loop, a new pool is created and so on. You should keep track of your instances if you use multithreading. The default autorelease pool is linked to the main loop thread – so if you use another thread make sure you use your own autorelease pool – or even better: just dont use autorelease.

Example 2

An autoreleased Object is considered to be valid whithin the scope where it received the autorelease message.

1
2
3
4
5
6
7
8
9

- (void)myMethod
{
    MyClass * myObject;
    myObject = [MyClass alloc];
    [myObject autorelease];
 
    // myObject will be valid until
    // the very end of this method!
}

Example 3

When you have a method that creates and returns an object autorelease is quite useful to make sure that an object will be released on time.

1
2
3
4
5
6
7

- (NSString *)myFunction
{
 
    NSString *myString = [[NSString alloc] initWithString:@"Hello String."];
    [myString autorelease];  // we have to do this to prevent a memory leak
    return myString;
}

Example 4

There are so named convencience constructors which will return autoreleased objects. If you use them and you want to keep them at the end of a method block, you have to sent a retain message. So if you keept in mind to call release or autorelease for each alloc, you know have to complete the rule to : for each alloc and for each retain you have to call release or autorelease.

1
2

// if we assume that myVar exists
myVar = [[NSString stringWithCString:"Hello String."] retain];

So we can breakdown the memory management for objective-c to some rules :

Rule 1 : Retention Count

1. Within a given block, the use of -copy, -alloc and -retain should be equal the use of -release and -autorelease.
2. Objects created using convenience cunstructors (e.g. NSString’s strintWithCString) are concidered autoreleased.
3. Implement a -dealloc method to release the instance variables you own.

Example 1: alloc and release

1
2
3
4
5
6
7
8

- (void)printHello
{
	NSString *string;
	string = [[NSString alloc] initWithString:@"Hello"];
	NSLog(string);
	// we created string with alloc -- release it
	[string release];
}

Example 2: Convenience constructor

1
2
3
4
5
6
7
8

- (void) printHello
{
	NSString *string;
	string = [NSString stringWithFormat:@"Hello"];
	NSLog(string);
	// we created string with convenience constructor
	// we can assume it's autoreleased
}

Rule 2 : Always use accessor methods

If you are using retain and release on a classes instance variables throughout your code, you are almost certainly doing the wrong thing. Use conistently accessor methods of classes to decrease memory management problems.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

@interface Counter : NSObject
{
	NSNumber *count;
}
 
- (NSNumber *)count
{
	return count;
}
 
- (void)setCount:(NSNumber *)newCount
{
	[newCount retain];
	[count release];
	count = newCount;
}
 
- (void)dealloc
{
	[self setCount:nil];
	[super dealloc];
}
- (void)reset
{
//*/
//    YOU COULD DO :
	NSNumber *zero = [NSNumber numberWithInt:0];
	[self setCount:zero];
/*/
//    OR (if you have to alloc here) :
	NSNumber *zero = [[NSNumber alloc] initWithInt:0];
	[self setCount:zero];
	[zero release];
//*/
}

Rule 2 : NSArray, NSDictionary, NSSet etc.

When you add an object to a collection class the collection retains it. A release message will be sent when the collection it self gets released. To understand this, think of what would you do if you are planning a collection class. You wanted to make sure that no objects you were given to look after disappeared out from under you else where, so you send them a -retain message as they’re passed in. If they’re removed, you have to send a balancing -release message. Same when your collection will be released, any remaining objects in your collection should be sent a -release message during your own -dealloc method.

The following examples are both correct.

Example 1

1
2
3
4
5
6
7
8
9
10
11

-(void) myMethod
{
    NSMutableArray *array;
    int i;
    // ...
    for (i = 0; i < 10; i++)
    {
        NSNumber *n = [NSNumber numberWithInt: i];
        [array addObject: n];
    }
}

Example 2

1
2
3
4
5
6
7
8
9
10
11
12

-(void) myMethod
{
    NSMutableArray *array;
    int i;
    // ...
    for (i = 0; i < 10; i++)
    {
        NSNumber *n = [[NSNumber alloc] initWithInt: i];
        [array addObject: n];
        [n release];
    }
}

Release and dealloc

The release message will be sent by you or by an autorelease pool. The release method of an object decreases the reference counter by one, and if its zero calls the dealloc method.

Vicious retain circles

Guess we have an object A is retaining object B and object B is retaining object A. Now these objects never reach a zero retain count. Just in that moment the reference count gets to one, they are effectively out of the program. This is called vicious retain circles and it is possible to have very complex retain cirules like that where the minumum count is even higher than one. To avoid this you should always plan your class dependency wisely. Lets take a look on the Cocoa view hierachy. A NSView can have several subviews which have subviews and so on. On the other side a NSView has also a pointer to the superview. Why doesn’t this ends in an vicious retain circle? Well, NSViews retains their subviews but not their superview.

Nonatomic vs Atomic

If you define properties you will often see this :

@property( nonatomic, retain ) NSString * myString;

If you dont use nonatomic the default would be atomic. But what does this thing do? If you write your own accessors rather than using synthesized ones the property will do nothing. If you use synthesized properties, atomic properties are like synchronized attributes in java – they will do an object-level lock to ensure that only one thread is able to read or write this property. This doesn’t mean the whole object is thread-safe, but the property reads/writes are. Even if you still think: “Hell yeah! I want it!” you should know that this is in cost of performance – so in most cases nonatomic properties are faster.

Further Links

• Documentation on developer.apple.com : Memory Managemet

Cocoa : some may think it’s a pendant to java ( like java was coffee, so cocoa have to be something like coffee for children: cocoa) – but its not! It’s a huge coding library (API) to code your mac applictions. Cocoa classes are starting with “NS”-Tag, like NSString, or NSObject.

Objective C : Objective C, or short ObjC is a programming language extended from standard C. So all standard C code is leagal Objective C code. If you already read something about objective C you probably ask your self what the heck is that thing about these brackets “[ ]” ? Here is a simple code snippet which we will discuss later:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

///////////////////////////////////////////
// FILE : classA.h
// Header File for classA
///////////////////////////////////////////
#import <uikit /UIKit.h>
 
@interface classA : NSObject {
 bool myBoolean;
 int myNumber;
 int myIdentifier;
 NSString * name;
}
 
// manual creating getters and setters for a property
-(int) myNumber;
-(void) setMyNumber:(int)value;
 
// automatic creating getters and setters for a property
@property bool myBoolean;
@property (readonly) int myIdentifier;
@property (assign) NSString * name;
 
// methods and functions
-(void) doStuffWithA:(bool)a B:(int)b C:(NSString *)c;
 
@end
 
///////////////////////////////////////////
// FILE : classA.m
// Implementation File for classA
///////////////////////////////////////////
@implementation classA
 
// automatic generation of getters and setters for properties:
@synthesize myBoolean;
@synthesize myIdentifier;
@synthesize name;
 
// manual getter and setter methods:
-(void) setMyNumber:(int)value {
 myNumber = value;
}
 
-(int) myNumber {
 return myNumber;
 // this is ok. It will return the value. To call the function in ObjC
 // you have to write something like:"return [self myNumber];"
}
 
-(void) doStuffWithA:(bool)a B:(int)b C:(NSString *)c {
 myBoolean = a;
 myNumber = b;
 myName = c;
 myIdentifier = b; // ok, internal writeable - only external readonly
 // not allowed:  self.myNumber = b;
 // dot notations are only allowed for automatic generated properties.
}
 
@end
 
///////////////////////////////////////////
// FILE main.m
// Main Application File
///////////////////////////////////////////
#import </uikit><uikit /UIKit.h>
#import "classA.h"
 
int main(int argc, char *argv[]) {
  classA * myObject = [[classA alloc]init];
  [myObject setMyNumber:1]; // ok
  int a = [myObject myNumber]; // ok
  // myObject.setNumber(1); // not allowed.
  // int a = myObject.myNumber; // only on automatic generated properties.
  [myObject setMyBoolean:true]; // ok
  myObject.myBoolean = true; // ok
  bool b = [myObject myBoolean]; // ok
  b = myObject.myBoolean; // ok
  // [myObject setMyIdentifier:1]; // not allowed : readonly
  // myObject.myIdentifier = 1; // not allowed : readonly
  int i = [myObject myIdentifier]; // ok
  i = myObject.myIdentifier; // ok
  [myObject doStuffWithA:true B:42 C:@"Text"];  
 
 return retVal;
}
</uikit>

Some words about this “[ ]” – stuff. First of all, in Objective C you do not call a member function of an object directly (like “object.methodName(value1, value2)”. You retain a controller to sent a message to the object by using these brackets ( [object methodName:value1 param2Name: value2] ).

The basic form is [object param1Name:value1 param2Name:value2 param3Name:value3] where param1Name is the method name itself. That’s why we called our “doStuff” method in classA : “doStuffWithA”. When you call that method it would be read like [doStuffWithA:true B:42 C:@"String"].

Now some may think that Objective C is a bit ugly. You are right – it’s ugly. But never the less it is a powerful tool, so it’s worth to get through it.