IFilePromise arabirimini uygulama

IFilePromise arabirimini kullanmanın en kolay yolu ByteArray veya senkronize FileStream gibi senkronize bir veri sağlayıcı nesne kullanmaktır. Aşağıdaki örnekte bir ByteArray nesnesi oluşturulur, veri ile doldurulur ve open() yöntemi çağırıldığında geri döndürülür.

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 ); 
        } 
    } 
}

Uygulamada senkronize dosya vaatlerinin sınırlı kullanım alanı vardır. Veri miktarı az ise, kolaylıkla geçici dizinde bir dosya oluşturup, sürükle ve bırak panosuna normal dosya liste dizisi ekleyebilirsiniz. Diğer yandan, veri miktarı çoksa veya veriyi oluşturmak hesaplama açısından verimli değilse, uzun senkronize olan bir işlem gereklidir. Uzun senkronize işlemler kullanıcı arabirimi güncellemelerini belirli bir süre için engelleyebilir ve uygulamanızın yanıt vermiyormuş gibi görünmesine neden olabilir. Bu sorundan kaçınmak için, zamanlayıcı tarafından yönlendirilen ve senkronize olmayan bir veri sağlayıcısı oluşturabilirsiniz.

Senkronize olmayan bir veri sağlayıcı nesnesi kullandığınızda IFilePromise isAsync özelliği true olmalı ve open yöntemiyle dönen nesne IEventDispatcher arabirimini uygulamalıdır. Yerleşik nesnelerin veri sağlayıcısında kullanılabilmesi için çalışma zamanı çeşitli alternatif olayları dinler. Örneğin, progress olayları FileStream ve URLStream nesneleri tarafından gönderilirken, socketData olayları Socket nesneleri tarafından gönderilirler. Çalışma zamanı tüm bu nesneler için uygun olayları dinler.

Aşağıdaki olaylar, veri sağlayıcı nesnesinden veri okuma işlemini yürütür:

• Event.OPEN — Çalışma zamanına veri kaynağının hazır olduğunu bildirir.

• ProgressEvent.PROGRESS — Çalışma zamanına verinin geçerli olduğunu bildirir. Çalışma zamanı veri sağlayıcı nesnesinden geçerli veri miktarını okur.

• ProgressEvent.SOCKET_DATA — Çalışma zamanına verinin geçerli olduğunu bildirir. socketData olayları soket temelli nesneler tarafından gönderilir. Diğer nesne türleri için bir progress olayı göndermelisiniz. (Çalışma zamanı, veri okunabilir olduğunda her iki olayın da bunu saptamasını dinler.)

• Event.COMPLETE — Çalışma zamanına verilerin okunduğunu bildirir.

• Event.CLOSE — Çalışma zamanına tüm verilerin okunduğunu bildirir. (Çalışma zamanı bu amaçla hem close ve complete öğesini dinler.)

• IOErrorEvent.IOERROR — Çalışma zamanına veri okuma sırasında bir hata oluştuğunu bildirir. Çalışma zamanı dosya oluşturma işlemini iptal eder ve IFilePromise close() yöntemini çağırır.

• SecurityErrorEvent.SECURITY_ERROR — Çalışma zamanına bir güvenlik hatası oluştuğunu bildirir. Çalışma zamanı dosya oluşturma işlemini iptal eder ve IFilePromise close() yöntemini çağırır.

• HTTPStatusEvent.HTTP_STATUS — Çalışma zamanı tarafından httpResponseStatus ile birlikte geçerli verinin hata mesajı yerine istenilen içeriği gösterdiğinden emin olmak için kullanılır (404 sayfası gibi). Bu olayı HTTP protokolüne bağlı nesneler göndermelidir.

• HTTPStatusEvent.HTTP_RESPONSE_STATUS — Çalışma zamanı tarafından httpStatus ile birlikte geçerli verilerin arzu edilen içeriği gösterdiğinden emin olmak için kullanılır. Bu olayı HTTP protokolüne bağlı nesneler göndermelidir.

Veri sağlayıcı bu olayları aşağıdaki sırada göndermelidir:

1. open olayı

2. progress veya socketData olayları

3. complete veya close olayı

Aşağıdaki örnek, özel, senkronize olmayan veri sağlayıcısı kullanarak dosya izni oluşturur. Veri sağlayıcı sınıfı ByteArray öğesini genişletir (IDataInput desteği için) ve IEventDispatcher arabirimini uygular. Her zamanlayıcı olayında, nesne bir yığın veri oluşturur ve çalışma zamanına verinin geçerli olduğunu haber vermek için ilerleme olayı gönderir. Yeterli veri oluşturulduğunda, nesne tamamlanmış bir olay gönderir.

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 ); 
    } 
} 
}

Senkronize olmayan IFilePromise uygulaması senkronize olan uygulamayla aynıdır. Temel farklar isAsync öğesinin true değerini döndürmesi ve open() yönteminin senkronize olmayan bir veri nesnesini döndürmesidir:

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 ); 
        } 
    } 
}