IFilePromise 인터페이스 구현

IFilePromise 인터페이스를 구현하는 가장 간단한 방법은 ByteArray 또는 동기 FileStream과 같은 동기 데이터 공급자 객체를 사용하는 것입니다. 다음 예제에서는 open() 메서드가 호출될 때 ByteArray 객체가 만들어지고 데이터로 채워지며 반환됩니다.

package 
{ 
    import flash.desktop.IFilePromise; 
    import flash.events.ErrorEvent; 
    import flash.utils.ByteArray; 
    import flash.utils.IDataInput; 
     
    public class SynchronousFilePromise implements IFilePromise 
    { 
        private const fileSize:int = 5000; //size of file data 
        private var filePath:String = "SynchronousFile.txt"; 
         
        public function get relativePath():String 
        { 
            return filePath; 
        } 
         
        public function get isAsync():Boolean 
        { 
            return false; 
        } 
         
        public function open():IDataInput 
        { 
            var fileContents:ByteArray = new ByteArray(); 
             
            //Create some arbitrary data for the file 
            for( var i:int = 0; i < fileSize; i++ ) 
            { 
                fileContents.writeUTFBytes( 'S' ); 
            } 
             
            //Important: the ByteArray is read from the current position             
            fileContents.position = 0; 
            return fileContents; 
        } 
         
        public function close():void 
        { 
            //Nothing needs to be closed in this case. 
        } 
         
        public function reportError(e:ErrorEvent):void 
        { 
            trace("Something went wrong: " + e.errorID + " - " + e.type + ", " + e.text ); 
        } 
    } 
}

실제로, 동기 파일 프로미스는 사용이 제한적입니다. 데이터 양이 적은 경우에는 임시 디렉토리에 파일을 만들어서 드래그 앤 드롭 클립보드에 일반적인 파일 목록 배열을 추가하면 간편합니다. 반면에 데이터 양이 많거나 데이터 생성의 계산이 복잡한 경우 긴 동기 프로세스가 필요합니다. 긴 동기 프로세스는 상당한 시간 동안 UI 업데이트를 차단하여 응용 프로그램이 응답하지 않는 것처럼 보이게 만들 수 있습니다. 이러한 문제를 방지하기 위해서는 타이머로 구동되는 비동기 데이터 공급자를 만들 수 있습니다.

비동기 데이터 공급자 객체를 사용하는 경우에는 IFilePromise isAsync 속성이 true여야 하며 open() 메서드로 반환되는 객체에서 IEventDispatcher 인터페이스를 구현해야 합니다. 런타임에서는 여러 기본 제공 객체를 데이터 공급자로 사용할 수 있도록 몇 가지 대체 이벤트를 수신합니다. 예를 들어 progress 이벤트는 FileStream 및 URLStream 객체에 의해 전달되지만 socketData 이벤트는 Socket 객체에 의해 전달됩니다. 런타임에서는 이러한 모든 객체로부터 적합한 이벤트를 수신합니다.

다음 이벤트는 데이터 공급자 객체에서 데이터를 읽는 프로세스를 구동합니다.

• Event.OPEN - 데이터 소스가 준비되었음을 런타임에 알립니다.

• ProgressEvent.PROGRESS - 데이터를 사용할 수 있음을 런타임에 알립니다. 런타임에서 데이터 공급자 객체로부터 사용 가능한 데이터 양을 읽습니다.

• ProgressEvent.SOCKET_DATA - 데이터를 사용할 수 있음을 런타임에 알립니다. socketData 이벤트는 소켓 기반 객체에 의해 전달됩니다. 다른 객체 유형의 경우 progress 이벤트를 전달해야 합니다. 런타임에서 두 이벤트를 모두 수신하여 데이터를 읽을 수 있는 경우를 감지합니다.

• Event.COMPLETE - 데이터를 모두 읽었음을 런타임에 알립니다.

• Event.CLOSE - 데이터를 모두 읽었음을 런타임에 알립니다. 이를 위해 런타임에서 close 및 complete를 모두 수신합니다.

• IOErrorEvent.IOERROR - 데이터를 읽는 동안 오류가 발생했음을 런타임에 알립니다. 런타임에서 파일 만들기를 중단하고 IFilePromise close() 메서드를 호출합니다.

• SecurityErrorEvent.SECURITY_ERROR - 보안 오류가 발생했음을 런타임에 알립니다. 런타임에서 파일 만들기를 중단하고 IFilePromise close() 메서드를 호출합니다.

• HTTPStatusEvent.HTTP_STATUS - 사용 가능한 데이터가 오류 메시지(예: 404 페이지)가 아니라 원하는 내용을 나타내도록 하기 위해 httpResponseStatus와 함께 런타임에서 사용됩니다. HTTP 프로토콜 기반 객체는 이 이벤트를 전달해야 합니다.

• HTTPStatusEvent.HTTP_RESPONSE_STATUS - 사용 가능한 데이터가 원하는 내용을 나타내도록 하기 위해 httpStatus와 함께 런타임에서 사용됩니다. HTTP 프로토콜 기반 객체는 이 이벤트를 전달해야 합니다.

데이터 공급자는 다음과 같은 순서로 이러한 이벤트를 전달해야 합니다.

1. open 이벤트

2. progress 또는 socketData 이벤트

3. complete 또는 close 이벤트

다음 예제에서는 사용자 정의 비동기 데이터 공급자를 사용하여 파일 프로미스를 만듭니다. 데이터 공급자 클래스는 ByteArray(IDataInput 지원)를 확장하고 IEventDispatcher 인터페이스를 구현합니다. 각 타이머 이벤트에서 객체는 데이터 청크를 생성하고 데이터를 사용할 수 있음을 런타임에 알리기 위해 progress 이벤트를 전달합니다. 충분한 데이터가 생성되면 객체가 complete 이벤트를 전달합니다.

package 
{ 
import flash.events.Event; 
import flash.events.EventDispatcher; 
import flash.events.IEventDispatcher; 
import flash.events.ProgressEvent; 
import flash.events.TimerEvent; 
import flash.utils.ByteArray; 
import flash.utils.Timer; 
 
[Event(name="open", type="flash.events.Event.OPEN")] 
[Event(name="complete",  type="flash.events.Event.COMPLETE")] 
[Event(name="progress", type="flash.events.ProgressEvent")] 
[Event(name="ioError", type="flash.events.IOErrorEvent")] 
[Event(name="securityError", type="flash.events.SecurityErrorEvent")] 
public class AsyncDataProvider extends ByteArray implements IEventDispatcher 
{ 
    private var dispatcher:EventDispatcher = new EventDispatcher(); 
    public var fileSize:int = 0; //The number of characters in the file 
    private const chunkSize:int = 1000; //Amount of data written per event 
    private var dispatchDataTimer:Timer = new Timer( 100 ); 
    private var opened:Boolean = false; 
     
    public function AsyncDataProvider() 
    { 
        super(); 
        dispatchDataTimer.addEventListener( TimerEvent.TIMER, generateData ); 
    } 
 
    public function begin():void{ 
        dispatchDataTimer.start(); 
    } 
     
    public function end():void 
    { 
        dispatchDataTimer.stop(); 
    } 
    private function generateData( event:Event ):void 
    { 
        if( !opened ) 
        { 
            var open:Event = new Event( Event.OPEN ); 
            dispatchEvent( open );     
            opened = true; 
        } 
        else if( position + chunkSize < fileSize ) 
        { 
            for( var i:int = 0; i <= chunkSize; i++ ) 
            { 
                writeUTFBytes( 'A' ); 
            } 
            //Set position back to the start of the new data 
            this.position -= chunkSize; 
            var progress:ProgressEvent = 
                new ProgressEvent( ProgressEvent.PROGRESS, false, false, bytesAvailable, bytesAvailable + chunkSize); 
            dispatchEvent( progress ) 
        } 
        else 
        { 
            var complete:Event = new Event( Event.COMPLETE ); 
            dispatchEvent( complete );         
        } 
    } 
     //IEventDispatcher implementation 
    public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false):void 
    { 
        dispatcher.addEventListener( type, listener, useCapture, priority, useWeakReference ); 
    } 
     
    public function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void 
    { 
        dispatcher.removeEventListener( type, listener, useCapture ); 
    } 
     
    public function dispatchEvent(event:Event):Boolean 
    { 
        return dispatcher.dispatchEvent( event ); 
    } 
     
    public function hasEventListener(type:String):Boolean 
    { 
        return dispatcher.hasEventListener( type ); 
    } 
     
    public function willTrigger(type:String):Boolean 
    { 
        return dispatcher.willTrigger( type ); 
    } 
} 
}

비동기 IFilePromise 구현은 동기 구현과 거의 동일합니다. 주요 차이점은 isAsync는 true를 반환하고, open() 메서드는 비동기 데이터 객체를 반환한다는 것입니다.

package 
{ 
    import flash.desktop.IFilePromise; 
    import flash.events.ErrorEvent; 
    import flash.events.EventDispatcher; 
    import flash.utils.IDataInput; 
     
    public class AsynchronousFilePromise extends EventDispatcher implements IFilePromise 
    { 
        private var fileGenerator:AsyncDataProvider; 
        private const fileSize:int = 5000; //size of file data 
        private var filePath:String = "AsynchronousFile.txt"; 
                 
        public function get relativePath():String 
        { 
            return filePath; 
        } 
         
        public function get isAsync():Boolean 
        { 
            return true; 
        } 
         
        public function open():IDataInput 
        { 
            fileGenerator = new AsyncDataProvider(); 
            fileGenerator.fileSize = fileSize; 
            fileGenerator.begin(); 
            return fileGenerator; 
        } 
         
        public function close():void 
        { 
            fileGenerator.end(); 
        } 
         
        public function reportError(e:ErrorEvent):void 
        { 
            trace("Something went wrong: " + e.errorID + " - " + e.type + ", " + e.text ); 
        } 
    } 
}