+Show TOC
×Hide TOC

AbstractLoader

Kind of class:	public class
Package:	com.bourre.load
Inherits from:	none
Implements:	ASyncCommand com.bourre.load.Loader
Known subclasses:	ApplicationLoader FileLoader GraphicLoader QueueLoader RemotingCall SoundLoader VideoDisplay
Version:	1.0
Author:	Francis Bourre
Classpath:	com.bourre.load.AbstractLoader
File last modified:	Monday, 24 November 2008, 11:36:46

► View source

▼ Hide source

/*
 * Copyright the original author or authors.
 * 
 * Licensed under the MOZILLA PUBLIC LICENSE, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.mozilla.org/MPL/MPL-1.1.html
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.bourre.load
{
    import com.bourre.commands.ASyncCommand;
    import com.bourre.commands.ASyncCommandListener;
    import com.bourre.commands.AbstractSyncCommand;
    import com.bourre.error.IllegalStateException;
    import com.bourre.error.NullPointerException;
    import com.bourre.events.EventBroadcaster;
    import com.bourre.load.strategy.LoadStrategy;
    import com.bourre.log.PixlibDebug;
    import com.bourre.log.PixlibStringifier;
    
    import flash.events.Event;
    import flash.net.URLRequest;
    import flash.system.LoaderContext;
    import flash.utils.Dictionary;
    import flash.utils.getTimer;    
    
    /**
     * @author Francis Bourre
     * @version 1.0
     */
    public class AbstractLoader 
        implements     com.bourre.load.Loader, ASyncCommand
    {
        static private var _oPool : Dictionary = new Dictionary();

        static protected function registerLoaderToPool ( o : Loader ) : void
        {
            if( _oPool[ o ] == null )
            {
                _oPool[ o ] = true;

            } else
            {
                PixlibDebug.WARN( o + " is already registered in the loading pool" );
            }
        }

        static protected function unregisterLoaderFromPool ( o : Loader ) : void
        {
            if( _oPool[ o ] != null )
            {
                delete _oPool[ o ];

            } else
            {
                PixlibDebug.WARN( o + " is not registered in the loading pool" );
            }
        }

        private var _oEB : EventBroadcaster;
        private var _sName : String;
        private var _nTimeOut : Number;
        private var _oURL : URLRequest;
        private var _bAntiCache : Boolean;
        protected var _sPrefixURL : String;

        private var _loadStrategy : LoadStrategy;
        private var _oContent : Object;
        private var _bIsRunning : Boolean;
        private var _nLastBytesLoaded : Number;
        private var _nTime : int;

        public function AbstractLoader( strategy : LoadStrategy = null )
        {
            _loadStrategy = (strategy != null) ? strategy : new NullLoadStrategy();
            _loadStrategy.setOwner( this );

            _oEB = new EventBroadcaster( this, LoaderListener );
            _nTimeOut = 10000;
            _bAntiCache = false;
            _sPrefixURL = "";
            _bIsRunning = false;
        }

        public function execute( e : Event = null ) : void
        {
            load();
        }

        public function getStrategy () : LoadStrategy
        {
            return _loadStrategy;
        }

        public function load( url : URLRequest = null, context : LoaderContext = null ) : void
        {
            if ( url ) setURL( url );

            if ( getURL().url.length > 0 )
            {
                _nLastBytesLoaded = 0;
                _nTime = getTimer();

                registerLoaderToPool( this );
                _loadStrategy.load( getURL(), context );

            } else
            {
                var msg : String = this + ".load() can't retrieve file url.";
                PixlibDebug.ERROR( msg );
                throw new NullPointerException( msg );
            }
        }

        protected function onInitialize() : void
        {
            fireEventType( LoaderEvent.onLoadProgressEVENT );
            fireEventType( LoaderEvent.onLoadInitEVENT );
        }

        final protected function setListenerType( type : Class ) : void
        {
            _oEB.setListenerType( type );
        }

        public function getBytesLoaded() : uint
        {
            return _loadStrategy.getBytesLoaded();
        }

        public function getBytesTotal() : uint
        {
            return _loadStrategy.getBytesTotal();
        }

        final public function getPerCent() : Number
        {
            var n : Number = Math.min( 100, Math.ceil( getBytesLoaded() / ( getBytesTotal() / 100 ) ) );
            return ( isNaN(n) ) ? 0 : n;
        }
        
        final public function isLoaded( ) : Boolean
        {
            return ( getBytesLoaded() / getBytesTotal() ) == 1 ;
        }

        public function getURL() : URLRequest
        {
            return _bAntiCache ? new URLRequest( _sPrefixURL + _oURL.url + "?nocache=" + _getStringTimeStamp() ) : new URLRequest( _sPrefixURL + _oURL.url );
        }

        public function setURL( url : URLRequest ) : void
        {
            _oURL = url;
        }

        final public function addASyncCommandListener( listener : ASyncCommandListener, ... rest ) : Boolean
        {
            return _oEB.addEventListener( AbstractSyncCommand.onCommandEndEVENT, listener );
        }

        final public function removeASyncCommandListener( listener : ASyncCommandListener ) : Boolean
        {
            return _oEB.removeEventListener(  AbstractSyncCommand.onCommandEndEVENT, listener );
        }

        public function addListener( listener : LoaderListener ) : Boolean
        {
            return _oEB.addListener( listener );
        }

        public function removeListener( listener : LoaderListener ) : Boolean
        {
            return _oEB.removeListener( listener );
        }

        public function addEventListener( type : String, listener : Object, ... rest ) : Boolean
        {
            return _oEB.addEventListener.apply( _oEB, rest.length > 0 ? [ type, listener ].concat( rest ) : [ type, listener ] );
        }

        public function removeEventListener( type : String, listener : Object ) : Boolean
        {
            return _oEB.removeEventListener( type, listener );
        }

        public function getName() : String
        {
            return _sName;
        }

        public function setName( sName : String ) : void
        {
            _sName = sName;
        }

        public function setAntiCache( b : Boolean ) : void
        {
            _bAntiCache = b;
        }

        public function isAntiCache() : Boolean
        {
            return _bAntiCache;
        }

        public function prefixURL( sURL : String ) : void
        {
            _sPrefixURL = sURL;
        }

        final public function getTimeOut() : Number
        {
            return _nTimeOut;
        }

        final public function setTimeOut( n : Number ) : void
        {
            _nTimeOut = Math.max( 1000, n );
        }

        public function release() : void
        {
            _loadStrategy.release();
            _oEB.removeAllListeners();
        }

        public function getContent() : Object
        {
            return _oContent;
        }

        public function setContent( content : Object ) : void
        {    
            _oContent = content;
        }

        public function fireOnLoadProgressEvent() : void
        {
            fireEventType( LoaderEvent.onLoadProgressEVENT );
        }

        final public function fireOnLoadInitEvent() : void
        {
            _bIsRunning = false;
            onInitialize();
            unregisterLoaderFromPool( this );
        }

        public function fireOnLoadStartEvent() : void
        {
            fireEventType( LoaderEvent.onLoadStartEVENT );
        }

        public function fireOnLoadErrorEvent( message : String = "" ) : void
        {
            fireEventType( LoaderEvent.onLoadErrorEVENT, message );
        }

        public function fireOnLoadTimeOut() : void
        {
            unregisterLoaderFromPool( this );
            fireEventType( LoaderEvent.onLoadTimeOutEVENT );
        }

        final public function fireCommandEndEvent() : void
        {
            fireEventType( AbstractSyncCommand.onCommandEndEVENT );
        }

        /**
         * Returns the string representation of this instance.
         * 
         * @return the string representation of this instance
         */
        public function toString() : String 
        {
            return PixlibStringifier.stringify( this );
        }

        //
        protected function fireEventType( type : String, errorMessage : String = "" ) : void
        {
            fireEvent( getLoaderEvent( type, errorMessage ) );
        }

        protected function fireEvent( e : Event ) : void
        {
            _oEB.broadcastEvent( e );
        }

        protected function getLoaderEvent( type : String, errorMessage : String = "" ) : LoaderEvent
        {
            return new LoaderEvent( type, this, errorMessage );
        }

        //
        private function _getStringTimeStamp() : String
        {
            var d : Date = new Date();
            return String( d.getTime() );
        }

        public function run () : void
        {
            if ( !isRunning() )
            {
                _bIsRunning = true;
                execute();

            } else
            {
                var msg : String = this + ".run() called wheras an operation is currently running";
                PixlibDebug.ERROR( msg );
                throw new IllegalStateException( msg );
            }
        }

        public function isRunning () : Boolean
        {
            return _bIsRunning;
        }

        // TODO check if _checkTimeOut is important
//        private function _checkTimeOut( nLastBytesLoaded : Number, nTime : Number ) : void 
//        {
//            if ( nLastBytesLoaded != _nLastBytesLoaded)
//            {
//                _nLastBytesLoaded = nLastBytesLoaded;
//                _nTime = nTime;
//            }
//            else if ( nTime - _nTime  > _nTimeOut)
//            {
//                fireOnLoadTimeOut();
//                release();
//                PixlibDebug.ERROR( this + " load timeout with url : '" + getURL() + "'." );
//            }
//        }
    }
}

import com.bourre.load.Loader;
import com.bourre.load.strategy.LoadStrategy;

import flash.net.URLRequest;
import flash.system.LoaderContext;

internal class NullLoadStrategy 
    implements LoadStrategy
{
        public function load( request : URLRequest = null, context : LoaderContext = null  ) : void {}
        public function getBytesLoaded() : uint { return 0; }
        public function getBytesTotal() : uint { return 0; }
        public function setOwner( owner : Loader ) : void {}
        public function release() : void {}
}

Summary

Constructor

AbstractLoader (strategy:LoadStrategy = null)

Instance methods

execute (e:Event = null) : void
- Execute the request according to the current command data.
getStrategy : LoadStrategy
load (url:URLRequest = null, context:LoaderContext = null) : void
getBytesLoaded : uint
getBytesTotal : uint
getPerCent : Number
isLoaded : Boolean
getURL : URLRequest
setURL (url:URLRequest) : void
addASyncCommandListener (listener:ASyncCommandListener, rest) : Boolean
- Adds the passed-in command listener object as listener
removeASyncCommandListener (listener:ASyncCommandListener) : Boolean
- Removes the passed-in command listener object as listener
addListener (listener:LoaderListener) : Boolean
removeListener (listener:LoaderListener) : Boolean
addEventListener (type:String, listener:Object, rest) : Boolean
removeEventListener (type:String, listener:Object) : Boolean
getName : String
setName (sName:String) : void
setAntiCache (b:Boolean) : void
isAntiCache : Boolean
prefixURL (sURL:String) : void
getTimeOut : Number
setTimeOut (n:Number) : void
release : void
getContent : Object
setContent (content:Object) : void
fireOnLoadProgressEvent : void
fireOnLoadInitEvent : void
fireOnLoadStartEvent : void
fireOnLoadErrorEvent (message:String = "") : void
fireOnLoadTimeOut : void
fireCommandEndEvent : void
- Fires the {VISDOC_CODE_BLOCK_7} event to the listeners of this command.
toString : String
- Returns the string representation of this instance.
run : void
isRunning : Boolean

Constructor

AbstractLoader

public function AbstractLoader (

strategy:LoadStrategy = null)

Instance methods

addASyncCommandListener

final public function addASyncCommandListener (

listener:ASyncCommandListener, rest) : Boolean

Adds the passed-in command listener object as listener
for this command events.

The {VISDOC_CODE_BLOCK_2} function support
the custom arguments provided by the

{VISDOC_CODE_BLOCK_3} method.

Parameters:

listener:

the listener object which want to
receive notification from this command

rest :

optional arguments corresponding to the
{VISDOC_CODE_BLOCK_4} behavior.

Returns:

{VISDOC_CODE_BLOCK_5} if the listener have been added as result
of the call
#

Specified by:

ASyncCommand.addASyncCommandListener

addEventListener

public function addEventListener (

type:String, listener:Object, rest) : Boolean

addListener

public function addListener (

listener:LoaderListener) : Boolean

execute

public function execute (

e:Event = null) : void

Execute the request according to the current command data.

Stateless commands may use the passed-in event object
as data source for its execution. If the execution can't
be performed because of unreachable data the command have
to throw an error.

Parameters:

An event that will be used as data source by the command.

Throws:

{VISDOC_LINK_0}{VISDOC_CODE_BLOCK_2} — Stateless command use the passed-in event
as data source for its execution, so the event must provide the right data for
the current {VISDOC_CODE_BLOCK_3} object.
#

Specified by:

Command.execute

fireCommandEndEvent

final public function fireCommandEndEvent (

) : void

Fires the {VISDOC_CODE_BLOCK_7} event to the listeners of this command.

Specified by:

ASyncCommand.fireCommandEndEvent

fireOnLoadErrorEvent

public function fireOnLoadErrorEvent (

message:String = "") : void

fireOnLoadInitEvent

final public function fireOnLoadInitEvent (

) : void

fireOnLoadProgressEvent

public function fireOnLoadProgressEvent (

) : void

fireOnLoadStartEvent

public function fireOnLoadStartEvent (

) : void

fireOnLoadTimeOut

public function fireOnLoadTimeOut (

) : void

getBytesLoaded

public function getBytesLoaded (

) : uint

getBytesTotal

public function getBytesTotal (

) : uint

getContent

public function getContent (

) : Object

getName

public function getName (

) : String

getPerCent

final public function getPerCent (

) : Number

getStrategy

public function getStrategy (

) : LoadStrategy

getTimeOut

final public function getTimeOut (

) : Number

getURL

public function getURL (

) : URLRequest

isAntiCache

public function isAntiCache (

) : Boolean

isLoaded

final public function isLoaded (

) : Boolean

isRunning

public function isRunning (

) : Boolean

load

public function load (

url:URLRequest = null, context:LoaderContext = null) : void

prefixURL

public function prefixURL (

sURL:String) : void

release

public function release (

) : void

removeASyncCommandListener

final public function removeASyncCommandListener (

listener:ASyncCommandListener) : Boolean

Removes the passed-in command listener object as listener
for this command events.

Parameters:

listener:

the listener object which to remove from this
command's listeners

Returns:

{VISDOC_CODE_BLOCK_6} if the listener have been removed as result
of the call
#

Specified by:

ASyncCommand.removeASyncCommandListener

removeEventListener

public function removeEventListener (

type:String, listener:Object) : Boolean

removeListener

public function removeListener (

listener:LoaderListener) : Boolean

run

public function run (

) : void

setAntiCache

public function setAntiCache (

b:Boolean) : void

setContent

public function setContent (

content:Object) : void

setName

public function setName (

sName:String) : void

setTimeOut

final public function setTimeOut (

n:Number) : void

setURL

public function setURL (

url:URLRequest) : void

toString

public function toString (

) : String

Returns the string representation of this instance.

Returns:

the string representation of this instance