However, it must be mentioned that embedding a text XML within SWF will get it compressed as part of the SWF compression anyway. Therefore, if compression is the only motivation, don’t convert the XML to binary and embed the binary version – it does not make sense. But if you wish to do some data encryption, then the additional work may be appropriate.

Embedding External Data
You can embed any external source, including any external XML file, within your SWF using the [Embed] tag:

// ActionScript 3.0
 
// assuming you have an XML file named "data.xml" in folder "assets/data/"
 
[Embed(source="assets/data/data.xml", mimeType="application/octet-stream")]
private static const binaryXML:Class;

Back To XML
You can then instantiate the binary data and convert it back to XML in your code:

var xmlData:XML;
 
var bytes:ByteArray = new binaryXML() as ByteArray
if (bytes)
{
	try
	{
		bytes.uncompress();
	}
	catch(e:Error)
	{
	}
	xmlData = XML(bytes);
}

NOTE: The above code will be able to handle both binary XML and text XML files.

ROT128 Encrypted Binary XML
If you had performed ROT128 encryption on the binary XML, you decrypt it accordingly before calling uncompress():

var xmlData:XML;
 
var bytes:ByteArray = new binaryXML() as ByteArray
if (bytes)
{
	// BEGIN ROT128
	var j:int = data.length;
	while (j--)
	{
		data[j] += 128;
	}
	// END ROT128
	bytes.uncompress();
	xmlData = XML(bytes);
}

NOTE: The above code assumes the data is binary and ROT128 encrypted; it will not be able to handle text XML.

Part I: “Applying ROT128 Encryption On ByteArray”
Part II: “Applying ROT128 Encryption On Embedded/Module SWFs”

In “Saving XML As Binary”, we looked at how text XML can be stored in a ByteArray object so that it can be compressed and made non-human-readable. In this post, we look at how you can integrate ROT128 into the XML-to-ByteArray-to-XML routines. Binary XML is used only as an example; you can definitely apply the same concept to other binary data.

XML-to-ByteArray:
ROT128 is applied after the XML is stored and compressed as ByteArray.

var data:ByteArray = new ByteArray();
data.writeUTFBytes(xmlData); // xmlData is original XML string
data.compress();
// BEGIN ROT128
var j:int = data.length;
while (j--)
{
	data[j] += 128;
}
// END ROT128
new FileReference().save(data, "bindata.xml"); // default name "bindata.xml"

ByteArray-to-XML:
With ROT128 applied, the saved binary file is no longer a valid compressed ByteArray – it cannot be uncompressed and converted back to XML without first reversing the encryption on the raw data.

// event handler for Event.COMPLETE of URLLoader loading external XML
function on_XML(evt:Event):void
{
	var data:* = URLLoader(evt.target).data;
	if (data is ByteArray)
	{
		try
		{
			// BEGIN ROT128
			var j:int = data.length;
			while (j--)
			{
				data[j] += 128;
			}
			// END ROT128
			data.uncompress();
		}
		catch(e:Error)
		{
		}
	}
	data = XML(data);
	// handle data as XML
}

Partial Encryption
In order to make the process of reversing ROT128 encryption less predictable, you could vary the conditions under which the encryption is to be applied.

Here is an example (alternate bytes):

// BEGIN ROT128
var j:int = data.length;
while (j--)
{
	data[j] += 128;
	j--; // skip next byte
}
// END ROT128

Another example (first 1024 bytes):

// BEGIN ROT128
var j:int = (data.length < 1024) ? data.length : 1024;
while (j--)
{
	data[j] += 128;
}
// END ROT128

Correspondingly, your applications would reverse the encryption under the same conditions. Effectively, these conditions determine the complexity of your cipher and become the “secret key” necessary to decrypt the data.

Conclusion
ROT128 is a weak encryption technique that you should not use to protect sensitive data. However, the light-weight algorithm can be used to make binary blobs inaccessible to unauthorized parties while allowing your applications to easily restore the data when needed.

This method of encryption may seem amateurish, but it does what it is supposed to do well enough while remaining light-weight and flexible.

It worked well enough for Julius Caesar, after all.

As mentioned in the previous post, you can save XML in binary and get the benefits of compression, but doing so would make it impossible to edit the data through a text editor.

This post explores a simple tool you can create easily using Flash/ActionScript 3, a tool that will allow you (or your clients and end-users) to load, read, edit and save XML in compressed binary format. As shown below, this is a minimalist approach – feel free to beautify and/or customize it to fit your own requirements.

You can find the source code at the end of this post. The code does not use any UI component, not from Aspire UI, Flex or Flash, just plain native Flash Player classes so you can compile the AS3 class alone without any additional library.

(480×480 SWF, 2KB)

• You need Flash Player 10+ to view the above SWF.
• Click the “Browse” button to open a native local filesystem dialog – choose an XML file to load.
• Once loaded, the XML will be displayed in the input text field above.
• After that, click the “Save” button to open a native local filesystem dialog – choose location and file name.
• Look for the saved file in your local storage – notice that the file size is much smaller than the original.
• If you open the saved file in a text editor, you will see garbage text because it is in compressed binary format.
• You can load a binary XML file into the above tool (if it was saved in “.xml” extension).
• You can edit the XML in the text field before saving.

BinaryXMLTool Class

package 
{
	import flash.display.Sprite;
	import flash.display.Stage;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.events.IOErrorEvent;
	import flash.net.FileFilter;
	import flash.net.FileReference;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.text.TextFieldType;
	import flash.text.TextFormat;
	import flash.utils.ByteArray;
	import flash.xml.XMLDocument;
 
	public class BinaryXMLTool extends Sprite 
	{
 
		// ** minimalist buttons **
		private var browseButton:TextField;
		private var saveButton:TextField;
 
		// ** minimalist editor **
		private var xmlText:TextField;
 
		// ** browse/load/save **
		private var xmlFile:FileReference;
 
		public function BinaryXMLTool():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
 
		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
 
			// entry point
			stage.align			= StageAlign.LEFT;
			stage.scaleMode			= StageScaleMode.NO_SCALE;
			stage.showDefaultContextMenu	= false;
 
			// ** draw minimalist text editor **
			xmlText				= new TextField();
			xmlText.multiline		= true;
			xmlText.background		= true;
			xmlText.backgroundColor		= 0xEEEEEE;
			xmlText.type			= TextFieldType.INPUT;
			xmlText.width			= 400;
			xmlText.height			= 400;
			xmlText.border			= true;
			xmlText.x			= (stage.stageWidth - xmlText.width) * 0.5;
			addChild(xmlText);
 
			// ** draw minimalist browse button **
			browseButton			= new TextField();
			browseButton.autoSize		= TextFieldAutoSize.LEFT;
			browseButton.background		= true;
			browseButton.backgroundColor	= 0x000000;
			browseButton.defaultTextFormat	= new TextFormat("Tahoma", 14, 0xFFFFFF, true, null, null, null, null, null, 4, 4);
			browseButton.selectable		= false;
			browseButton.text		= "BROWSE";
			browseButton.x			= (stage.stageWidth - browseButton.width) * 0.5;
			browseButton.y			= 420;
			addChild(browseButton);
 
			// ** draw minimalist save button **
			saveButton			= new TextField();
			saveButton.autoSize		= TextFieldAutoSize.LEFT;
			saveButton.background		= true;
			saveButton.backgroundColor	= 0xAAAAAA;
			saveButton.defaultTextFormat	= browseButton.defaultTextFormat;
			saveButton.selectable		= false;
			saveButton.text			= "SAVE";
			saveButton.x			= (stage.stageWidth - saveButton.width) * 0.5;
			saveButton.y			= 460;
			addChild(saveButton);
 
			// ** button listeners **
			browseButton.addEventListener(MouseEvent.CLICK, on_buttonClick, false, 0, true);
			saveButton.addEventListener(MouseEvent.CLICK, on_buttonClick, false, 0, true);
		}
 
		/**
		* handle browse or save
		*/
		private function on_buttonClick(evt:MouseEvent):void
		{
			var btn:TextField = evt.target as TextField;
			if (btn)
			{
				if (btn.text == "BROWSE")
				{
					xmlFile = new FileReference();
					xmlFile.addEventListener(Event.SELECT, on_xmlSelect, false, 0, true);
					xmlFile.browse([new FileFilter("XML Documents","*.xml")]);
				}
				else if (btn.text == "SAVE")
				{
					if (xmlFile)
					{
						if (xmlText.text.length)
						{
							// ** saving as binary **
							var data:ByteArray = new ByteArray();
							data.writeUTFBytes(xmlText.text);
							data.compress();
							new FileReference().save(data, "bin" + xmlFile.name);
						}
					}
				}
			}
 
		}
 
		/**
		* handle browse, load XML file
		*/
		private function on_xmlSelect(evt:Event):void
		{
			xmlFile.removeEventListener(Event.SELECT, on_xmlSelect);
			xmlFile.addEventListener(Event.COMPLETE, on_xmlComplete, false, 0, true);
			xmlFile.load();
		}
 
		/**
		* handle load, check if it is binary, uncompress, display XML in editor
		*/
		private function on_xmlComplete(evt:Event):void
		{
			xmlFile.removeEventListener(Event.COMPLETE, on_xmlComplete);
 
			saveButton.backgroundColor = 0x000000;
 
			var data:* = FileReference(evt.target).data;
			if (data is ByteArray)
			{
				try
				{
					ByteArray(data).uncompress();
				}
				catch(e:Error)
				{
				}
 
			}
			data = XML(data);
			xmlText.text = data;
		}
	}	
}

Admittedly, having the XML data in compressed binary format contradicts the original intention of using XML in the first place – to allow human-readable data. Therefore, you will have to decide what exactly is important for your application before proceeding. Perhaps having cryptic external data is indeed what you want – allowing data to be externalized so they can be changed without requiring the SWF to be recompiled, and yet would prefer the data to be non-human-readable.

Converting XML To Binary Data (ByteArray)
First, we look at how to store the XML data in a ByteArray. The following code assumes that you already have the XML data stored as a String value in a variable named “xmlData”:

var data:ByteArray = new ByteArray();
data.writeUTFBytes(xmlData); // xmlData is original XML string
data.compress();

And that does it – the XML data is now in compressed binary.

Saving to File
Now that you have the binary data as a ByteArray object, you can save that object to file as raw data. You can do that either by
(i) posting to a server script;
(ii) using AIR API to save to local storage; or
(iii) using Flash Player 10 API to save to local storage.

We will look at (iii), because that is most accessible to every Flash developer. The class you will use is flash.net.FileReference. The FileReference.save() method is available when targeting Flash Player 10 – it allows you to save the data in the FileReference object to a local file.

As a security measure, the save() method will only work in the Flash Player if you call it in response to a user event (for example, MouseEvent.CLICK event). Therefore, you need to create a button, attach a listener to it, and call the save() method in the listener.

function on_buttonClick(evt:MouseEvent):void
{
	var data:ByteArray = new ByteArray();
	data.writeUTFBytes(xmlData); // xmlData is original XML string
	data.compress();
	new FileReference().save(data, "bindata.xml"); // default name "bindata.xml"
}

The save() method will open a native dialog box – choose a file name and location and you will save the XML data in your local filesystem. Notice that you can save the file in the “.xml” extension, but you will no longer get a human-readable XML file – you will see garbage text if you open the file in a text editor because the data is in compressed binary.

Loading Binary XML
You can load the binary file the same way you would a normal XML file:

var ldr:URLLoader	= new URLLoader();
ldr.dataFormat	= URLLoaderDataFormat.BINARY; // ** make sure you do this **
ldr.addEventListener(Event.COMPLETE, on_XML);
ldr.addEventListener(IOErrorEvent.IO_ERROR, on_XML);
ldr.load(new URLRequest(pathToXMLFile));

Therefore, the code for loading is the same as for normal text XML files, except that you need to set dataFormat to URLLoaderDataFormat.BINARY. Even if you end up loading a normal text XML file, the above code will work just fine.

Converting Binary Data To XML
After the binary XML file is loaded, you convert the binary data back to text XML.

var xmlData:XML;
 
function on_XML(evt:Event):void
{
	if (evt.type == Event.COMPLETE)
	{
		var data:* = URLLoader(evt.target).data;
		if (data is ByteArray)
		{
			try
			{
				ByteArray(data).uncompress();
			}
			catch(e:Error)
			{
			}
		}
		xmlData = XML(data);
	}
}

With the code above, your application will be able to handle both text XML and binary XML files. Therefore, this code is something you can use even if you are not currently using XML stored as compressed binary data. If at a later time you decide to compress your XML in binary format, the application will be able to handle it just fine.

In the next post, we will look at a simple tool you can create easily using Flash/ActionScript 3 to load, read, edit and save XML files in compressed binary format.

Note:
The above technique can be used for any text file, not just XML.