Flash, accediendo a TotalBytes antes de cargar el archivo.

Question

Estoy buscando una forma sencilla de encontrar el tamaño de los archivos que planeo cargar sin cargarlos todavía. Básicamente, estoy haciendo un lote de archivos que deben cargarse y sería muy útil si pudiera determinar de antemano qué tan grande será la carga total.

el objeto Loader en flash tiene una propiedad totalBytes, pero eso solo devolverá un valor cuando ya esté cargando un archivo.

Answer 1

Por cargado, ¿te refieres completamente cargado o sin carga de llamada? Si una llamada de carga es aceptable, lo siguiente podría ser útil. El evento de progreso indica el tamaño total de los datos entrantes en el primer disparo. Simplemente dejamos que se desencadene un evento de progreso determinado, tomamos el valor total del elemento de carga actual y lo agregamos a nuestra propia variable _total; Continuamos esto hasta que nuestro proveedor de datos (array, xml, etc.) esté vacío. al final tienes la suma de todos los totales de tus activos.

package
{
    import flash.display.Sprite;
    import flash.display.Loader;
    import flash.events.Event;
    import flash.events.ProgressEvent;
    import flash.URLLoader;
    import flash.URLRequest;

    public class ExampleDocumentClass extends Sprite
    {
        private var _urlLoader:URLLoader;
        private var _loader:Loader;
        private var _request:URLRequest;
        private var _total:Number;
        private var _array:Array;

        public function ExampleDocumentClass():void
        {
            if(stage) _init;
            else addEventListener(Event.ADDED_TO_STAGE, _init);
        }
        private function _init(e:Event = null):void
        {
            _array = [{type:"nonDisplay", path:"path/to/file"},{type:"display", path:"path/to/file"}];
            _urlRequest = new URLRequest();

            //Non display asset
             _urlLoader = new URLLoader();
            _urlLoader.addEventListener(ProgressEvent.PROGRESS, _onProgress);

            //Display asset
            _loader = new Loader();

            loadAsset();
        }
        private function loadAsset():void
        {
            if(_array.length > 0)
            {
                var pObj:Object = _array[0];
                if(pObj.type == "nonDisplay")
                {
                    loadNonDisplayAsset(pObj.path);
                }
                else
                {
                    loadDisplayAsset(pObj.path);
                }
                //Remove this item from the array;
                _array.shift();
            }
        }
        private function loadNonDisplayAsset(pAsset:String):void
        {
            _urlRequest.url = pAsset;
            _urlLoader.load(_urlRequest);
        }
        private function loadDisplayAsset(pAsset:String):void
        {
            _urlRequest.url = pAsset;
            _loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, _onProgress);
            _loader.load(_urlRequest);
        }
        private function _onProgress(e:ProgressEvent):void
        {
            _total += e.bytesTotal;
            _loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS, _onProgress);
            _urlLoader.removeEventListener(ProgressEvent.PROGRESS, _onProgress);
        }
    }
}

Por lo tanto, cargamos un activo el tiempo suficiente para adjuntar su Tamaño total, a nuestra propia variable _total y luego llamamos al siguiente elemento de la matriz y agregamos su total hasta que el proveedor de datos esté vacío. Obviamente, esto podría hacerse con XML, o como desee, una matriz es justo lo que usé para el ejercicio.

Answer 2

No hay forma de obtener el tamaño de un archivo antes de Actionscript 3 . Una solución fácil sería agregar un pequeño script al servidor que escanea todos los archivos y devuelve sus nombres y su tamaño al swf (como JSON o XML o lo que sea) .

Answer 3

No hay forma de hacer esto en ActionScript. Necesitará algún código del lado del servidor para hacer esto. Podría crear un método que tome un nombre de archivo y devuelva el total de bytes.

Answer 4

No sé cómo haría esto con ActionScript (no soy Gurú), pero mi primera suposición sería utilizar un script PHP (o cualquier otro lenguaje de scripting de su elección) para obtener los tamaños de archivo y regresar. los valores.

Answer 5

Otra forma (probablemente excesiva) sería crear algo que simplemente solicite al servidor los encabezados del archivo (incluido el tamaño del archivo). Lo mismo se podría lograr simplemente comenzando a descargar el archivo y cerrando la secuencia cuando tenga el tamaño del archivo (debería ser bastante rápido) o teniendo (como se sugirió antes) otra forma de pedirle al servidor el tamaño del archivo (útil si está cargando varios archivos y necesita saber el tamaño del archivo antes de cargar)

Answer 6

He experimentado con el método proporcionado por Brian Hodge, así como con otro método en el que envié variables (ubicaciones de carpetas como cadenas desde XML) a PHP para obtener el tamaño combinado de todos los archivos dentro de una carpeta en particular y regresar. Los datos a Flash.

¡Un problema importante que encontré en mi viaje a precargar el paraíso fue que Flash Player parece producir resultados inconsistentes con respecto al tamaño del archivo! Incluso si hubiera cargado exactamente los mismos archivos dos veces, Flash me diría que tenían tamaños diferentes ... a veces.

Esto también causó problemas con el método alternativo (PHP), ya que la secuencia de comandos PHP produciría (aparentemente) resultados de tamaño de archivo precisos que eran inconsistentes con los producidos por Flash, lo que provocó que mi cargador se vaya al 85% o 128%, dependiente sobre el almacenamiento en caché y el estado de ánimo de Flash: /

Deseché ambos métodos en favor de una buena clase llamada bulk-loader , que permite la carga en cola y el seguimiento del progreso de varios elementos, y mucho más: D

Tenga en cuenta que aumentará significativamente el tamaño de su archivo SWF ... qué irónico