actionscript 3 लखनऊ आकाशवाणी(एएस 3)-बड़ी फाइल के लिए बड़ी आईपीड एप्लिकेशन डाउनलोड करें




आल इंडिया रेडियो लाइव (2)

सबसे पहले मैं यह निर्दिष्ट करना चाहता हूं कि मैं स्रोत कोड पोस्ट नहीं कर सकता क्योंकि परियोजना बहुत बड़ी है। मैं iPad डिवाइस पर एक बड़ी फ़ाइल (500+ MB) डाउनलोड करने का प्रयास कर रहा हूं। प्रारंभ में मैंने URL लोडर के साथ कोशिश की, लेकिन मुझे एहसास हुआ कि आईपैड उपकरणों की स्मृति के बारे में बहुत सीमित संसाधन हैं मैंने सोचा था कि यूआरएल स्ट्रीम इन फाइलों में फाइल को डाउनलोड करेगा और फाइलस्ट्रीम के साथ मैं इस खंड को डिवाइस पर सहेज सकता हूँ (जैसे कि एएस 3: यूआरऍलस्ट्रीम को डेस्कटॉप पर फाइल सहेजना? ), लेकिन मैं गलत था, जब मैं एक डाउनलोड करने की कोशिश करता हूं तो डिवाइस क्रैश हो जाता है बड़ी फाइल क्योंकि डिवाइस की रैम पर्याप्त नहीं है (अधिक सटीक रूप से यह बहुत बड़ा हो जाता है: System.privateMemory) क्या किसी को भी कोई विचार है कि एक फ़ाइल को विण्डोज़ में कैसे डाउनलोड किया जाए और क्या यह "सॉकेट कनेक्शन" का उपयोग किए बिना संभव है?

अग्रिम में धन्यवाद।

संपादित करें: यहां कोड है जो मैं उपयोग करता हूं (टिप्पणी की गई पंक्तियाँ वह संस्करण हैं जिसमें फाइलस्ट्रीम लास केवल फ़ाइल डाउनलोड होने के बाद बंद हो जाती है।



    package components.streamDownloader
    {
        import flash.events.Event;
        import flash.events.EventDispatcher;
        import flash.events.IOErrorEvent;
        import flash.events.OutputProgressEvent;
        import flash.events.ProgressEvent;
        import flash.events.SecurityErrorEvent;
        import flash.filesystem.File;
        import flash.filesystem.FileMode;
        import flash.filesystem.FileStream;
        import flash.net.URLRequest;
        import flash.net.URLStream;
        import flash.system.System;
        import flash.utils.ByteArray;


    /**
     * 
     */
    public class StreamDownloader extends EventDispatcher
    {

        [Event(name="DownloadComplete", type="com.tatstyappz.net.DownloadEvent")]

        [Event(name="Error", type="com.tatstyappz.net.DownloadEvent")]


        //--------------------------------------------------------------------------
        //
        //  Constructor
        //
        //--------------------------------------------------------------------------

        public function StreamDownloader()
        {

        }


        //--------------------------------------------------------------------------
        //
        //  Variables
        //
        //--------------------------------------------------------------------------

        private var file:File;

        //private var fileStream:FileStream;

        private var urlRequest:URLRequest;

        private var urlStream:URLStream;

        private var waitingForDataToWrite:Boolean = false;


        //--------------------------------------------------------------------------
        //
        //  API
        //
        //--------------------------------------------------------------------------

        public function download(urlRequest:URLRequest, file:File):void {


            init();

            this.urlRequest = urlRequest;
            this.file = file;
            //fileStream.open(file, FileMode.WRITE);
            urlStream.load(urlRequest);
        }   


        //--------------------------------------------------------------------------
        //
        //  Event handlers
        //
        //--------------------------------------------------------------------------    

        //----------------------------------
        //  urlStream events
        //----------------------------------

        protected function urlStream_openHandler(event:Event):void
        {
            waitingForDataToWrite = false;
            dispatchEvent(event.clone());
        }

        protected function urlStream_progressHandler(event:ProgressEvent):void
        {


            trace("MEMORY:", System.totalMemoryNumber / 1024 / 1024, "MEMORY P:", System.privateMemory / 1024 / 1024, "FREE MEMORY:", System.freeMemory / 1024 / 1024, "PROGRESS:", event.bytesLoaded / event.bytesTotal );




            if(waitingForDataToWrite){
                writeToDisk();
            }       
        }

        protected function urlStream_completeHandler(event:Event):void
        {
            if(urlStream.bytesAvailable > 0)
            {
                writeToDisk();
            }
            //fileStream.close();

            destory();

            dispatchEvent(event.clone());

            // dispatch additional DownloadEvent
            dispatchEvent(new StreamDownloadEvent(StreamDownloadEvent.DOWNLOAD_COMPLETE, urlRequest, file));        
        }

        protected function urlStream_securityErrorHandler(event:SecurityErrorEvent):void
        {
            dispatchEvent(new StreamDownloadEvent(StreamDownloadEvent.ERROR, urlRequest, file, event.errorID.toString()));
            destory();
        }

        protected function urlStream_ioErrorHandler(event:IOErrorEvent):void
        {
            dispatchEvent(new StreamDownloadEvent(StreamDownloadEvent.ERROR, urlRequest, file, event.errorID.toString()));
            destory();
        }   


        //----------------------------------
        //  fileStream events
        //----------------------------------

        protected function fileStream_outputProgressHandler(event:OutputProgressEvent):void
        {
            waitingForDataToWrite = true;
        }   

        protected function fileStream_ioErrorHandler(event:IOErrorEvent):void
        {
            dispatchEvent(new StreamDownloadEvent(StreamDownloadEvent.ERROR, urlRequest, file, event.errorID.toString()));
            destory();
        }   


        //--------------------------------------------------------------------------
        //
        //  Utils
        //
        //--------------------------------------------------------------------------

        private function init():void
        {
            urlStream = new URLStream();
            //fileStream = new FileStream();

            urlStream.addEventListener(Event.OPEN, urlStream_openHandler);
            urlStream.addEventListener(ProgressEvent.PROGRESS, urlStream_progressHandler); 
            urlStream.addEventListener(Event.COMPLETE, urlStream_completeHandler);
            urlStream.addEventListener(IOErrorEvent.IO_ERROR, urlStream_ioErrorHandler);
            urlStream.addEventListener(SecurityErrorEvent.SECURITY_ERROR, urlStream_securityErrorHandler);

            //fileStream.addEventListener(OutputProgressEvent.OUTPUT_PROGRESS, fileStream_outputProgressHandler)
            //fileStream.addEventListener(IOErrorEvent.IO_ERROR, fileStream_ioErrorHandler);        
        }

        private function destory():void
        {
            urlStream.removeEventListener(Event.OPEN, urlStream_openHandler);
            urlStream.removeEventListener(ProgressEvent.PROGRESS, urlStream_progressHandler); 
            urlStream.removeEventListener(Event.COMPLETE, urlStream_completeHandler);
            urlStream.removeEventListener(IOErrorEvent.IO_ERROR, urlStream_ioErrorHandler);
            urlStream.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, urlStream_securityErrorHandler);

            //fileStream.removeEventListener(OutputProgressEvent.OUTPUT_PROGRESS, fileStream_outputProgressHandler)
            //fileStream.removeEventListener(IOErrorEvent.IO_ERROR, fileStream_ioErrorHandler); 

            urlStream = null;
            //fileStream = null;
        }

        private function writeToDisk():void {
            /*var fileData:ByteArray = new ByteArray();
            urlStream.readBytes(fileData, 0, urlStream.bytesAvailable);
            fileStream.writeBytes(fileData,0,fileData.length);
            waitingForDataToWrite = false;*/

            var bytes:ByteArray = new ByteArray();
            urlStream.readBytes( bytes );

            var fs:FileStream = new FileStream();
            fs.open( file, FileMode.APPEND );
            fs.writeBytes( bytes );
            fs.close();
        }




    }
    }


https://code.i-harness.com


जैसा कि मैंने अपनी टिप्पणी में csomakk में कहा था, मैंने डेस्कटॉप, आईओएस, और एंड्रॉइड के लिए यूआरएल स्ट्रीम कंचन पद्धति का उपयोग करके आकाशवाणी के माध्यम से 300+ एमबी फ़ाइलों को सफलतापूर्वक डाउनलोड किया है।

छद्म कोड:

var stream:URLStream = new URLStream();
stream.addEventListener( PROGRESS, progressHandler );
stream.addEventListener( COMPLETE, completeHandler );
stream.load( url );

private function progressHandler( e:ProgressEvent ):void {
    this.writeDataToDisk();
}

private function completeHandler( e:Event ):void {
    this.writeDataToDisk();
}

private function writeDataToDisk():void {
    var bytes:ByteArray = new ByteArray();
    this.stream.readBytes( bytes );

    var fs:FileStream = new FileStream();
    fs.open( file, FileMode.APPEND );
    fs.writeBytes( bytes );
    fs.close();
}

यह बुनियादी तर्क काम करता है और 300 एमबी तक काम करता है (और संभवतः आगे। हालांकि मुझे इसका परीक्षण करना चाहिए था, अब मैं इसके बारे में सोचता हूं)। यह काफी तेज़ी से लिखा गया था इसलिए कुछ त्रुटियां हो सकती हैं और मैंने निश्चित रूप से कुछ चीजों को छिपाने के लिए कहा था, लेकिन आपको यह विचार मिलता है।

अगर यह काम नहीं करता है, तो हमें आपके द्वारा कुछ चीजें चाहिए:

  1. किसी भी त्रुटि पोस्ट करें
  2. fs.close() बाद file.size / 1024 / 1024 + "MB" fs.close() और क्रैश होने से पहले कितनी दूर हो
  3. ट्रेस आउट सिस्टम System.memory / 1024 / 1024 + "MB" after the स्मृती / 1024/1024 System.memory / 1024 / 1024 + "MB" after the fs.close () `इसलिए हम मेमोरी उपयोग की निगरानी कर सकते हैं

दुर्घटना होने से पहले 2 और 3 के लिए हमें केवल अंतिम ट्रेस स्टेटमेंट की आवश्यकता होती है

वैकल्पिक रूप से, आपको यह पता होना चाहिए कि आप आवेदन में उस 500MB फ़ाइल के साथ कुछ भी करने में सक्षम नहीं होंगे। फ्लैश बस इसके आकार की वजह से इसे लोड नहीं करेगा एकमात्र कारण है कि मैंने अपनी 300MB वीडियो फाइलों को दूर करने में कामयाब रहा है कि हम उन्हें डिस्क से स्ट्रीमिंग कर रहे थे, पूरी चीजों को स्मृति में संग्रहीत नहीं करते


चूंकि मुझे किसी कारण के लिए जोश के जवाब के तहत टिप्पणी करने की इजाजत नहीं है, मैं अपने संस्करण को एक अलग जवाब के रूप में जोड़ रहा हूं। लेकिन यह बहुत ही उनके सुझाव पर आधारित है। यह कोड गिटहब के साथ भी यहां उपलब्ध है: https://github.com/shishenkov/ActionscriptClasses/blob/master/us/flashmx/net/LargeFileLoader.as

पूर्वापेक्षा - यूआरएल स्ट्रीम एक भयानक वर्ग है, लेकिन इसमें एक गड़बड़ी है जिससे बड़ी फ़ाइलों को ठीक से लोड होने से रोकने के लिए मेमोरी रिसाव / बिल्डअप का कारण बनता है। मैं यहाँ साझा कर रहा हूँ वर्ग का परीक्षण किया गया है और एक मुद्दा बिना बिना एक आईपैड एयर 2 (64 जीबी) में 1.5GB फ़ाइलों का अनुक्रम डाउनलोड करने में सक्षम था। मुझे लगता है कि बड़ी फ़ाइलों को भी ठीक हो जाएगा, चूंकि यह वास्तव में रैम भंडारण सीमा पर काबू पाता है (गड़बड़ी से पहले इसे 200 एमबी के आसपास क्रैश हो रहा था)।

गड़बड़ - कच्चे डेटा बायटैरेअरे, जहां आप लोड बाइट्स की प्रतिलिपि बनाते हैं, कभी जीसी द्वारा निपटा नहीं जाता (जैसा कि यहां बताया गया है: http://blogs.splunk.com/2007/11/16/flashas3-urlstream-memory-leak/ ) इसलिए, समाधान जोश की तकनीक का उपयोग करता है एक वर्ग को लागू करने के लिए है और यह सुनिश्चित करता है कि लिखने के बाद बाइट का निपटारा किया जाता है।

... यहाँ कोड है (नोट: यह अभी भी पूर्व-उत्पादन है):

package us.flashmx.net 
{
    import flash.events.ErrorEvent;
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.HTTPStatusEvent;
    import flash.events.IEventDispatcher;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;
    import flash.events.SecurityErrorEvent;
    import flash.filesystem.File;
    import flash.filesystem.FileMode;
    import flash.filesystem.FileStream;
    import flash.net.URLRequest;
    import flash.net.URLStream;
    import flash.system.System;
    import flash.utils.ByteArray;

    /**
     * ...
     * @author  Nick Shishenkov <[email protected]>
     */
    public class LargeFileLoader extends EventDispatcher 
    {
        private var _url:String             = "";
        private var _filePath:String        = "";
        private var _fileStream:FileStream  = new FileStream;
        private var _urlStream:URLStream    = new URLStream;
        private var _localFile:File;
        private var _bytesLoaded:Number;

        public function LargeFileLoader() 
        {
            super(null);

            //
            _urlStream.addEventListener(Event.OPEN, _onOpen, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(ProgressEvent.PROGRESS, _onProgress, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(Event.COMPLETE, _onComplete, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(IOErrorEvent.IO_ERROR, _onError, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(SecurityErrorEvent.SECURITY_ERROR, _onSecurityError, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(HTTPStatusEvent.HTTP_RESPONSE_STATUS, _onHTTPStatus, false, int.MIN_VALUE, true);
            _urlStream.addEventListener(HTTPStatusEvent.HTTP_STATUS, _onHTTPStatus, false, int.MIN_VALUE, true);
        }

        private function _onHTTPStatus(e:HTTPStatusEvent):void 
        {
            dispatchEvent(e.clone());
        }

        public function load(remoteURL:String, localPath:String, overwrite:Boolean = true):void
        {
            _url        = remoteURL;
            _filePath   = localPath;
            //
            _localFile      = new File(_filePath);
            _bytesLoaded    = 0;

            //
            if (overwrite && _localFile.exists)
            {
                _localFile.deleteFile();
            }
            //
            _urlStream.load(new URLRequest(url));
            _fileStream.open(_localFile, FileMode.APPEND);
        }

        private function _onOpen(e:Event):void 
        {
            dispatchEvent(e.clone());
        }

        private function _onSecurityError(e:SecurityErrorEvent):void 
        {
            dispatchEvent(e.clone());
        }

        private function _onError(e:IOErrorEvent):void 
        {
            dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, e.text));
        }

        private function _onProgress(e:ProgressEvent):void 
        {
            //
            trace(" -> _onProgress: " + _urlStream.length + " | " + e.bytesLoaded + " / " + e.bytesTotal);
            //
            _writeStreamBytes();
            //
            dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS, false, false, e.bytesLoaded, e.bytesTotal));
        }

        private function _onComplete(e:Event):void 
        {
            _writeStreamBytes();
            //
            dispatchEvent(new Event(Event.COMPLETE));
        }

        private function _writeStreamBytes():void
        {
            var bytes:ByteArray = new ByteArray();
            _urlStream.readBytes( bytes );
            _fileStream.writeBytes( bytes );

            //
            _bytesLoaded    += bytes.length;

            //clear buffer (if the array stays non-null it will lead to a memmory leak
            bytes   = null;

        }

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

        public function get filePath():String 
        {
            return _filePath;
        }

        public function get bytesLoaded():Number 
        {
            //_localFile.size;
            return _bytesLoaded;
        }


        public function dispose():void
        {
            try{ _fileStream.close(); }catch (err:Error){};

            //
            try{ _urlStream.close(); }catch (err:Error){};

            //
            _urlStream.removeEventListener(Event.OPEN, _onOpen);
            _urlStream.removeEventListener(ProgressEvent.PROGRESS, _onProgress);
            _urlStream.removeEventListener(Event.COMPLETE, _onComplete);
            _urlStream.removeEventListener(IOErrorEvent.IO_ERROR, _onError);
            _urlStream.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, _onSecurityError);
            _urlStream.removeEventListener(HTTPStatusEvent.HTTP_RESPONSE_STATUS, _onHTTPStatus);
            _urlStream.removeEventListener(HTTPStatusEvent.HTTP_STATUS, _onHTTPStatus);

            //
            _urlStream  = null;
            _fileStream = null;

            //
            System.gc();
        }
    }

}

मैंने स्काउट सीसी के साथ कई डिवाइस परीक्षण चलाए और स्मृति हर समय बनी रहती है (कोई भी buildups नहीं)। मैं बाद में इस सप्ताह के कुछ पुराने आईओएस उपकरणों का परीक्षण करूँगा। रिकॉर्ड के लिए: मैं एडोब एयर 24.0.0.180 का इस्तेमाल कर रहा हूं

यहाँ एक नमूना उपयोग है:

package us.flashmx.net 
{
    import flash.display.DisplayObject;
    import flash.events.Event;
    import flash.events.ProgressEvent;

    /**
     * ...
     * @author ...
     */
    public class LargeFileLoader_DEMO extends DisplayObject 
    {
        private var _largeFilesLoader:LargeFileLoader;

        public function LargeFileLoader_DEMO() 
        {
            super();
            //
            init_largeFilesLoader("http://A.Large.File.URL/", "/The/Absolute/Local/Path");
        }

        public function dispose_largeFilesLoader():void
        {
            //
            if (_largeFilesLoader != null)
            {
                //clear listeners
                _largeFilesLoader.removeEventListener(ProgressEvent.PROGRESS, _onFileLoaderProgress);
                _largeFilesLoader.removeEventListener(Event.COMPLETE, _onFileLoaderComplete);
                //dispose
                _largeFilesLoader.dispose();
                //free mem
                _largeFilesLoader   = null;
            }           
        }

        private function init_largeFilesLoader(fURL:String, fPath:String):void
        {
            //
            _largeFilesLoader   = new LargeFileLoader;

            //
            _largeFilesLoader.addEventListener(ProgressEvent.PROGRESS, _onFileLoaderProgress, false, int.MIN_VALUE, true);
            _largeFilesLoader.addEventListener(Event.COMPLETE, _onFileLoaderComplete, false, int.MIN_VALUE, true);

            //
            _largeFilesLoader.load(fURL, fPath);
        }

        private function _onFileLoaderComplete(e:Event):void 
        {
            trace("All done!");
            dispose_largeFilesLoader();
        }

        private function _onFileLoaderProgress(e:ProgressEvent):void 
        {
            _largeFilesLoader.bytesLoaded;
        }
    }

}

... मुझे आशा है कि वह मदद करेंगे !

चियर्स -निक