Tiefe Kopien (Deep-Copies) erfordern hingegen etwas mehr als das Zuordnen einzelner Referenzen. Prinzipiell muss durch alle Properties der Instanz traversiert werden und jedes Unterobjekt und dessen Unterobjekte dementsprechend auch kopiert werden. Eine einfache Methode dieses zu erreichen kann in Cocoa über den Weg der Archivierung mit Hilfe des NSKeyedArchiver gehen (siehe auch meinen vorherigen Artikel). Eine konkrete Implementierung innerhalb einer Klasse könnte so aussehen:

@interface Entry : NSObject <NSCoding>
{
        NSString *text;
	NSString *headline;
}

@property (nonatomic, retain)NSString *text;
@property (nonatomic, retain)NSString *headline;

-(id)deepCopy;

@end

///////////////////////////////////////////////////////////////////////////////////////////////////

@implementation Entry

@synthesize text, headline;

-(id)initWithCoder: (NSCoder *)coder
{
	if(self = [super init])
	{
		self.text = [coder decodeObjectForKey: @"text"];
		self.headline = [coder decodeObjectForKey: @"headline"];
	}

	return self;
}

-(void)encodeWithCoder: (NSCoder *)encoder
{
    [encoder encodeObject: self.text forKey: @"text"];
    [encoder encodeObject: self.headline forKey: @"headline"];
}

-(id)deepCopy
{
    return [NSKeyedUnarchiver unarchiveObjectWithData: [NSKeyedArchiver archivedDataWithRootObject: self]];
}

-(void)dealloc
{
    [text release];
    [headline release];
    [super dealloc];
}

@end

Zu beachten ist natürlich dass jedes Objekt und alle Unterobjekte dem NSCoding-Protokoll folgen müssen.

@interface Entry : NSObject <NSCoding>
{
        NSString *text;
	NSString *headline;
}

@property (nonatomic, retain)NSString *text;
@property (nonatomic, retain)NSString *headline;

@end

///////////////////////////////////////////////////////////////////////////////////////////////////

@implementation Entry

@synthesize text, headline;

-(id)initWithCoder: (NSCoder *)coder
{
	if(self = [super init])
	{
		self.text = [coder decodeObjectForKey: @"text"];
		self.headline = [coder decodeObjectForKey: @"headline"];
	}

	return self;
}

-(void)encodeWithCoder: (NSCoder *)encoder
{
    [encoder encodeObject: self.text forKey: @"text"];
    [encoder encodeObject: self.headline forKey: @"headline"];
}

-(void)dealloc
{
    [text release];
    [headline release];
    [super dealloc];
}

@end

Eine Klasse die nun mehrere Entries archivieren und wieder extrahieren möchte, könnte das mit folgenden Methoden tun:

[...]
-(void)archiveEntries: (NSArray *)entries withPath: (NSString *)path
{
        NSMutableDictionary *rootObject = [NSDictionary dictionaryWithObject: entries forKey: @"entries"];
	[NSKeyedArchiver archiveRootObject: rootObject toFile: path];
}

-(NSArray *)unarchiveEntriesOnPath: (NSString *)path
{
        NSDictionary *rootObject = [NSKeyedUnarchiver unarchiveObjectWithFile: path];
        return [rootObject valueForKey: @"entries"];
}
[...]

Die Daten werden in unserem Beispiel in eine plist-Datei gespeichert, dessen Pfad natürlich frei gewählt werden kann. Natürlich hat man die Möglichkeit die Daten auch mit NSData zu schreiben. Ich empfehle einfach mal die Apple Dokumentation zum Thema NSKeyedArchiver durchzugehen.

Link zur Apple Dokumentation.

Der Fokus des tinyBlogs liegt vorallem im Arbeiten mit ActionController Instanzen, welche gute Erweiterungsmöglichkeiten bieten. Die Datenbank-Schnittstelle wird aktuell in MySQL bereitgestellt, kann aber leicht erweitert werden indem man einen eigenen konkreten DatabaseConnector schreibt.

Link zum tinyBlog.

Die Property modalPresentationStyle legt fest in welcher Größe der neue ViewController seine Ansicht darstellt. Die Enum UIModalPresentationStyle hat vier unterschiedliche Werte:

• UIModalPresentationFullScreen – Es wird in einer Vollbildansicht präsentiert.
• UIModalPresentationPageSheet – Legt die Größe auf die der Portraitansicht fest.
• UIModalPresentationFormSheet – Die neue Ansicht wird in einem Fenster angezeigt.
• UIModalPresentationCurrentContext – Nutzt den Style des Parents.

Man ist somit nicht immer auf die Vollbildansicht angewiesen. Das ist recht praktisch wenn man mal eben ein modales Fenster einblenden will um z.B. einen neuen Datensatz mit wenigen Feldern zu erstellen.

Darüber hinaus kann man die modalen Ansichten neuerdings auch mit Hilfe verschiedener Animationen einblenden. Bekannt ist der Weg die Ansicht von unten nach oben einfahren zu lassen. Das Ganze ist mit dem UIModalTransitionStyleCoverVertical der standard Übergang. Dazu hat Apple den horizontalen Flip (UIModalTransitionStyleFlipHorizontal), den Crossfade (UIModalTransitionStyleCrossDissolve) und den sogennanten “Partial Curl” (UIModalTransitionStylePartialCurl), sprich das Umblättern, ins Framework übernommen.

Beide Neuerungen sind in einem ViewController gewohnt leicht einzubinden:

MyViewController *viewController = [[MyViewController alloc] init];
viewController.modalPresentationStyle = UIModalPresentationFormSheet;
viewController.modalTransitionStyle = UIModalTransitionStyleCoverVertical;
[self presentModalViewController: viewController animated: YES];

Link zu dem offiziellen SDK 3.2 Changelog.

Adobe hat für diesen Fall vorgesorgt und stellt dem Entwickler die Klasse EncryptedLocalStore zur Verfügung. Hiermit kann man jederzeit auf einen der Anwendung eindeutig zugeordneten verschlüsselten Speicher zugreifen. AIR verwendet in diesem Fall DPAPI respektive den Keychain auf dem Mac und speichert Daten mit AES-CBC-128Bit Verschlüsselung.

Das schöne an dieser Speicherart ist aber, dass man “schnell mal eben” Zugriff auf Daten bekommt und genauso schnell neue Daten schreiben kann.
Folgendes Beispiel schreibt einen String “value” mit dem Namen “key” in den Speicher:

var stringByteArray:ByteArray = new ByteArray();
stringByteArray.writeUTFBytes("value");
EncryptedLocalStore.setItem("key", stringByteArray);

Die zu schreibenden Daten sind vom Typ ByteArray, sprich man kann im Prinzip jede Art von Daten dort Speichern. Wichtig ist hier dass der Speicher im besten Fall 10MB nicht übersteigt.

EncryptedLocalStore muss also weder initialisiert noch eingestellt werden. Jede AIR-Anwendung verfügt automatisch über eine solche Speichermöglichkeit.
Um die Daten z.B. in der nächsten Sitzung wiederherzustellen bedienen wir uns einfach der statischen Methode getItem(name:String):

var stringByteArray:ByteArray = EncryptedLocalStore.getItem("key");
var value:String = stringByteArray.readUTFBytes(stringByteArray.length);

Link zu EncryptedLocalStore.

Die Autorisierung innerhalb der RTM-API ist anfänglich etwas verwirrend. Ähnlich wie es bei Flickr gehandhabt wird, ist auch RTM abhängig von einem Token. Eventuell werde ich im nächsten Artikel etwas genauer auf das Login bzw. die Autorisierung eingehen. Weitere Informationen dazu gibt es allerdings auch auf der offiziellen API Dokumentation.

Link zu Milky.
Link zur Remember the Milk API.

Ich schätze die gesamte Lage etwas verhaltener ein. Zum einen erkenne  ich noch nicht wie sich Flash CS5 dazu eignet wirkliche Anwendungen mit mobilem Interface zu dispatchen. Hier fehlt es schlichtweg an passenden (nativen) Komponenten. Zum anderen bin ich mir unsicher ob Performance und Qualität solcher Anwendungen für den erwarteten Erfolg ausreichen. Bisher hörte ich nur, dass aus CS5 veröffentlichte iPhone Apps verhältnismäßig größer sind als die native Konkurrenz.

Persönlich bin ich vielmehr gespannt auf das mobile Flex-Framework mit dem Codenamen “Slider”. Dieses soll das dispatchen einer Anwendung auf die gängigen mobilen Plattformen erlauben. Es bietet neben einer leichtgewichtigen Struktur auch UI-Komponenten die für die mobile Plattform entwickelt werden. Das ganze soll, so wird gemunkelt, im Laufe des Jahres benutzbar sein.

Ich möchte an dieser Stelle auch noch auf einen Artikel von Florian Plag aufmerksam machen. Dieser listet die teilweise bereits erhältlichen Flash und nicht-Flash Alternativen zur iPhone-Entwicklung auf. Ich würde allerdings jedem ans Herz legen sich eventuell ein gutes Objective-C Buch zu schnappen, bevor man sich auf Scriptsprachen wie z.B. Lua fixiert. Was ich bisher gesehen habe, kann Objektive-C in vielen Bereichen eine durchaus elegante Sprache sein.

Link zu Flex-”Slider”.

Eine gute Methode um dieses Verhalten auszuhebeln, ist es, die Javascript Schnittstelle des Browsers anzusprechen und dementsprechend ein neues Fenster zu generieren. In diesem Zusammenhang kann ich auf eine tolle und kompakte Klasse verweisen, die genau das tut:

URLNavigator.as:

package com.zorked {
	import flash.external.ExternalInterface;
	import flash.net.*;

	public class URLNavigator {

		/**
		 * Utility function to wrap up changing pages. Avoids over-aggressive popup blockers.
		 * @param url		The URL to change to. Either a String or a URLRequest
		 * @param window	The target browser window/tab, generally _self, _top, or _blank
		 * @usage URLNavigator.ChangePage("http://www.google.com", "_blank");
		 */
		public static function ChangePage(url:*, window:String = "_self"):void {
			var req:URLRequest = url is String ? new URLRequest(url) : url;
			if (!ExternalInterface.available) {
				navigateToURL(req, window);
			} else {
				var strUserAgent:String = String(ExternalInterface.call("function() {return navigator.userAgent;}")).toLowerCase();
				if (strUserAgent.indexOf("firefox") != -1 || (strUserAgent.indexOf("msie") != -1 && uint(strUserAgent.substr(strUserAgent.indexOf("msie") + 5, 3)) >= 7)) {
					ExternalInterface.call("window.open", req.url, window);
				} else {
					navigateToURL(req, window);
				}
			}
		}

	}
}

Was wird hier gemacht? Nun im Prinzip macht die Klasse einen Check ob es sich um gewisse Browser-Versionen handelt und führt dementsprechend einen normalen navigateToURL-Request aus, oder er ruft die Javascript Methode window.open() auf. Man ist im Grunde auf der sicheren Seite und gegen die Popup-Blocker Schikane einiger Browser gut gerüstet.

Link zum Artikel

In der überarbeiteten Version unserer Anwendung geht es nun darum, dass es die Möglichkeit gibt den Kreis nicht nur in x- und y-Richtung zu bewegen, sondern auch dessen Alpha-Wert anzupassen.

(Rechtsklick-View Source um Quellcode einzusehen)

In diesem Beispiel brauchen wir also neben dem MoveCommand noch einen zweiten Befehlstypen, welcher in der Lage ist den Alpha-Wert eines entsprechenden Sprites zu verändern und wieder rückgängig zu machen. Er muss also das ICommand-Interface implementieren.

AlphaCommand.as:

package com.boxedfolder.examples.undo
{
	import flash.display.Sprite;

	public class AlphaCommand implements ICommand
	{
		private var _sprite:Sprite;

		private var _alpha:Number;

		private var _targetAlpha:Number;

		public function AlphaCommand(sprite:Sprite, targetAlpha:Number)
		{
			_targetAlpha = targetAlpha;
			_alpha = sprite.alpha;
			_sprite = sprite;
		}

		public function execute():void
		{
			_sprite.alpha = _targetAlpha;
		}

		public function undo():void
		{
			_sprite.alpha = _alpha;
		}
	}
}

Um eine Struktur zu erhalten, die es uns ermöglicht viele kleinere Commands sequentiell abzuarbeiten, bedienen wir uns des Composite-Patterns. Wir erstellen uns dazu einen MacroCommand, welcher potentiell beliebig viele Unterbefehle einschließen kann.

MacroCommand.as:

package com.boxedfolder.examples.undo
{
	public class MacroCommand implements ICommand
	{
		private var commandStack:Array = [];

		public function execute():void
		{
			var command:ICommand;

			for(var i:int = 0; i < commandStack.length; ++i)
			{
				command = commandStack[i] as ICommand;
				command.execute();
			}
		}

		public function undo():void
		{
			var command:ICommand;

			while(commandStack.length > 0)
			{
				command = commandStack.pop() as ICommand;
				command.undo();
			}
		}

		public function addSubCommand(command:ICommand):void
		{
			commandStack.push(command);
		}
	}
}

Da die Klasse MacroCommand das Interface ICommand implementiert ist eine Instanz in der Lage wie ein regulärer Befehl aufgerufen zu werden. Anstatt allerdings selber Funktionalität zu implementieren, wird durch die Unterbefehle iteriert und deren execute()- bzw. undo()-Methode ausgeführt. Zusätzliche Subcommands lassen sich via der Methode addSubCommand() hinzufügen.

Um jetzt diese Befehlskette in unsere Anwendung zu integrieren, müssen wir den MacroCommand instantiieren, Subcommands hinzufügen und dessen execute()-Methode aufrufen.

UndoExample.as:

package
{
	import com.boxedfolder.examples.undo.AlphaCommand;
	import com.boxedfolder.examples.undo.ICommand;
	import com.boxedfolder.examples.undo.MacroCommand;
	import com.boxedfolder.examples.undo.MoveCommand;

	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.text.TextField;
	import flash.text.TextFieldType;

	[SWF(height="550", width="550", backgroundColor="#ffffff", frameRate="50")]

	public class UndoExample extends Sprite
	{
		//... verkürzt

		private var commandStack:Array = [];

		public function UndoExample()
		{
			setupVisuals();
		}

		private function setupVisuals():void
		{
		     //....verkürzt
		}

		private function buttonHandler(e:MouseEvent):void
		{
			if(e.target == goButton)
				changeObject();

			if(e.target == undoButton)
				undo();
		}

		private function changeObject():void
		{

			var command:MacroCommand;
			var yv:Number = Number(yTextField.text);
			var xv:Number = Number(xTextField.text);
			var av:Number = Number(aTextField.text);

			if(!isNaN(yv) && !isNaN(xv) && !isNaN(av))
			{
				command = new MacroCommand();
				command.addSubCommand(new MoveCommand(circle, xv, yv));
				command.addSubCommand(new AlphaCommand(circle, av));

				commandStack.push(command);
				command.execute();
			}
		}

		private function undo():void
		{
			var command:ICommand;

			if(commandStack.length > 0)
			{
				command = commandStack.pop() as ICommand;
				command.undo();
			}
		}
	}
}

Der Vorteil dieser Struktur liegt in der Flexibilität. Wir verwenden einfach mehreren MacroCommands um so Funktionalität zu bündeln und den kompletten Befehlsverbund leicht Rückgängig zu machen.

Ich kann jedem empfehlen, dort mal einen Blick reinzuwerfen. Alternativ ist natürlich immer ein MVC-Framework eine gute Wahl. Für Flash/Flex gibt es eine recht große Auswahl. Ich benutze aktuell PureMVC für diverse Projekte, weitere sind z.B. Mate, Swiz, Cairngorm oder Parsley. Die einzelnen Frameworks unterscheiden sich häufig in Art und Anzahl der benutzten Patterns.

Zum Thema Flex-Frameworks hat auch David Tucker kürzlich einen interessanten Blogeintrag geschrieben. Dieser behandelt einige Probleme diverser Frameworks und zeigt Alternativen auf.

Link zum Artikel von David Tucker.
Link zum  Artikel Truckin´ Through ActionScript 3.0 MVC: Part 2
Link zum  Artikel Truckin´ Through ActionScript 3.0 MVC: Part 2
Link zum  Artikel Truckin´ Through ActionScript 3.0 MVC: Part 3
Link zum  Artikel Truckin´ Through ActionScript 3.0 MVC: Part 4

UPDATE:
Link zum  Artikel Truckin´ Through ActionScript 3.0 MVC: Part 5