Question

I want to call a function in main flex app from the custom preloader code in actionscript before it dispatches complete event.
Also i want to know how to call back to a function in preloader code from application

Thanks

Answer 1

So in the preloader init method you can use the following line to get the application:

        parentApplication = event.currentTarget.loaderInfo.content.application;

we had our preloader implement a custom interface called IPreloader and our App implement a custom interface called IPreloaderApp, IPreloader is defined as:

package com.roundarch.adapt.preloader
{
    import mx.preloaders.IPreloaderDisplay;

    public interface IPreloader extends IPreloaderDisplay
    {
        /**
         * Setting this will update the preloader's percentage bar or graphic.
         */
        function set percentage(value:Number):void;
        function get percentage():Number;

        /**
         * Sets the status (if available) on the preloader.
         */
        function set status(value:String):void;

        /**
         * This will communicate to the preloader that loading of all application
         * properties is complete.
         */
        function loadingComplete():void;

        /**
         * This will tell the preloader that there has been an error loading the application.
         *
         * The preloader will probably want to display this error message in a nice display to
         * the user.
         *
         * @param errorString The error message to display.
         * @param fatal If true, the preloader should act as if the application will not run perhaps
         * by notifying the user that they cannot continue.
         * @return Should return true if the error was properly handled.
         */
        function displayError(errorString:String, fatal:Boolean=false):Boolean;

        /**
         * Returns true if this IPreloader implementation can handle displaying loading
         * errors through the error(...) method. If false, the implementing application will
         * need to notify the user of any errors itself.
         */
        function get canDisplayErrors():Boolean;
    }
}

and for the IPreloaderApp

package com.roundarch.adapt.preloader
{

    /**
     * Any application which uses an IPreloader as its preloader will be
     * required to implement this interface or throw an error.
     */
    public interface IPreloaderApp
    {
        /**
         * Once the application has loaded and initialized, this method will be called on the
         * application and the preloader will be passed in so the app can make updates to it.
         */
        function preloaderInit(preloader:IPreloader):void;
    }
}

Also something to note, if the app is added behind the preloader instead of in-front (the default behavior) then you won’t see alerts that are popped up by the application since they’ll be behind the preloader so you’ll want to switch the order. Here’s a bit of code we used to get around that:

    private var removedOnce : Boolean;

    //When the Preloader class instance (this things parent) is removed from it's parent
    //add this to the stage, allows us to dispatch the complete event at the corret time
    //allowing the SystemManager to add the application to the stage and adding this at
    //index 0 to allow pop-ups to show over it.
    private function parentRemoved(event : Event) : void
    {
        if (!removedOnce)
        {
            removedOnce = true;

            stage.addChildAt(this, 0);
            ToolTipManager.enabled = false;
        }
    }

after the parentApplication is set within the preloader init handler as shown at the top of this post we add a handler to catch the removal of the preloader by the SystemManager and re-add it (there is no visible flicker)

        //Lets the system manager know to add the application to the stage
        //this will also remove the preloader for this reason I'm listening for the removal
        //then adding the preloader to the stage again
        parent.addEventListener(Event.REMOVED, parentRemoved);
        dispatchEvent(new Event(Event.COMPLETE));

One other thing to note is that you don’t want to “pollute” your preloader code with any Flex classes, if you include things from the framework you will end up having to load the entire framework into memory before the preloader begins (which can be hefty).