Let’s suppose your app makes a lot of http requests at once, and you need a good administration for that. Based on used browser your app is running on, you are only allowed to limited request count – mostly its 2 requests per domain, the remaining ones are sitting in browser buffer waiting to finish those actual. URLRequestBuffer is handy class that lets you manage URLRequest-s. E.g. you are creating image gallery and request hundreds of images in gallery at a time, now when user navigates throug the images you need to make some request more prioritized before others, some to be canceled, some may timeout etc. Here comes URLRequestBuffer in scene.

Pushing requests into the buffer automaticaly sorts requests by priority and tries to load next request based on priority/delay logic. After request is complete (timeouted, or error) it loads next and so on. Usage is very simple once you get familiar with 3 classes it consist of (URLRequestBuffer, URLRequestBufferItem and URLRequestBufferEvent)

// define buffer and max simultaneous (active) requests
var buffer:URLRequestBuffer = new URLRequestBuffer(2);

// loader - URLLoader or Loader instance
// request - URLRequest instance
// priority - uint, higher priority requests loads first
// delay - request is called after X milliseconds after pushing
// pushing requests into buffer returns URLRequestBufferItem, next suitable requests called
var bufferItem:URLRequestBufferItem = buffer.push(loader, request, priority, delay);
var bufferId:uint = bufferItem.id;

// URLRequestBufferItem by bufferId
buffer.getWaitingById(bufferId)
buffer.getActiveById(bufferId)

// stop and trash request (buffered or active)
buffer.removeWaitingById(bufferId);
buffer.removeActiveById(bufferId);

// enumerating waiting item list
for(var i:uint = 0; i < buffer.countWaiting; i++)
    bufferItem = buffer.getWaitingItem(i);

// enumerating active item list
for(var i:uint = 0; i < buffer.countActive; i++)
    bufferItem = buffer.getActiveItem(i);

// buffer event handling
buffer.addEventListener(URLRequestBufferEvent.WAITING_REQUEST_ADDED, onBufferChange);
buffer.addEventListener(URLRequestBufferEvent.WAITING_REQUEST_REMOVED, onBufferChange);
buffer.addEventListener(URLRequestBufferEvent.ACTIVE_REQUEST_ADDED, onBufferChange);
buffer.addEventListener(URLRequestBufferEvent.ACTIVE_REQUEST_REMOVED, onBufferChange);
buffer.addEventListener(URLRequestBufferEvent.REQUEST_TIMEOUT, onBufferChange);

private function onBufferChange(event:URLRequestBufferEvent):void
{
    var bufferItem:URLRequestBufferItem = event.item;

    // some stats
    trace(buffer.countWaiting, buffer.countActive)
}

This post is about communication between loader (Parent.as) flash object (.swf) and loaded (Child.as) flash object. While flash is event based, I find it correct to use events to communicate, although different methods exist (direct function call etc.)

Here is our Parent.as class (goes Parent.swf). It loads Child.as on init and listens for events on it Child. It contains green circle pseudo button:

package
{
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.net.URLRequest;

    public class Parent extends Sprite
    {
        private var loader:Loader = new Loader();

        public function Parent()
        {
            var request:URLRequest = new URLRequest("Child.swf");

            loader.contentLoaderInfo.addEventListener(Event.COMPLETE, complete);
            loader.load(request);
            addChild(loader);

            addEventListener("hallo", hallo);

            var btn:Sprite = new Sprite();
            btn.graphics.beginFill(0x00ff00);
            btn.graphics.drawCircle(0, 50, 50);
            btn.graphics.endFill();
            btn.addEventListener(MouseEvent.CLICK, click);
            addChild(btn);
        }

        private function complete(event:Event):void
        {
            trace("Parent::complete()");
        }

        private function hallo(event:Event):void
        {
            trace("Parent::hallo()");
        }

        private function click(event:MouseEvent):void
        {
            trace("Parent::click()");
            loader.content.dispatchEvent(new Event("welcome"));
        }
    }
}

Child.as (published as Child.swf) dispatches event when added to stage and listens for other events from Parent loader. Contains black button:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;

    public class Child extends Sprite
    {
        public function Child()
        {
            super();

            var btn:Sprite = new Sprite();
            btn.graphics.beginFill(0);
            btn.graphics.drawCircle(50, 50, 50);
            btn.graphics.endFill();
            btn.addEventListener(MouseEvent.CLICK, click);
            addChild(btn);

            addEventListener(Event.ADDED_TO_STAGE, added);
            addEventListener("welcome", welcome);
        }

        private function click(event:MouseEvent):void
        {
            trace("Child::click()");
            dispatchEvent(new Event("hallo", true));
        }

        private function added(event:Event):void
        {
            trace("Child::added()");
            dispatchEvent(new Event("hallo", true));
        }

        private function welcome(event:Event):void
        {
            trace("Child::welcome()");
        }
    }
}

Make sure you create Child.swf before you load it in Parent.swf. After you run Parent.swf, following is traced:

Child::added()
Parent::hallo()
Parent::complete()

after clicking button in Parent.swf you see:

Parent::click()
Child::welcome()

and click on button in Child.swf:

Child::click()
Parent::hallo()

The communication is event based, it is as easy as call dispatchEvent() with bubbling from Child or loader.content.dispatchEvent() from Parent:

In fact, loader.content is instance of Child.as root, so If you define listener directly on loader.content, you do not need to make dispatchEvent()-s bubbling.

To make it work online, make sure both .swf files are with the same securty sandbox and from same domain (or acceptable Security.allowDomain() set to make the other file access script).

Update: jdem.cz, tinyurl.com, bit.ly, tr.im, is.gd providers implemented.

Application (view source enabled), please use your own api key for bit.ly

I have just discovered tr.im has not crossdomain.xml, please do not us it while it throws errors. I have just asked them and few more providers to create crossdomain files, will see…

There are two methods you can handle resuls:

// 1. use callback function
URLShorten.jdemcz(long_url.text, jdemczResult);

// ...callback function gets one parameter = short url
private function jdemczResult(url:String):void
{
    jdemcz = url;
}

// 2. addEventDispatcher to have bigger control
var dispatcher:EventDispatcher = URLShorten.tinyurlcom(long_url.text);
dispatcher.addEventListener(URLShortenEvent.COMPLETE, tinyurlcomComplete);

// ...dispatched event.url = short url
private function tinyurlcomComplete(event:URLShortenEvent):void
{
    tinyurl = event.url;
}

URLShorten class

package sk.yoz.net
{
    import com.adobe.serialization.json.JSON;

    import flash.events.Event;
    import flash.net.URLRequest;
    import flash.net.URLVariables;

    import sk.yoz.events.URLShortenEvent;

    public class URLShorten extends Object
    {
        public function URLShorten()
        {
            super();
        }

        private static function prepare(request:URLRequest,
            variables:URLVariables, callback:Function,
            completeHandler:Function=null):URLLoaderDynamic
        {
            var loader:URLLoaderDynamic = new URLLoaderDynamic();
            var handler:Function = completeHandler || complete;

            request.data = variables;
            loader.callback = callback;
            loader.load(request);
            loader.addEventListener(Event.COMPLETE, handler);
            return loader;
        }

        private static function complete(event:Event):void
        {
            var loader:URLLoaderDynamic = URLLoaderDynamic(event.target);
            var url:String = String(loader.data);

            loader.removeEventListener(Event.COMPLETE, complete);
            dispatch(url, loader)
        }

        private static function dispatch(url:String, loader:URLLoaderDynamic)
            :void
        {
            var callback:Function = loader.callback;
            var type:String = URLShortenEvent.COMPLETE;

            if(callback != null)
                callback(url);
            loader.dispatchEvent(new URLShortenEvent(type, false, false, url));
        }

        public static function jdemcz(longUrl:String, callback:Function=null)
            :URLLoaderDynamic
        {
            var apiUrl:String = "http://www.jdem.cz/get";
            var request:URLRequest = new URLRequest(apiUrl);
            var variables:URLVariables = new URLVariables();

            variables.url = longUrl;
            return prepare(request, variables, callback);
        }

        public static function tinyurlcom(longUrl:String,
            callback:Function=null):URLLoaderDynamic
        {
            var apiUrl:String = "http://tinyurl.com/api-create.php";
            var request:URLRequest = new URLRequest(apiUrl);
            var variables:URLVariables = new URLVariables();

            variables.url = longUrl;
            return prepare(request, variables, callback);
        }

        public static function bitly(longUrl:String, login:String,
            apiKey:String, version:String="2.0.1", callback:Function=null)
            :URLLoaderDynamic
        {
            var apiUrl:String = "http://api.bit.ly/shorten";
            var request:URLRequest = new URLRequest(apiUrl);
            var variables:URLVariables = new URLVariables();

            variables.version = version;
            variables.longUrl = longUrl;
            variables.login = login;
            variables.apiKey = apiKey;
            return prepare(request, variables, callback, bitlyComplete);
        }

        private static function bitlyComplete(event:Event):void
        {
            var loader:URLLoaderDynamic = URLLoaderDynamic(event.target);
            var result:String = String(loader.data);
            var data:Object = JSON.decode(result);
            var url:String;

            loader.removeEventListener(Event.COMPLETE, bitlyComplete);
            for each(var resultItem:Object in data.results)
                url = resultItem.shortUrl;
            dispatch(url, loader);
        }

        public static function trim(longUrl:String,
            callback:Function=null):URLLoaderDynamic
        {
            var apiUrl:String = "http://api.tr.im/v1/trim_simple";
            var request:URLRequest = new URLRequest(apiUrl);
            var variables:URLVariables = new URLVariables();

            variables.url = longUrl;
            return prepare(request, variables, callback);
        }

        public static function isgd(longUrl:String,
            callback:Function=null):URLLoaderDynamic
        {
            var apiUrl:String = "http://is.gd/api.php";
            var request:URLRequest = new URLRequest(apiUrl);
            var variables:URLVariables = new URLVariables();

            variables.longurl = longUrl;
            return prepare(request, variables, callback);
        }
    }
}

we need loader to hold callback function reference, URLLoaderDynamic class pretty much fits this needs

package sk.yoz.net
{
    import flash.net.URLRequest;
    import flash.net.URLLoader;

    import sk.yoz.net.URLLoaderDynamic;

    public dynamic class URLLoaderDynamic extends URLLoader
    {
        public function URLLoaderDynamic(request:URLRequest=null)
        {
            super(request);
        }

    }
}

custom URLShortenEvent class is dispatched after url is returned

package sk.yoz.events
{
    import flash.events.Event;

    public class URLShortenEvent extends Event
    {
        public static const COMPLETE:String = "URLShortenEventCOMPLETE";

        private var _url:String;

        public function URLShortenEvent(type:String, bubbles:Boolean=false,
            cancelable:Boolean=false, url:String="")
        {
            super(type, bubbles, cancelable);
            _url = url;
        }

        public function get url():String
        {
            return _url;
        }
    }
}

It may be not popular, but it is possible to substitute / override whole class from .swc file. Lets say you are using some public api, in our case Facebook actionscript api. I admire work of developer team, but I would like to have some things different. My facebook application requires publish_stream extended permission right after user login (authorize) my application. Even if official facebook api documentation says it is possible to ask for extended permission with login.php call (req_perms parameter), our facebook actionscript api does not offer setting this parameter.

After few moments of research it was clear that login.php call makes DesktopSession class, method onLogin()…

... some code ...

protected function onLogin(p_event:FacebookEvent):void {
	p_event.target.removeEventListener(FacebookEvent.COMPLETE, onLogin);

	if (p_event.success) {
		_auth_token = (p_event.data as StringResultData).value;

		//now that we have an auth_token we need the user to login with it
		var request:URLRequest = new URLRequest();
		var loginParams:String = '?';

		if (_offline_access) {
				loginParams += 'ext_perm=offline_access&';
		}

		request.url = login_url+loginParams+"api_key="+api_key+"&v="+api_version+"&auth_token="+_auth_token;

		navigateToURL(request, "_blank");

		_waiting_for_login = true;
		dispatchEvent(new FacebookEvent(FacebookEvent.WAITING_FOR_LOGIN));
	} else {
		onConnectionError(p_event.error);
	}
}

... some code ...

Now lets do the dirty work. If it were possible, I would extend DesktopSession class and override just onLogin function, but api creates and uses DesktopSession inside its whole logic, so there is no way to succeed. However, it is possible to override whole class. First, in your flex project (with facebook swc in library path), create directory structure com/facebook/session/ (the same as DesktopSession package defines), than copy DesktopSession.as file inside. Well, thats it … From now, when you publish your application, compilator uses your DesktopSession instead of the one in .swc.

To make the new class working for my needs, onLogin function needs to be changed into something like this:

... some code ...

protected function onLogin(p_event:FacebookEvent):void {
	p_event.target.removeEventListener(FacebookEvent.COMPLETE, onLogin);

	if (p_event.success) {
		_auth_token = (p_event.data as StringResultData).value;

		//now that we have an auth_token we need the user to login with it
		var request:URLRequest = new URLRequest(login_url);
		var variables:URLVariables = new URLVariables();

		variables.req_perms = 'publish_stream';
		variables.api_key = api_key;
		variables.v = api_version;
		variables.auth_token = _auth_token;
		variables.fbconnect = "true";
		variables.connect_display = "page";

		request.data = variables;
		navigateToURL(request, "_blank");

		_waiting_for_login = true;
		dispatchEvent(new FacebookEvent(FacebookEvent.WAITING_FOR_LOGIN));
	} else {
		onConnectionError(p_event.error);
	}
}

... some code ...

By asking extended permissions with login.php, facebook opens more step authorization dialog where each permissions is separated into own step and user can allow or dont allow each.

Important:

• Even if you send req_perms=publish_stream with login.php, facebook only accepts it when your app is live (not from your desktop testing) … Functionality already bugged in facebook bugzilla
• Even if it is possible to override class this way, consider using it. Next time there may be newer version of .swc with some changes in your overriden class!

Flex Error #1034: Type Coercion Failed: Cannot Convert *** to mx.core.IFlexDisplayObject

… after using getDefinition() method, in my case:

// url = "../some.swf"
var request:URLRequest = new URLRequest(url);
var context:LoaderContext = new LoaderContext();
context.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
loader = new Loader();
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, assetsComplete);
loader.load(request, context);
...
// assetsComplete()
var applicationDomain:ApplicationDomain = assetsLoader.contentLoaderInfo.applicationDomain;
var assetsClass:Class = applicationDomain.getDefinition("Assets") as Class;
...

The problem is, in fact, the security not coercion! Try move your .swf (the one that is beeing loaded) into the same directory where master .swf file is located.

Lets see how to convert between Bitmap, BitmapData and ByteArray in few examples:

• DisplayObject to BitmapData
• BitmapData to Bitmap
• BitmapData to ByteArray
• URL (image) to ByteArray (asynchronous)
• URL (image) to BitmapData (asynchronous)
• ByteArray to BitmapData (asynchronous)

DisplayObject to BitmapData. FYI DisplayObject is any visible object in flash (Sprite, MovieClip, Bitmap, UIComponent, Video etc…):

import flash.display.BitmapData;
var bitmapData:BitmapData = new BitmapData(button.width, button.height, false, 0xFFFFFF);
bitmapData.draw(button);
// result: bitmapData

BitmapData to Bitmap:

import flash.display.Bitmap;
var bitmap:Bitmap = new Bitmap(bitmapData);
// result: bitmap

BitmapData to ByteArray. Requires jpeg / png or any other encoder. Read more about JPEG encoding here:

import mx.graphics.codec.JPEGEncoder;
import flash.utils.ByteArray;
var encoder:JPEGEncoder = new JPEGEncoder(90);
var byteArray:ByteArray = encoder.encode(bitmapData));
// result: byteArray

URL (image) to ByteArray. Asynchronous operation:

import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.net.URLRequest;
import flash.utils.ByteArray;

var loader:Loader = new Loader();
loader.load(new URLRequest("banner1.jpg"));
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loaderComplete);

private function loaderComplete(event:Event):void
{
    var loaderInfo:LoaderInfo = LoaderInfo(event.target);
    var byteArray:ByteArray = loaderInfo.bytes;
    // result: byteArray
}

URL (image) to BitmapData. Asynchronous operation:

import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.net.URLRequest;
import flash.display.BitmapData;

var loader:Loader = new Loader();
loader.load(new URLRequest("banner1.jpg"));
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loaderComplete);

private function loaderComplete(event:Event):void
{
    var loaderInfo:LoaderInfo = LoaderInfo(event.target);
    var bitmapData:BitmapData = new BitmapData(loaderInfo.width, loaderInfo.height, false, 0xFFFFFF);
    bitmapData.draw(loaderInfo.loader);
    // result: bitmapData
}

ByteArray to BitmapData. Asynchronous operation:

import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.display.BitmapData;

var loader:Loader = new Loader();
loader.loadBytes(byteArray);
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loaderComplete);

private function loaderComplete(event:Event):void
{
    var loaderInfo:LoaderInfo = LoaderInfo(event.target);
    var bitmapData:BitmapData = new BitmapData(loaderInfo.width, loaderInfo.height, false, 0xFFFFFF);
    bitmapData.draw(loaderInfo.loader);
    // result: bitmapData
}

Synchronous JPEG ByteArray to BitmapData can be found here