• Part 1: Imports, strings and function calls
• Part 2: Header files, variable and function definitions

In this part 2 of Objective-C for Flash developers, we will look at header files and how variables are defined in comparison to ActionScript 3. Before we start, I need to clarify one thing: I will consistently use the term function throughout this tutorial, although technically there is a semantic difference between funcitons and methods. It’s just to make this all easier on the brain, that’s all.

Header files (i.e. MyClass.h)

Any and all Objective-C classes are split into a .h file and a .m file. The former being the header file, the latter the implementation.

This is a concept that has no counterpart in AS3 so a direct comparison won’t be possible. What a header file does is list the definition of your class. In one way you could say that it’s a bit like the part you put before the constructor in you AS3 classes, in another you could say it’s like and AS3 interface. Both are correct to some extent, however neither would be accurate.

If you cmd+click the name of a framework class in the Xcode source editor, you will get to the class header file. In a way this is the Black Box Principle in practice; you get to see what the class exposes as it’s interface, but not how it does it’s grunt work. That is reserved for the implementation file. The one exeption to this is that a header file also defines any private properties of a class, so these are also exposed.

An Obj-C header file defines what instance variables, properties og functions a class has, which class it inherits from and the interfaces it adheres to. It is declared with the @interface keyword:

@interface MyClass : MySuperClass

@interface keyword, followed by class name, a colon and the super class name. For the most bare-bones objects, you extend NSObject.

You see, this might be the reason you would think a header file is like an AS3 interface, and it sort of is. But don’t put that one in the bank and move on just yet because you need to be aware that Objective-C has something called “protocols” which is semantically more similar to AS3 interfaces. We will deal with protocols in a later part, but for now here’s an illustration to help you map you understanding of these concepts to AS3:

In general you could say that the Objective-C header file is a combination of the AS3 class header and the AS3 interface, while the AS3 interface is a combination of the Objective-C header file and Objective-C protocols.

A complete abstract header file:

#import "SomeClass.h"
@class SomeOtherClass;
@interface MyClass : MySuperClass {
 DataType *myProtectedVariable;
}
 
@property (strong, nonatomic) DataType *propertyName;
-(void)doSomething;
@end

Now what’s all this? First of all, if you read part 1, you know that the #import keyword is just like imports in AS3. But here you see yet another kind of import:

@class imports

@class DetailViewController;

Quite simply, importing with @class does no more than tell the compiler that the class exists. This is called a forward declaration. The compiler will defer validation of the existance of the class to compile time. If your implementation uses properties or functions of this class, you will need to #import the class instead.

A way to remember which is which is to compare #import to ActionScript’s #include directive since that also uses the # sign and it inlines the code of the class. Another way is to notice that the @class keyword does not use a file extension (MyClass, not MyClass.h). This gives you an indication that @class is a general declaration, not an import.

Instance variables (ivars)

These are defined in what actually looks like a constructor, but this being a header file it’s not. (Actually, Obj-C doesn’t have explicit constructors, more on this in a later part).

protected var myProtectedVariable:DataType;

@interface MyClass : MySuperClass {
 DataType *myProtectedVariable;
}

Defining variables like this makes them local to the instance of the class. By default these variables are protected, making them accessible to the class and any subclasses, but not from the outside. Ivars can also be specified as private or public, though this is rare and highly discouraged.

Properties

// In an interface
function get propertyName():DataType
function set propertyName(value:DataType):void

@property (strong, nonatomic, readwrite) DataType *propertyName;

From left to right: @property keyword, property modifiers in parethesis (see below), the data type, which by C convention is always listed before the property/variable name, and lastly the propertyName, with or without the asterisk (see below).

A property is an externally accessible variable. It is not a public property and in the context of the header file it is merely a declaration stating to other classes that this is a property you can access. You will have to provide getter/setter implementations in the .m file to support this declaration. Think of it as declaring getter and setter functions in an AS3 interface.

Pointers

@property (strong, nonatomic, readwrite) DataType *propertyName;

You might have noticed that asterisk preceeding the property name. This declares that this variable is a pointer. A pointer is a reference to the memory space that an object occupies. By storing pointers to objects you don’t maintain copies of them throughout your application but rather references to the same instance.

Pointers do not have direct AS3 counterparts because AS3 is a higher level language that does not provide this level of memory management. In AS3 some datatypes are implicitly passed by reference/pointers (such as arrays) and others are passed by value, like strings. On a side note, in Objective-C strings are instances of NSString and as such they too are passed as pointers.

In Objective-C that asterisk is present whenever a pointer is declared, be it in a property, private variable or local variable. It is important to remember that function arguments are also declarations of local variables, hence you must include the asterisk there as well if the value you expect should be a pointer/reference.

Property modifiers

To assist in memory management, thread safety and access control, Objective-C has a number of possible modifiers you can specify in the property declaration. These are the words in parethesis following the @property keyword as seen in the example above:

@property (strong, nonatomic, readwrite) DataType *propertyName;

Regarding the memory modifiers, you should be aware that iOS 5 introduced automatic reference counting (ARC) which simplifies memory management and thus changed the list of possible modifiers. iOS Memory management and thread safety is beyond the scope of this post series. See Apple iOS Center documentation for these.

The access modifiers do have AS3 equivalents: Specifying readwrite is the same as implementing a getter and a setter, while readonly is the same as only implementing a getter.

Property modifiers can appear in any order. The default property modifiers are weak, atomic, readwrite and need not be specified.

Functions

In the example above you saw a function signature at its simplest:

public function doSomething():void

-(void)doSomething;

These are more appropriately called methods because they are exposed and as such part of the class interface. The minus sign denotes an instance method, as opposed to a static method which is prefixed by a + sign:

public static function doSomething():void

+(void) doSomething;

With arguments, functions look like this:

public function doSomething(soleArgument:DataType):void

-(void)doSomething: (DataType *) soleArgument;

That’s all nice and well. The asterisk pointer indicater is placed inside the data type declaration parenthesis. If this was a primitive value, like an integer, the asterisk would be omitted. Look at what happens when you include multiple arguments. In this case I wrote the example a little less abstract to better convey why this is:

public function doSomethingWith(myArgument:DataType, numRepetitions:int):void

-(void) doSomethingWithMyObject: (DataType *) theObject forThisManyTimes:(int) numRepetitions;

Whoah! That’s definitely not like ActionScript. Essentially you should read that signature like “do something with my object for this many times”. The function name and the first argument are together seen as the complete function name, whereas additional arguments add to it like a sentence. It sort of looks like you define the name of the second argument twice (and any additional arguments after that), but it’s actually not that weird. The name before the data type parethesis is the externally visible argument name (i.e. the name that pops up in the content assist), while the name after the parenthesis is the definition of the local variable exposed inside the function’s implementation.

What about return types? That’s easy:

public function getSomething():DataType

-(DataType) getSomething;

I’ll leave you with that for now

• Part 1: Imports, strings and function calls
• Part 2: Header files, variable and function definitions

This will be a multipart blog post covering how to understand Objective-C in the ActionScript frame of reference. In this first part we will deal with imports, function calls and strings. I give you the AS3 to Obj-C transition guide, part 1.

Introduction

Coming from an AS2/AS3 background, I found that many of my conceptions of design patterns, event models and general application structure didn’t apply very well when starting out with Cocoa Touch and Objective-C. In fact I expected that because my choice to learn Objective-C in particular was with the intent of doing something very different from what I’m used to. I wanted to rip myself completely out of my comfort zone in an attemp to lower my natural resistance to anything new. I got what I bargained for, in spades.

Imports

I’ll start litterally at the top: Imports in AS3 and Objective-C are quite similar:

import somepackage.Class;

#import <Foundation/Foundation.h>
#import "Class.h"

The UIKit is another Obj-C framework which, as you probably guessed by the UI prefix, is comprised of GUI-classes. It’s closest equivalent in AS3 would be the flash.display.* package. Being GUI-classes you import them like so:

#import "UIKit/UIKit.h"

Function/Method calls

This is the one thing that does the most in making Obj-C alien-looking to devs with an ECMAScript background. In Objective-C calling functions is not even called calling functions, but rather “passing messages”…that’s right: “passing messages”… I’ll let that sink in for a while because you’re gonna need it when you read forum threads and tutorials…”passing messages”.

So how do you pass a message?

myObject.myFunction();

[myObject myFunction];

Function calls with arguments

myObject.myFunction(soleArgument);

[myObject myFunction:soleArgument];

myObject.myFunction(firstArgument, secondArgument);

[myObject myFunction:firstArgument theSecondArgument:secondArgument];

This is one of the things Obj-C does to make itself more understandable, but it is also one of the things that make it seem like you need to be a fast typer in order to be productive in Objective-C. It gets clearer when you see it in the context of an actual example, here is how to initialize a standard iOS alert:

[myAlertInstance initWithTitle:@"My Alert" message:@"My message"
	delegate:self cancelButtonTitle:@"OK"];

There’s no denying that this does make it easier to understand what the arguments are, but you will notice a somewhat odd tingle in the back of your spine the first few times you type it. Just remember: First argument has no label (usually the label is the last word in the camelcased function name), the others are of the form label:value with spaces in between them. Don’t worry. XCode’s code completion feature is really, really good and you don’t have to remember the labels for each function you use.

A word of caution: You might think that since the arguments are labeled that their order is optional, but this is not the case. However you will rarely be tempted to pass arguments in a different order than the function signature.

Function signatures are a page of it’s own, so we’ll deal with that next time. For now here is the lowdown on that “@” sign as promised.

Strings

foo = "bar";

foo = @"bar";

Next time we will deal with function signatures.

Trivia

1. In C, a string is actually an array of characters, so you can probably imagine why NSString is preferable in a higher level language.
2. An image in Objective-C is an instance of the UIImage class and the prefix “UI” naturally makes you think that it has to do with the user interface. You might even have assumed that it’s there because UIImage is part of UIKit (and you’d be right!). That’s all nice an logical, but what about the “NS” prefix, like in NSString and NSArray? This is derived from the fact that the first versions of OSX was actually called NeXTStep, made by the company NeXT, founded by Steve Jobs in the years he was outed from Apple.

Data binding is essentially tha synchonization of values, typically between the model and the views (read more here. For Flex applications data binding is typically accomplished with the [Bindable] compiler meta tag. For pure AS3 applications it’s been a roll-your-own world and some even use [Bindable] here as well. This is just wrong.

These are the reasons why BindMax is better than [Bindable]:

• Mobile loving
  Building mobile apps with AIR? Then you know it’s all about squeezing file size out and performace in. BindMax is an implementation of the observer pattern, which is a much simpler structure than the Flash Event bus. In fact it’s beautiful minimalism compared the Events. Smaller file size, better performance.
• Speed!
  For primitive data types BindMax is generally 3x faster than [Bindable]. Performance with complex data types obviously depends on how fast your compare functions are, if you have any. Without them, complex data types propagate just as fast as the primitve ones. The speed tests are included with the source so check for yourself!
• Early type checking
  A data binding is usually defined early in the application run cycle. When that happens, BindMax will evaluate each attempt to bind a property or setter against the data type of the binding and throw an error if the data types don’t match. With [Bindable], you get no errors until the target property/setter for that binding is used. For a property that is used only rarely, you may never even see that error until the client/user stumbles over that rare use case and tells you.
• Boot time property/getter/setter name validation on both sides of data binding
  Just as with type checking, BindMax validates that that the names match between the property or setter you bind a property or getter to.
• Easy custom compare functions for complex and custom data types
  Primitive data type values like numbers and strings are easy to compare. Complex data types like arrays, dictionaries and custom objects require special handling. For this scenario, BindMax provides setCompareFunction which lets you pass it a function reference to a custom function that takes two instances of the same class and returns true if they are equal.
• Optional automatic binding disposal
  To play nice with the garbage collector, BindMax lets you turn on automatic disposal of bindings which are no longer in use. When the last target for a binding is removed, BindMax will dispose of it.
• Previous value retrieval
  BindMax stores the last value of each binding so you can retrieve it with retrieveLast if for comparison with the new value. The typical use case for this functionality is an animated image gallery where animation direction is determined based on image index vs previous image index. I’m sure you can think of several others.
• Powerful reset function
  With the reset function, you can reset any or all of the bound properties to their default values (value of the property when the binding was defined). A quick call to reset followed by propagateAll will effectively reset you application.
• Propagation forcing
  There are times when checking if a value is in fact changed simply doesn’t make sense. Then you wanna be sure that a value spreads to you application each time it is set, even if hasn’t changed. BindMax lets you override change detection on a per-update or per-property basis.

So go get it! At Google Code

NOTE: From now on I will be talking mostly about BindMax instead of it’s little brother BindLite. I’m leaving BindLite in the source in case someone finds it useful, but BindMax is much more verastile by not being an all static access class.

I’ve also updated the BindMax tutorial

The updates I made were the following:

• Added reset all functionality when calling reset without arguments
• Added setForcedPropagation function
• Added propagateAll function
• Removed outdated example project

I needed to draw a dashed line in AS3. I thought it would be easy, but I thought “hey, that one’s already been covered”, expecting that if I could find some ready-made class or lib that would do the job, I might even get some extra benefits. I went on this great interweb page called Google and I searched for “Dashed Line AS3″.

I was disappointed at all the feeble attempts at doing something so simple, so after a couple of attempts i did it myself. I even threw in the added benefit of making it able to draw itself between two points you supply it. I was expecting something extra so I imagine you did too.

Here ya’ go:

DashedLine.as

PS: Damn, that drop shadow Mac OS X includes in window screenshots is really something.

If you’re like me in that you exercise and you track your workouts with a Garmin device, there’s a chance that you’ve experienced the situation where the sync will hang about halfway through.

Why?

What seems to happen is that the Garmin Communicator plug-in is able to read the TCX-files off the device and onto disk (that’s the first 50% of the process), but crashes when it tries to upload the files to Gamin Connect, Dailymile, Runkeeper, Endomondo or any other site that uses the plug-in for sync with Garmin devices. There’s actually one progress bar for each of these steps on Garmin Connect, so the above image would not be completely accurate, the first bar would reach 100% and then it hangs.

One solution..if you can call it that

My previous solution would be to force quit the plug-in in Activity Monitor and try again until it finally worked (often as many as 6-8 attempts). I sync my runs to each of the four afformented websites (if only my friends could agree on the same site), so you can quickly see that this process becomes tedious.

Better solution: Clear the cache

What seems to be the problem is that the last TCX file that was synced is still in the browser cache and is somehow able to confuse to plug-in, because the solution to the problem is rather simple; clear your browser’s cache between each sync. This has proven to be a stable workaround for me for a while.

A note on Garmin Support

I’ve tried contacting Garmin Support several times about this, but no replies yet. The problem is even mentioned several places on the Garmin Support forums, but I doubt Garmin moderates or even monitors their own forum. An official response has yet to be made at least. I have a love-hate realationship with Garmin because I think they make hands down the best GPS HR monitors (with some exceptions), but at the same time their support is appalling and sadly I’m far from the only one who thinks so.

Well not exactly bigger in terms of file size, but since BindLite was taken it had to be BindMax for its brother. BindLite was released earlier this year as a flex-less, event-less alternative to data binding in AS3. But whereas BindLite is a static class suitable for smaller projects, I quickly realized that to make it more usable, it could no longer be all static. Enter BindMax.

BindMax does exactly the same as BindLite does but with the added flexibility of being an instance. The recommended approach is to extend it for your Model class. Example:

public class MyModel extends BindMax {
	public var state:String = State.INPUT;
	public var captureDelay:uint = 0;
	public var capturePhase:String;
	public var currentSwf:SwfVO;
	public var error:ErrorVO;
	public var render:BitmapData;
}

After this, all is the same as with BindLite with the exception that you need access to the MyModel instance. I recommend providing this acces through a dependency injection-driven framework such as RobotLegs.

Examples of use:

// Binding a property to a public property or setter on view
model.bind( "state", view );
 
// Property name needs to be passed as string, so using enums is recommended
model.bind( Bindable.STATE, view );
 
// Changing a property and propagate the change if value is different
model.update( Bindable.STATE, "main" );
 
// Changing a model property and force propagation
model.update( Bindable.STATE, "main", true );
 
// Resetting model properties to their values at define time
model.reset( Bindable.STATE, Bindable.FILE );
 
// Removing a data binding. Omit the second argument to unbind target from all data bindings
model.unbind( view, Bindable.STATE );
 
// Retrieve the before-change value of a bindable property
model.retrieveLast( Bindable.STATE );
 
// Control what happens when last target unbinds from a property
// true : Discard orphaned bindings
// false : retain orphaned bindins (default)
model.autoDisposeBindings = true;

Download BindLIte and BindMax as a combined package here: http://code.google.com/p/bindlite/

Docs are here: http://www.oyvindnordhagen.com/bindlite/docs/

Just as part of a fun little side project, I made this class to generate random circular Tron-like patterns. I thought I’d post it here in case anyone else likes the look of what it does. I’ve included an option to save the image in 2880×2880 pixels.

Se the Tron pattern generator here: www.oyvindnordhagen.com/tron/

So these days I’m experimenting with AIR P2P apps through the recently introduced ServerSocket class (which I think is still in beta by the way). Since the AIR API does not provide any network client/server/peer discovery tools, I decided to hack down a simple IP scanner to do the trick.

This package consists of two classes; IPScanner and IPScannerEvent. IPScanner will accept a starting IP and it will scan the rest of the range from that IP. In other words, if you pass in 192.168.1.100, it will try to “ping” each possible address from 192.168.1.100 to 192.168.1.255. Pass in 192.168.0, and it will go on all the way from 192.168.0.0 to 192.168.255.255, but it is limited to those last two segments.

An optional handshake string can also provided. In which case IPScanner will attempt to send this handshake string to each IP it is able to connect to and wait for a reply. This enables you to make sure you’re connecting to the right peer.

I find this works really well for me, so I thougt maybe someone else might need it too. Feel free to leave comments!

IPScanner.zip

Really awesome generative art from flashandmath http://tpt.to/agn5D8

Around 8 months ago, I released LazyFallback, the batch jpg fallback generator for flash. That version was hacked together over just a few hours on the train to and from work and had a few obvious limitations. Especially when it came to movies with scripted animation.

This time, I’ve done it right (I think). Funnily enough, during the time I was working on improving LazyFallback, I talked to @paulholliday who by sheer coincidence was working on the exact same thing, and he kindly let me have the source for his own app, FallbackCreator. Inspired by his solution, I changed the solution for loading the swfs altogether from using a Loader to using AIR’s HTMLLoader to enable AVM1 movies to play as naturally as possible.

Other improvements:

• Much better memory handling
• AutoUpdate
• Graceful error handling
• Slightly more polished UI
• New icons

Also, this has been a trial project for Robotlegs on my part, which I really like. But personally, I’m not too font of Flex data binding, so I combined it withBindLite (or more specifically a new version called BindMax, which I might publish later).

A word of caution

Your swfs should not contain playing MovieClips or ActionScript on the first frame. This is a good practice in genereal when it comes to banners ads either way, but for LazyFallback to be able to reliably control the capture delay, nothing should happen before frame 2.

So why wait—go get LazyFallback now!